b311480e |
1 | // Created on: 2001-06-26 |
2 | // Created by: Alexander GRIGORIEV |
973c2be1 |
3 | // Copyright (c) 2001-2014 OPEN CASCADE SAS |
b311480e |
4 | // |
973c2be1 |
5 | // This file is part of Open CASCADE Technology software library. |
b311480e |
6 | // |
d5f74e42 |
7 | // This library is free software; you can redistribute it and/or modify it under |
8 | // the terms of the GNU Lesser General Public License version 2.1 as published |
973c2be1 |
9 | // by the Free Software Foundation, with special exception defined in the file |
10 | // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT |
11 | // distribution for complete text of the license and disclaimer of any warranty. |
b311480e |
12 | // |
973c2be1 |
13 | // Alternatively, this file may be used under the terms of Open CASCADE |
14 | // commercial license or contractual agreement. |
7fd59977 |
15 | |
16 | #include <LDOMBasicString.hxx> |
17 | #include <LDOM_MemManager.hxx> |
18 | #include <TCollection_AsciiString.hxx> |
19 | #include <TCollection_ExtendedString.hxx> |
20 | #include <errno.h> |
21 | |
22 | //======================================================================= |
23 | //function : LDOMString |
24 | //purpose : Create a free string (not connected to any type of container) |
25 | //======================================================================= |
26 | |
27 | LDOMBasicString::LDOMBasicString (const char * aValue) |
28 | { |
29 | if (aValue == NULL /*|| aValue[0] == '\0'*/) { |
30 | myType = LDOM_NULL; |
31 | myVal.ptr = NULL; |
32 | } else { |
33 | myType = LDOM_AsciiFree; |
60be1f9b |
34 | Standard_Size aLen = strlen (aValue) + 1; |
7fd59977 |
35 | myVal.ptr = new char [aLen]; |
36 | memcpy (myVal.ptr, aValue, aLen); |
37 | } |
38 | } |
39 | |
40 | //======================================================================= |
41 | //function : LDOMString |
42 | //purpose : Create an Ascii string managed by LDOM_Document |
43 | //======================================================================= |
44 | |
45 | LDOMBasicString::LDOMBasicString (const char * aValue, |
46 | const Handle(LDOM_MemManager)& aDoc) |
47 | { |
48 | if (aValue == NULL /*|| aValue[0] == '\0'*/) { |
49 | myType = LDOM_NULL; |
50 | myVal.ptr = NULL; |
51 | } else { |
52 | myType = LDOM_AsciiDoc; |
60be1f9b |
53 | Standard_Integer aLen = (Standard_Integer) strlen (aValue) + 1; |
7fd59977 |
54 | myVal.ptr = aDoc -> Allocate (aLen); |
55 | memcpy (myVal.ptr, aValue, aLen); |
56 | } |
57 | } |
58 | |
59 | //======================================================================= |
60 | //function : LDOMString |
61 | //purpose : Create an Ascii string managed by LDOM_Document |
62 | //======================================================================= |
63 | |
64 | LDOMBasicString::LDOMBasicString (const char * aValue, |
65 | const Standard_Integer aLen, |
66 | const Handle(LDOM_MemManager)& aDoc) |
67 | { |
68 | if (aValue == NULL || aLen == 0) { |
69 | myType = LDOM_NULL; |
70 | myVal.ptr = NULL; |
71 | } else { |
72 | myType = LDOM_AsciiDoc; |
73 | myVal.ptr = aDoc -> Allocate (aLen + 1); |
74 | memcpy (myVal.ptr, aValue, aLen); |
75 | ((char *)myVal.ptr)[aLen] = '\0'; |
76 | } |
77 | } |
78 | |
79 | //======================================================================= |
80 | //function : LDOMBasicString |
81 | //purpose : Copy constructor |
82 | //======================================================================= |
83 | |
84 | LDOMBasicString::LDOMBasicString (const LDOMBasicString& anOther) |
85 | : myType (anOther.Type()) |
86 | { |
87 | switch (myType) { |
88 | case LDOM_AsciiFree: |
89 | if (anOther.myVal.ptr) { |
60be1f9b |
90 | Standard_Size aLen = strlen ((const char *)anOther.myVal.ptr) + 1; |
7fd59977 |
91 | myVal.ptr = new char [aLen]; |
92 | memcpy (myVal.ptr, anOther.myVal.ptr, aLen); |
93 | break; |
94 | } |
95 | case LDOM_AsciiDoc: |
96 | case LDOM_AsciiDocClear: |
97 | case LDOM_AsciiHashed: |
98 | myVal.ptr = anOther.myVal.ptr; |
99 | break; |
100 | case LDOM_Integer: |
101 | myVal.i = anOther.myVal.i; |
102 | default: ; |
103 | } |
104 | } |
105 | |
106 | //======================================================================= |
107 | //function : ~LDOMString() |
108 | //purpose : Destructor |
109 | //======================================================================= |
110 | |
111 | LDOMBasicString::~LDOMBasicString () |
112 | { |
113 | if (myType == LDOM_AsciiFree) { |
114 | if (myVal.ptr) |
115 | delete [] (char *) myVal.ptr; |
116 | } |
117 | } |
118 | |
119 | //======================================================================= |
120 | //function : operator = |
121 | //purpose : Assignment to NULL |
122 | //======================================================================= |
123 | |
124 | LDOMBasicString& LDOMBasicString::operator = (const LDOM_NullPtr *) |
125 | { |
126 | if (myType == LDOM_AsciiFree && myVal.ptr) |
127 | delete [] (char *) myVal.ptr; |
128 | myType = LDOM_NULL; |
129 | myVal.ptr = NULL; |
130 | return * this; |
131 | } |
132 | |
133 | //======================================================================= |
134 | //function : operator = |
135 | //purpose : Assignment |
136 | //======================================================================= |
137 | |
138 | LDOMBasicString& LDOMBasicString::operator = (const LDOMBasicString& anOther) |
139 | { |
140 | if (myType == LDOM_AsciiFree && myVal.ptr) |
141 | delete [] (char *) myVal.ptr; |
142 | myType = anOther.Type(); |
143 | switch (myType) { |
144 | case LDOM_AsciiFree: |
145 | if (anOther.myVal.ptr) { |
60be1f9b |
146 | Standard_Size aLen = strlen ((const char *)anOther.myVal.ptr) + 1; |
7fd59977 |
147 | myVal.ptr = new char [aLen]; |
148 | memcpy (myVal.ptr, anOther.myVal.ptr, aLen); |
149 | break; |
150 | } |
151 | case LDOM_AsciiDoc: |
152 | case LDOM_AsciiDocClear: |
153 | case LDOM_AsciiHashed: |
154 | myVal.ptr = anOther.myVal.ptr; |
155 | break; |
156 | case LDOM_Integer: |
157 | myVal.i = anOther.myVal.i; |
158 | default: ; |
159 | } |
160 | return * this; |
161 | } |
162 | |
163 | //======================================================================= |
164 | //function : equals |
165 | //purpose : Compare two strings by content |
166 | //======================================================================= |
167 | |
168 | Standard_Boolean LDOMBasicString::equals (const LDOMBasicString& anOther) const |
169 | { |
170 | Standard_Boolean aResult = Standard_False; |
171 | switch (myType) |
172 | { |
173 | case LDOM_NULL: |
174 | return (anOther == NULL); |
175 | case LDOM_Integer: |
176 | switch (anOther.Type()) |
177 | { |
178 | case LDOM_Integer: |
179 | return (myVal.i == anOther.myVal.i); |
180 | case LDOM_AsciiFree: |
181 | case LDOM_AsciiDoc: |
182 | case LDOM_AsciiDocClear: |
183 | case LDOM_AsciiHashed: |
184 | { |
185 | long aLongOther = strtol ((const char *) anOther.myVal.ptr, NULL, 10); |
186 | return (errno == 0 && aLongOther == long(myVal.i)); |
187 | } |
188 | case LDOM_NULL: |
189 | default: |
190 | ; |
191 | } |
192 | break; |
193 | default: |
194 | switch (anOther.Type()) |
195 | { |
196 | case LDOM_Integer: |
197 | { |
198 | long aLong = strtol ((const char *) myVal.ptr, NULL, 10); |
199 | return (errno == 0 && aLong == long(anOther.myVal.i)); |
200 | } |
201 | case LDOM_AsciiFree: |
202 | case LDOM_AsciiDoc: |
203 | case LDOM_AsciiDocClear: |
204 | case LDOM_AsciiHashed: |
205 | return (strcmp ((const char *) myVal.ptr, |
206 | (const char *) anOther.myVal.ptr) == 0); |
207 | case LDOM_NULL: |
208 | default: |
209 | ; |
210 | } |
211 | } |
212 | return aResult; |
213 | } |
214 | |
215 | //======================================================================= |
216 | //function : operator TCollection_AsciiString |
217 | //purpose : |
218 | //======================================================================= |
219 | |
220 | LDOMBasicString::operator TCollection_AsciiString () const |
221 | { |
222 | switch (myType) { |
223 | case LDOM_Integer: |
224 | return TCollection_AsciiString (myVal.i); |
225 | case LDOM_AsciiFree: |
226 | case LDOM_AsciiDoc: |
227 | case LDOM_AsciiDocClear: |
228 | case LDOM_AsciiHashed: |
229 | return TCollection_AsciiString (Standard_CString(myVal.ptr)); |
230 | default: ; |
231 | } |
232 | return TCollection_AsciiString (); |
233 | } |
234 | |
235 | //======================================================================= |
236 | //function : operator TCollection_ExtendedString |
237 | //purpose : |
238 | //======================================================================= |
239 | |
240 | LDOMBasicString::operator TCollection_ExtendedString () const |
241 | { |
242 | switch (myType) { |
243 | case LDOM_Integer: |
244 | return TCollection_ExtendedString (myVal.i); |
245 | case LDOM_AsciiFree: |
246 | case LDOM_AsciiDoc: |
247 | case LDOM_AsciiDocClear: |
248 | case LDOM_AsciiHashed: |
249 | { |
250 | char buf[6] = {'\0','\0','\0','\0','\0','\0'}; |
251 | const long aUnicodeHeader = 0xfeff; |
252 | Standard_CString ptr = Standard_CString (myVal.ptr); |
253 | errno = 0; |
254 | // Check if ptr is ascii string |
255 | if (ptr[0] != '#' || ptr[1] != '#') |
256 | return TCollection_ExtendedString (ptr); |
257 | buf[0] = ptr[2]; |
258 | buf[1] = ptr[3]; |
259 | buf[2] = ptr[4]; |
260 | buf[3] = ptr[5]; |
261 | if (strtol (&buf[0], NULL, 16) != aUnicodeHeader) |
262 | return TCollection_ExtendedString (ptr); |
263 | |
264 | // convert Unicode to Extended String |
265 | ptr += 2; |
60be1f9b |
266 | Standard_Size aLength = (strlen(ptr) / 4), j = 0; |
7fd59977 |
267 | Standard_ExtCharacter * aResult = new Standard_ExtCharacter[aLength--]; |
268 | while (aLength--) { |
269 | ptr += 4; |
270 | buf[0] = ptr[0]; |
271 | buf[1] = ptr[1]; |
272 | buf[2] = ptr[2]; |
273 | buf[3] = ptr[3]; |
274 | aResult[j++] = Standard_ExtCharacter (strtol (&buf[0], NULL, 16)); |
275 | if (errno) { |
276 | delete [] aResult; |
277 | return TCollection_ExtendedString(); |
278 | } |
279 | } |
280 | aResult[j] = 0; |
281 | TCollection_ExtendedString aResultStr (aResult); |
282 | delete [] aResult; |
283 | return aResultStr; |
284 | } |
285 | default: ; |
286 | } |
287 | return TCollection_ExtendedString(); |
288 | } |
289 | |
290 | //======================================================================= |
291 | //function : GetInteger |
292 | //purpose : Conversion to Integer |
293 | //======================================================================= |
294 | |
295 | Standard_Boolean LDOMBasicString::GetInteger (Standard_Integer& aResult) const |
296 | { |
297 | switch (myType) { |
298 | case LDOM_Integer: |
299 | aResult = myVal.i; |
300 | break; |
301 | case LDOM_AsciiFree: |
302 | case LDOM_AsciiDoc: |
303 | case LDOM_AsciiDocClear: |
304 | case LDOM_AsciiHashed: |
305 | { |
306 | char * ptr; |
307 | long aValue = strtol ((const char *)myVal.ptr, &ptr, 10); |
308 | if (ptr == myVal.ptr || errno == ERANGE || errno == EINVAL) |
309 | return Standard_False; |
310 | aResult = Standard_Integer (aValue); |
311 | break; |
312 | } |
313 | default: |
314 | return Standard_False; |
315 | } |
316 | return Standard_True; |
317 | } |
318 | |
0797d9d3 |
319 | #ifdef OCCT_DEBUG |
57c28b61 |
320 | #ifndef _MSC_VER |
7fd59977 |
321 | //======================================================================= |
322 | // Debug Function for DBX: use "print -p <Variable> or pp <Variable>" |
323 | //======================================================================= |
324 | #include <LDOM_OSStream.hxx> |
325 | #define FLITERAL 0x10 |
326 | char * db_pretty_print (const LDOMBasicString * aString, int fl, char *) |
327 | { |
328 | LDOM_OSStream out (128); |
329 | const char * str; |
330 | switch (aString -> myType) { |
331 | case LDOMBasicString::LDOM_Integer: |
332 | if ((fl & FLITERAL) == 0) out << "LDOM_Integer: "; |
333 | out << '\"' << aString -> myVal.i << '\"'; goto finis; |
334 | case LDOMBasicString::LDOM_AsciiFree: |
335 | if ((fl & FLITERAL) == 0) out << "LDOM_AsciiFree: "; |
336 | break; |
337 | case LDOMBasicString::LDOM_AsciiDoc: |
338 | if ((fl & FLITERAL) == 0) out << "LDOM_AsciiDoc: "; |
339 | break; |
340 | case LDOMBasicString::LDOM_AsciiDocClear: |
341 | if ((fl & FLITERAL) == 0) out << "LDOM_AsciiDocClear: "; |
342 | break; |
343 | case LDOMBasicString::LDOM_AsciiHashed: |
344 | if ((fl & FLITERAL) == 0) out << "LDOM_AsciiHashed: "; |
345 | break; |
346 | default: |
347 | out << "Unknown type"; |
348 | } |
349 | str = (const char *) aString -> myVal.ptr; |
350 | out << '\"'; |
351 | if (strlen (str) > 512) |
352 | out.rdbuf() -> sputn (str, 512); |
353 | else |
354 | out << str; |
355 | out << '\"'; |
356 | finis: |
357 | out << ends; |
358 | return (char *)out.str(); |
359 | } |
360 | #endif |
361 | #endif |