Chameleon

Chameleon Svn Source Tree

Root/branches/xZenu/src/util/doxygen/qtools/qgstring.cpp

Source at commit 1322 created 9 years 5 months ago.
By meklort, Add doxygen to utils folder
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2004 by Dimitri van Heesch.
4 *
5 * Permission to use, copy, modify, and distribute this software and its
6 * documentation under the terms of the GNU General Public License is hereby
7 * granted. No representations are made about the suitability of this software
8 * for any purpose. It is provided "as is" without express or implied warranty.
9 * See the GNU General Public License for more details.
10 *
11 * Documents produced by Doxygen are derivative works derived from the
12 * input used in their production; they are not affected by this license.
13 *
14 */
15
16#include <stdio.h>
17#include "qgstring.h"
18
19#include <assert.h>
20
21#define BLOCK_SIZE 64
22#define ROUND_SIZE(x) ((x)+BLOCK_SIZE-1)&~(BLOCK_SIZE-1)
23
24#define DBG_STR(x) do { } while(0)
25//#define DBG_STR(x) printf x
26
27QGString::QGString() // make null string
28 : m_data(0), m_len(0), m_memSize(0)
29{
30 DBG_STR(("%p: QGString::QGString() %d:%s\n",this,m_len,m_data?m_data:"<none>"));
31}
32
33QGString::QGString(uint size)
34{
35 if (size==0)
36 {
37 m_data=0;
38 m_len=0;
39 }
40 else
41 {
42 m_memSize = ROUND_SIZE(size+1);
43 m_data = (char*)malloc(m_memSize);
44 memset(m_data,' ',size);
45 m_data[size]='\0';
46 m_len=size;
47 }
48 DBG_STR(("%p: QGString::QGString(uint size=%d) %d:%s\n",
49 this,size,m_len,m_data?m_data:"<none>"));
50}
51
52QGString::QGString( const QGString &s )
53{
54 if (s.m_memSize==0)
55 {
56 m_data = 0;
57 m_len = 0;
58 m_memSize = 0;
59 }
60 else
61 {
62 m_data = (char *)malloc(s.m_memSize);
63 m_len = s.m_len;
64 m_memSize = s.m_memSize;
65 qstrcpy(m_data,s.m_data);
66 }
67 DBG_STR(("%p: QGString::QGString(const QGString &) %d:%s\n",this,m_len,m_data?m_data:"<none>"));
68}
69
70QGString::QGString( const char *str )
71{
72 if (str==0)
73 {
74 m_data=0;
75 m_len=0;
76 m_memSize=0;
77 }
78 else
79 {
80 m_len = qstrlen(str);
81 m_memSize = ROUND_SIZE(m_len+1);
82 assert(m_memSize>=m_len+1);
83 m_data = (char *)malloc(m_memSize);
84 qstrcpy(m_data,str);
85 }
86 DBG_STR(("%p: QGString::QGString(const char *) %d:%s\n",this,m_len,m_data?m_data:"<none>"));
87}
88
89QGString::~QGString()
90{
91 free(m_data);
92 m_data=0;
93 DBG_STR(("%p: QGString::~QGString() %d:%s\n",this,m_len,m_data?m_data:"<none>"));
94}
95
96bool QGString::resize( uint newlen )
97{
98 m_len = 0;
99 if (newlen==0)
100 {
101 if (m_data) { free(m_data); m_data=0; }
102 m_memSize=0;
103 DBG_STR(("%p: 1.QGString::resize() %d:%s\n",this,m_len,m_data?m_data:"<none>"));
104 return TRUE;
105 }
106 m_memSize = ROUND_SIZE(newlen+1);
107 assert(m_memSize>=newlen+1);
108 if (m_data==0)
109 {
110 m_data = (char *)malloc(m_memSize);
111 }
112 else
113 {
114 m_data = (char *)realloc(m_data,m_memSize);
115 }
116 if (m_data==0)
117 {
118 DBG_STR(("%p: 2.QGString::resize() %d:%s\n",this,m_len,m_data?m_data:"<none>"));
119 return FALSE;
120 }
121 m_data[newlen]='\0';
122 m_len = qstrlen(m_data);
123 DBG_STR(("%p: 3.QGString::resize() %d:%s\n",this,m_len,m_data?m_data:"<none>"));
124 return TRUE;
125}
126
127bool QGString::enlarge( uint newlen )
128{
129 if (newlen==0)
130 {
131 if (m_data) { free(m_data); m_data=0; }
132 m_memSize=0;
133 m_len=0;
134 return TRUE;
135 }
136 uint newMemSize = ROUND_SIZE(newlen+1);
137 if (newMemSize==m_memSize) return TRUE;
138 m_memSize = newMemSize;
139 if (m_data==0)
140 {
141 m_data = (char *)malloc(m_memSize);
142 }
143 else
144 {
145 m_data = (char *)realloc(m_data,m_memSize);
146 }
147 if (m_data==0)
148 {
149 return FALSE;
150 }
151 m_data[newlen-1]='\0';
152 if (m_len>newlen) m_len=newlen;
153 return TRUE;
154}
155
156void QGString::setLen( uint newlen )
157{
158 m_len = newlen<=m_memSize ? newlen : m_memSize;
159}
160
161QGString &QGString::operator=( const QGString &s )
162{
163 if (m_data) free(m_data);
164 if (s.m_memSize==0) // null string
165 {
166 m_data = 0;
167 m_len = 0;
168 m_memSize = 0;
169 }
170 else
171 {
172 m_len = s.m_len;
173 m_memSize = s.m_memSize;
174 m_data = (char*)malloc(m_memSize);
175 qstrcpy(m_data,s.m_data);
176 }
177 DBG_STR(("%p: QGString::operator=(const QGString &%p) %d:%s\n",
178 this,&s,m_len,m_data?m_data:"<none>"));
179 return *this;
180}
181
182QGString &QGString::operator=( const char *str )
183{
184 if (m_data) free(m_data);
185 if (str==0) // null string
186 {
187 m_data = 0;
188 m_len = 0;
189 m_memSize = 0;
190 }
191 else
192 {
193 m_len = qstrlen(str);
194 m_memSize = ROUND_SIZE(m_len+1);
195 assert(m_memSize>=m_len+1);
196 m_data = (char*)malloc(m_memSize);
197 qstrcpy(m_data,str);
198 }
199 DBG_STR(("%p: QGString::operator=(const char *) %d:%s\n",this,m_len,m_data?m_data:"<none>"));
200 return *this;
201}
202
203QGString &QGString::operator+=( const QGString &s )
204{
205 if (s.m_memSize==0) return *this;
206 uint len1 = length();
207 uint len2 = s.length();
208 uint memSize = ROUND_SIZE(len1 + len2 + 1);
209 assert(memSize>=len1+len2+1);
210 char *newData = memSize!=m_memSize ? (char*)realloc( m_data, memSize ) : m_data;
211 m_memSize = memSize;
212 if (m_data)
213 {
214 m_data = newData;
215 memcpy( m_data + len1, s, len2 + 1 );
216 }
217 m_len = len1+len2;
218 DBG_STR(("%p: QGString::operator+=(const QGString &) %d:%s\n",this,m_len,m_data?m_data:"<none>"));
219 return *this;
220}
221
222QGString &QGString::operator+=( const char *str )
223{
224 if (!str) return *this;
225 uint len1 = length();
226 uint len2 = qstrlen(str);
227 uint memSize = ROUND_SIZE(len1 + len2 + 1);
228 assert(memSize>=len1+len2+1);
229 char *newData = memSize!=m_memSize ? (char *)realloc( m_data, memSize ) : m_data;
230 m_memSize = memSize;
231 if (newData)
232 {
233 m_data = newData;
234 memcpy( m_data + len1, str, len2 + 1 );
235 }
236 m_len+=len2;
237 DBG_STR(("%p: QGString::operator+=(const char *) %d:%s\n",this,m_len,m_data?m_data:"<none>"));
238 return *this;
239}
240
241QGString &QGString::operator+=( char c )
242{
243 uint len = m_len;
244 uint memSize = ROUND_SIZE(len+2);
245 assert(memSize>=len+2);
246 char *newData = memSize!=m_memSize ? (char *)realloc( m_data, memSize ) : m_data;
247 m_memSize = memSize;
248 if (newData)
249 {
250 m_data = newData;
251 m_data[len] = c;
252 m_data[len+1] = '\0';
253 }
254 m_len++;
255 DBG_STR(("%p: QGString::operator+=(char s) %d:%s\n",this,m_len,m_data?m_data:"<none>"));
256 return *this;
257}
258
259

Archive Download this file

Revision: 1322