projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0023864: An & symbol is read incorrectly from a XML Ocaf file
[occt.git] / src / Standard / Standard_String.hxx
CommitLineData
b311480e 1// Copyright (c) 1998-1999 Matra Datavision
2// Copyright (c) 1999-2012 OPEN CASCADE SAS
3//
4// The content of this file is subject to the Open CASCADE Technology Public
5// License Version 6.5 (the "License"). You may not use the content of this file
6// except in compliance with the License. Please obtain a copy of the License
7// at http://www.opencascade.org and read it completely before using this file.
8//
9// The Initial Developer of the Original Code is Open CASCADE S.A.S., having its
10// main offices at: 1, place des Freres Montgolfier, 78280 Guyancourt, France.
11//
12// The Original Code and all software distributed under the License is
13// distributed on an "AS IS" basis, without warranty of any kind, and the
14// Initial Developer hereby disclaims all such warranties, including without
15// limitation, any warranties of merchantability, fitness for a particular
16// purpose or non-infringement. Please see the License for the specific terms
17// and conditions governing the rights and limitations under the License.
18
7fd59977 19
20#ifndef _Standard_String_HeaderFile
21# define _Standard_String_HeaderFile
22
23# ifndef _Standard_TypeDef_HeaderFile
24# include <Standard_TypeDef.hxx>
25# endif
26
27#define INF(X,Y) (((X)<(Y))?(X):(Y))
28
29# if OptJr
30
31#define STRLEN(s,i) {(i) = 0;while((s)[(i)++] != '\0');(i)--;}
32#define EXTSTRLEN(s,i) {(i) = 0;while((s)[(i)++] != 0);(i)--;}
33#define STRCPY(s1,s2,i) {for(LoopIndex=0; LoopIndex<(i); LoopIndex++)(s1)[LoopIndex] = (s2)[LoopIndex];}
34#define STRCAT(s1,i,s2,j) {for(LoopIndex=0; LoopIndex<(j); LoopIndex++) (s1)[(i)+LoopIndex] = (s2)[LoopIndex];}
35
36//# ifdef __Standard_DLL
37# ifdef _Standard_CString_SourceFile
38__Standard_API const Standard_Integer *MaskEndIntegerString = static_MaskEndIntegerString ;
39# else
40__Standard_APIEXTERN const Standard_Integer *MaskEndIntegerString ;
41# endif
42//# else
43//Standard_IMPORT const Standard_Integer *MaskEndIntegerString ;
44//# endif
45
46// JR 16-jul-1998
47// Algorithme utilise pour le calcul des longueurs de strings
48// Je suppose que les octets sont de l'ascii 7 bits.
49// Si un des octets d'un mot est a zero et si on soustrait 0x01010101 a ce
50// mot, l'octet a zero change de signe.
51// Reciproquement si (( Word - 0x01010101 ) & 0x80808080 ) != 0
52// alors Word a un octet a zero.
53
54// Si on a des octets negatifs et si on applique le resultat ci-dessus a
55// ( Word & 0x7f7f7f7f ), cela sera vrai sauf si un des octets vaut 0x80
56// auquel cas on trouvera un octet a zero a tort.
57
58// Conclusion : il suffit de controler la presence d'un octet a zero a partir
59// du debut du mot ou l'on croira en avoir trouve un pour traiter
60// correctement les octets qui valent 0x80.
61
62// La meme chose est vraie pour les extendedstrings.
63
64// D'autre part afin d'accelerer les traitements, on teste si les chaines
65// sont alignees sur des mots de 32 bits ( AND de l'adresse avec 3 ) ou
66// sont alignees sur des shorts de 16 bits ( AND de l'adresse avec 1 ).
67
68inline Standard_Boolean CStringTestOfZero(const Standard_Integer aString )
69{
70 return ( ((( aString & 0x7f7f7f7f ) - \
71 0x01010101 ) & 0x80808080 ) == 0 ) ;
72}
73
74inline Standard_Boolean HalfCStringTestOfZero(const Standard_ExtCharacter anExtCharacter )
75{
76 return ( ((( anExtCharacter & 0x7f7f ) - 0x0101 ) & 0x8080 ) == 0 ) ;
77}
78
79inline Standard_Boolean ExtStringTestOfZero(const Standard_Integer anExtString )
80{
81 return ( ((( anExtString & 0x7fff7fff ) - \
82 0x00010001 ) & 0x80008000 ) == 0 ) ;
83}
84
85#define STRINGLEN( aString , LoopIndex ) { \
86 if ((ptrdiff_t(aString) & 1) == 0) { \
87 LoopIndex = 0 ; \
88 if ((ptrdiff_t(aString) & 3) == 0) { \
89 while (CStringTestOfZero(((Standard_Integer *)aString)[LoopIndex++])); \
90 LoopIndex = ( LoopIndex << 2 ) - 4 ; \
91 } \
92 else { \
93 while (HalfCStringTestOfZero(((Standard_ExtCharacter *)aString)[LoopIndex++])); \
94 LoopIndex = ( LoopIndex << 1 ) - 2 ; \
95 } \
96 while (aString[LoopIndex++] != '\0'); \
97 LoopIndex -= 1 ; \
98 } \
99 else \
100 STRLEN( aString , LoopIndex ) ; \
101}
102
103#define EXTSTRINGLEN( anExtString , LoopIndex ) { \
104 if ((ptrdiff_t(anExtString) & 3) == 0) { \
105 LoopIndex = 0 ; \
106 while (ExtStringTestOfZero(((Standard_Integer *)anExtString)[LoopIndex++]));\
107 LoopIndex = ( LoopIndex << 1 ) - 2 ; \
108 if ( anExtString[ LoopIndex ] != 0 ) \
109 LoopIndex += 1 ; \
110 } \
111 else \
112 EXTSTRLEN( anExtString , LoopIndex ) ; \
113}
114
115// aStringOut is an AsciiString and is word aligned
116// aStringIn is a CString and may be not word aligned
117#define CSTRINGCOPY( aStringOut , aStringIn , aStringLen ) { \
118 Standard_Integer LoopIndex = (Standard_Integer)(ptrdiff_t(aStringIn) & 3) ; \
119 if ( ( LoopIndex & 1 ) == 0 ) { \
120 if ( LoopIndex == 0 ) { \
121 for (; LoopIndex <= ( aStringLen >> 2 ) ; LoopIndex++ ) { \
122 ((Standard_Integer *) aStringOut )[ LoopIndex ] = \
123 ((Standard_Integer *) aStringIn )[ LoopIndex ] ; \
124 } \
125 } \
126 else { \
127 for ( LoopIndex = 0 ; LoopIndex <= ( aStringLen >> 1) ; LoopIndex++ ) { \
128 ((Standard_ExtCharacter *) aStringOut )[ LoopIndex ] = \
129 ((Standard_ExtCharacter *) aStringIn )[ LoopIndex ] ; \
130 } \
131 } \
132 } \
133 else \
134 STRCPY( aStringOut , aStringIn , aStringLen + 1 ) ; \
135}
136
137// aStringOut is an AsciiString and is word aligned
138// aStringIn is an AsciiString and is word aligned
139#define ASCIISTRINGCOPY( aStringOut , aStringIn , aStringLen ) { \
140 Standard_Integer LoopIndex ; \
141 LoopIndex = 0 ; \
142 for(; LoopIndex <= ( aStringLen >> 2 ) ; LoopIndex++ ) { \
143 ((Standard_Integer *) aStringOut )[ LoopIndex ] = \
144 ((Standard_Integer *) aStringIn )[ LoopIndex ] ; \
145 } \
146}
147
148#define STRINGCAT( aStringOut , aStringOutLen , aStringIn , aStringInLen ) { \
149 Standard_Integer LoopIndex ; \
150 if ((ptrdiff_t(&aStringOut[ aStringOutLen ]) & 1) == 0 && \
151 (ptrdiff_t(aStringIn) & 1 ) == 0 ) { \
152 LoopIndex = 0 ; \
153 if ((ptrdiff_t(&aStringOut[ aStringOutLen ]) & 3 ) == 0 && \
154 (ptrdiff_t(aStringIn) & 3 ) == 0 ) { \
155 for (; LoopIndex <= ( aStringInLen >> 2 ) ; LoopIndex++ ) { \
156 ((Standard_Integer *) aStringOut )[ ( aStringOutLen >> 2 ) + \
157 LoopIndex ] = ((Standard_Integer *) aStringIn )[ LoopIndex ] ; \
158 } \
159 } \
160 else { \
161 for (; LoopIndex <= ( aStringInLen >> 1 ) ; LoopIndex++ ) { \
162 ((Standard_ExtCharacter *) aStringOut )[ ( aStringOutLen >> 1 ) + \
163 LoopIndex ] = ((Standard_ExtCharacter *) aStringIn )[ LoopIndex ] ; \
164 } \
165 } \
166 } \
167 else \
168 STRCPY( &aStringOut[ aStringOutLen ] , aStringIn , aStringInLen + 1 ) ; \
169}
170
171// aString is an AsciiString and is word aligned
172// anOtherString is aCString and may be not word aligned
173// aStringLen is the length of aString and anOtherString
174#define CSTRINGEQUAL( aString , anOtherString , aStringLen , KEqual ) { \
175 KEqual = Standard_True ; \
176 Standard_Integer LoopIndex = Standard_Integer(ptrdiff_t(anOtherString) & 3); \
177 if ( ( LoopIndex & 1 ) == 0 ) { \
178 if ( LoopIndex == 0 ) { \
179 for (; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
180 if (((Standard_Integer *) aString )[ LoopIndex ] != \
181 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
182 KEqual = Standard_False ; \
183 break ; \
184 } \
185 } \
186 if ( KEqual == Standard_True && \
187 (((Standard_Integer *) aString )[ LoopIndex ] & \
188 MaskEndIntegerString[ aStringLen & 3 ]) != \
189 (((Standard_Integer *) anOtherString )[ LoopIndex ] & \
190 MaskEndIntegerString[ aStringLen & 3 ] ) ) \
191 KEqual = Standard_False ; \
192 } \
193 else { \
194 for ( LoopIndex = 0 ; LoopIndex < (( aStringLen + 1) >> 1) ; LoopIndex++ ) { \
195 if (((Standard_ExtCharacter *) aString )[ LoopIndex ] != \
196 ((Standard_ExtCharacter *) anOtherString )[ LoopIndex ] ) { \
197 KEqual = Standard_False ; \
198 break ; \
199 } \
200 } \
201 } \
202 } \
203 else { \
204 for ( LoopIndex = 0 ; LoopIndex < aStringLen ; LoopIndex++ ) { \
205 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
206 KEqual = Standard_False ; \
207 break ; \
208 } \
209 } \
210 } \
211}
212
213// aString is an AsciiString and is word aligned
214// anOtherString is aCString and may be not word aligned
215// aStringLen is the length of aString.
216// The length of anOtherString is unknown
217#define LCSTRINGEQUAL( aString , aStringLen , anOtherString , KEqual ) { \
218 KEqual = Standard_True ; \
219 Standard_Integer LoopIndex = Standard_Integer(ptrdiff_t(anOtherString) & 3); \
220 if ( ( LoopIndex & 1 ) == 0 ) { \
221 if ( LoopIndex == 0 ) { \
222 for (; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
223 if (((Standard_Integer *) aString )[ LoopIndex ] != \
224 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
225 KEqual = Standard_False ; \
226 break ; \
227 } \
228 } \
229 LoopIndex = ( LoopIndex << 2) ; \
230 } \
231 else { \
232 for ( LoopIndex = 0 ; LoopIndex < (( aStringLen + 1) >> 1) ; LoopIndex++ ) { \
233 if (((Standard_ExtCharacter *) aString )[ LoopIndex ] != \
234 ((Standard_ExtCharacter *) anOtherString )[ LoopIndex ] ) { \
235 KEqual = Standard_False ; \
236 break ; \
237 } \
238 } \
239 LoopIndex = ( LoopIndex << 1) ; \
240 } \
241 if ( KEqual ) { \
242 for (; LoopIndex <= aStringLen ; LoopIndex++ ) { \
243 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) { \
244 KEqual = Standard_False ; \
245 break ; \
246 } \
247 } \
248 } \
249 } \
250 else { \
251 for ( LoopIndex = 0 ; LoopIndex <= aStringLen ; LoopIndex++ ) { \
252 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
253 KEqual = Standard_False ; \
254 break ; \
255 } \
256 } \
257 } \
258}
259
260// aString is an AsciiString and is word aligned
261// anOtherString is an AsciiString and is word aligned
262#define ASCIISTRINGEQUAL( aString , anOtherString , aStringLen , KEqual ) { \
263 Standard_Integer LoopIndex ; \
264 KEqual = Standard_True ; \
265 LoopIndex = 0 ; \
266 for(; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
267 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
268 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
269 KEqual = Standard_False ; \
270 break ; \
271 } \
272 } \
273 if ( KEqual == Standard_True && \
274 (((Standard_Integer *) aString )[ LoopIndex ] & \
275 MaskEndIntegerString[ aStringLen & 3 ]) != \
276 (((Standard_Integer *) anOtherString )[ LoopIndex ] & \
277 MaskEndIntegerString[ aStringLen & 3 ] ) ) \
278 KEqual = Standard_False ; \
279}
280
281// aString is an AsciiString and is word aligned
282// anOtherString is aCString and may be not word aligned
283#define CSTRINGLESS( aString , aStringLen , anOtherString , \
284 anOtherStringLen , MinLen , KLess ) { \
285 Standard_Integer LoopIndex ; \
286 KLess = Standard_True ; \
287 LoopIndex = ptrdiff_t(anOtherString) & 3 ; \
288 if ( ( LoopIndex & 1 ) == 0 && MinLen > 3 ) { \
289 if ( LoopIndex == 0 ) { \
290 for (; LoopIndex < ( MinLen >> 2 ) ; LoopIndex++ ) { \
291 if (((Standard_Integer *) aString )[ LoopIndex ] != \
292 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
293 LoopIndex++ ; \
294 break ; \
295 } \
296 } \
297 LoopIndex = ( LoopIndex - 1 ) << 2 ; \
298 } \
299 else { \
300 for ( LoopIndex = 0 ; LoopIndex < ( MinLen >> 1 ) ; LoopIndex++ ) { \
301 if (((Standard_ExtCharacter *) aString )[ LoopIndex ] != \
302 ((Standard_ExtCharacter *) anOtherString )[ LoopIndex ] ) { \
303 LoopIndex++ ; \
304 break ; \
305 } \
306 } \
307 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
308 } \
309 } \
310 else \
311 LoopIndex = 0 ; \
312 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
313 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
314 break ; \
315 } \
316 if ( LoopIndex != MinLen ) { \
317 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
318 KLess = Standard_False ; \
319 } \
320 else if ( aStringLen >= anOtherStringLen ) \
321 KLess = Standard_False ; \
322}
323
324// aString is an AsciiString and is word aligned
325// anOtherString is aCString and may be not word aligned
326// aStringLen is the length of aString
327// The length of anOtherString is unknown
328#define LCSTRINGLESS( aString , aStringLen , anOtherString , KLess ) { \
329 KLess = Standard_True ; \
330 Standard_Integer LoopIndex = Standard_Integer(ptrdiff_t(anOtherString) & 3); \
331 if ( ( LoopIndex & 1 ) == 0 && aStringLen > 3 ) { \
332 if ( LoopIndex == 0 ) { \
333 for (; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
334 if (((Standard_Integer *) aString )[ LoopIndex ] != \
335 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
336 LoopIndex++ ; \
337 break ; \
338 } \
339 } \
340 LoopIndex = ( LoopIndex - 1 ) << 2 ; \
341 } \
342 else { \
343 for ( LoopIndex = 0 ; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
344 if (((Standard_ExtCharacter *) aString )[ LoopIndex ] != \
345 ((Standard_ExtCharacter *) anOtherString )[ LoopIndex ] ) { \
346 LoopIndex++ ; \
347 break ; \
348 } \
349 } \
350 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
351 } \
352 } \
353 else \
354 LoopIndex = 0 ; \
355 for (; LoopIndex < aStringLen ; LoopIndex++ ) { \
356 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
357 break ; \
358 } \
359 if ( LoopIndex != aStringLen ) { \
360 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
361 KLess = Standard_False ; \
362 } \
363 else if ( anOtherString[ LoopIndex ] == '\0' ) \
364 KLess = Standard_False ; \
365}
366
367// aString is an AsciiString and is word aligned
368// anOtherString is an AsciiString and is word aligned
369#define ASCIISTRINGLESS( aString , aStringLen , anOtherString , \
370 anOtherStringLen , MinLen , KLess ) { \
371 Standard_Integer LoopIndex ; \
372 KLess = Standard_True ; \
373 LoopIndex = 0 ; \
374 if ( MinLen > 3 ) { \
375 for(; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
376 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
377 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
378 LoopIndex++ ; \
379 break ; \
380 } \
381 } \
382 LoopIndex = ( LoopIndex - 1 ) << 2 ; \
383 } \
384 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
385 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
386 break ; \
387 } \
388 if ( LoopIndex != MinLen ) { \
389 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
390 KLess = Standard_False ; \
391 } \
392 else if ( aStringLen >= anOtherStringLen ) \
393 KLess = Standard_False ; \
394}
395
396// aString is an AsciiString and is word aligned
397// anOtherString is aCString and may be not word aligned
398#define CSTRINGGREATER( aString , aStringLen , anOtherString , \
399 anOtherStringLen , MinLen , KGreater ) { \
400 KGreater = Standard_True ; \
401 Standard_Integer LoopIndex = Standard_Integer(ptrdiff_t(anOtherString) & 3); \
402 if ( ( LoopIndex & 1 ) == 0 && MinLen > 3 ) { \
403 if ( LoopIndex == 0 ) { \
404 for (; LoopIndex < ( MinLen >> 2 ) ; LoopIndex++ ) { \
405 if (((Standard_Integer *) aString )[ LoopIndex ] != \
406 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
407 LoopIndex++ ; \
408 break ; \
409 } \
410 } \
411 LoopIndex = ( LoopIndex - 1 ) << 2 ; \
412 } \
413 else { \
414 for ( LoopIndex = 0 ; LoopIndex < ( MinLen >> 1 ) ; LoopIndex++ ) { \
415 if (((Standard_ExtCharacter *) aString )[ LoopIndex ] != \
416 ((Standard_ExtCharacter *) anOtherString )[ LoopIndex ] ) { \
417 LoopIndex++ ; \
418 break ; \
419 } \
420 } \
421 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
422 } \
423 } \
424 else \
425 LoopIndex = 0 ; \
426 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
427 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
428 break ; \
429 } \
430 if ( LoopIndex != MinLen ) { \
431 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
432 KGreater = Standard_False ; \
433 } \
434 else if ( aStringLen <= anOtherStringLen ) \
435 KGreater = Standard_False ; \
436}
437
438// aString is an AsciiString and is word aligned
439// anOtherString is aCString and may be not word aligned
440// aStringLen is the length of aString
441// The length of anOtherString is unknown
442#define LCSTRINGGREATER( aString , aStringLen , anOtherString , KGreater ) { \
443 Standard_Integer LoopIndex ; \
444 KGreater = Standard_True ; \
445 LoopIndex = (Standard_Integer)(ptrdiff_t(anOtherString) & 3) ; \
446 if ( ( LoopIndex & 1 ) == 0 && aStringLen > 3 ) { \
447 if ( LoopIndex == 0 ) { \
448 for (; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
449 if (((Standard_Integer *) aString )[ LoopIndex ] != \
450 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
451 LoopIndex++ ; \
452 break ; \
453 } \
454 } \
455 LoopIndex = ( LoopIndex - 1 ) << 2 ; \
456 } \
457 else { \
458 for ( LoopIndex = 0 ; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
459 if (((Standard_ExtCharacter *) aString )[ LoopIndex ] != \
460 ((Standard_ExtCharacter *) anOtherString )[ LoopIndex ] ) { \
461 LoopIndex++ ; \
462 break ; \
463 } \
464 } \
465 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
466 } \
467 } \
468 else \
469 LoopIndex = 0 ; \
470 for (; LoopIndex < aStringLen ; LoopIndex++ ) { \
471 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
472 break ; \
473 } \
474 if ( LoopIndex != aStringLen ) { \
475 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
476 KGreater = Standard_False ; \
477 } \
478 else \
479 KGreater = Standard_False ; \
480}
481
482// aString is an AsciiString and is word aligned
483// anOtherString is an AsciiString and is word aligned
484#define ASCIISTRINGGREATER( aString , aStringLen , anOtherString , \
485 anOtherStringLen , MinLen , KGreater ) { \
486 Standard_Integer LoopIndex ; \
487 KGreater = Standard_True ; \
488 LoopIndex = 0 ; \
489 if ( MinLen > 3 ) { \
490 for(; LoopIndex < ( aStringLen >> 2 ) ; LoopIndex++ ) { \
491 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
492 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
493 LoopIndex++ ; \
494 break ; \
495 } \
496 } \
497 LoopIndex = ( LoopIndex - 1 ) << 2 ; \
498 } \
499 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
500 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
501 break ; \
502 } \
503 if ( LoopIndex != MinLen ) { \
504 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
505 KGreater = Standard_False ; \
506 } \
507 else if ( aStringLen <= anOtherStringLen ) \
508 KGreater = Standard_False ; \
509}
510
511// anExtStringOut is an ExtendedString and is word aligned
512// anExtStringIn is an ExtString and may be not word aligned
513#define EXTSTRINGCOPY( anExtStringOut , anExtStringIn , anExtStringLen ) { \
514 Standard_Integer LoopIndex ; \
515 LoopIndex = (Standard_Integer)(ptrdiff_t(anExtStringIn) & 3) ; \
516 if ( LoopIndex == 0 ) { \
517 for (; LoopIndex <= ( anExtStringLen >> 1 ) ; LoopIndex++ ) { \
518 ((Standard_Integer *) anExtStringOut )[ LoopIndex ] = \
519 ((Standard_Integer *) anExtStringIn )[ LoopIndex ] ; \
520 } \
521 } \
522 else \
523 STRCPY( anExtStringOut , anExtStringIn , anExtStringLen + 1 ) ; \
524}
525
526// anExtStringOut is an ExtendedString and is word aligned
527// anExtStringIn is an ExtendedString and is word aligned
528// We copy the ending zero and possibly the ExtCharacter folowing
529#define EXTENDEDSTRINGCOPY( anExtStringOut , anExtStringIn , anExtStringLen ) {\
530 Standard_Integer LoopIndex ; \
531 for (LoopIndex = 0 ; LoopIndex <= ( anExtStringLen >> 1 ) ; LoopIndex++ ) { \
532 ((Standard_Integer *) anExtStringOut )[ LoopIndex ] = \
533 ((Standard_Integer *) anExtStringIn )[ LoopIndex ] ; \
534 } \
535}
536
537// anExtStringOut is an ExtendedString and is word aligned
538// anExtStringIn is an ExtendedString and is word aligned
539// We copy the ending zero and possibly the ExtCharacter folowing
540#define EXTENDEDSTRINGCAT( anExtStringOut , anExtStringOutLen , anExtStringIn , anExtStringInLen ) {\
541 Standard_Integer LoopIndex ; \
542 if ( ( anExtStringOutLen & 1 ) == 0 ) { \
543 for (LoopIndex = 0 ; LoopIndex <= ( anExtStringInLen >> 1 ) ; LoopIndex++ ) { \
544 ((Standard_Integer *) anExtStringOut )[ ( anExtStringOutLen >> 1 ) + LoopIndex ] = \
545 ((Standard_Integer *) anExtStringIn )[ LoopIndex ] ; \
546 } \
547 } \
548 else { \
549 STRCAT( anExtStringOut , anExtStringOutLen , anExtStringIn , anExtStringInLen + 1 ) ; \
550 } \
551}
552
553// aString is an ExtendedString and is word aligned
554// anOtherString is an ExtString and may be not word aligned
555// We compare the last two ExtCharacters or the last ExtCharacter and the
556// ending zero if it's word aligned
557// aStringLen is the length of aString and anOtherString
558#define EXTSTRINGEQUAL( aString , anOtherString , aStringLen , KEqual ) { \
559 Standard_Integer LoopIndex ; \
560 KEqual = Standard_True ; \
561 LoopIndex = 0 ; \
562 if ((ptrdiff_t(anOtherString) & 3 ) == 0 ) { \
563 for(; LoopIndex < (( aStringLen + 1) >> 1 ) ; LoopIndex++ ) { \
564 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
565 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
566 KEqual = Standard_False ; \
567 break ; \
568 } \
569 } \
570 } \
571 else { \
572 for(; LoopIndex < aStringLen ; LoopIndex++ ) { \
573 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
574 KEqual = Standard_False ; \
575 break ; \
576 } \
577 } \
578 } \
579}
580
581// aString is an ExtendedString and is word aligned
582// anOtherString is an ExtString and may be not word aligned
583// We compare the last two ExtCharacters or the last ExtCharacter and the
584// ending zero if it's word aligned
585// aStringLen is the length of aString.
586// The length of anOtherString is unknown
587#define LEXTSTRINGEQUAL( aString , aStringLen , anOtherString , KEqual ) { \
588 Standard_Integer LoopIndex ; \
589 KEqual = Standard_True ; \
590 LoopIndex = 0 ; \
591 if ((ptrdiff_t(anOtherString) & 3 ) == 0 ) { \
592 for(; LoopIndex < (( aStringLen + 1) >> 1 ) ; LoopIndex++ ) { \
593 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
594 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
595 KEqual = Standard_False ; \
596 break ; \
597 } \
598 } \
599 if ( KEqual && aString [ aStringLen ] != anOtherString [ aStringLen ] ) \
600 KEqual = Standard_False ; \
601 } \
602 else { \
603 for(; LoopIndex <= aStringLen ; LoopIndex++ ) { \
604 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
605 KEqual = Standard_False ; \
606 break ; \
607 } \
608 } \
609 } \
610}
611
612// aString is an ExtendedString and is word aligned
613// anOtherString is an ExtendedString and is word aligned
614// We compare the last two ExtCharacters or the last ExtCharacter and the
615// ending zero
616#define EXTENDEDSTRINGEQUAL( aString , anOtherString , aStringLen , KEqual ) { \
617 Standard_Integer LoopIndex ; \
618 KEqual = Standard_True ; \
619 LoopIndex = 0 ; \
620 for(; LoopIndex < (( aStringLen + 1) >> 1 ) ; LoopIndex++ ) { \
621 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
622 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
623 KEqual = Standard_False ; \
624 break ; \
625 } \
626 } \
627}
628
629// aString is an ExtendedString and is word aligned
630// anOtherString is an ExtendedString and may be not word aligned
631#define EXTSTRINGLESS( aString , aStringLen , anOtherString , \
632 anOtherStringLen , MinLen , KLess ) { \
633 Standard_Integer LoopIndex ; \
634 KLess = Standard_True ; \
635 LoopIndex = 0 ; \
636 if ((ptrdiff_t(anOtherString) & 3 ) == 0 ) { \
637 if ( MinLen > 1 ) { \
638 for(; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
639 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
640 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
641 LoopIndex++ ; \
642 break ; \
643 } \
644 } \
645 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
646 } \
647 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
648 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
649 break ; \
650 } \
651 if ( LoopIndex != MinLen ) { \
652 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
653 KLess = Standard_False ; \
654 } \
655 else if ( aStringLen >= anOtherStringLen ) \
656 KLess = Standard_False ; \
657 } \
658 else { \
659 if ( MinLen > 1 ) { \
660 for(; LoopIndex < aStringLen ; LoopIndex++ ) { \
661 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
662 LoopIndex++ ; \
663 break ; \
664 } \
665 } \
666 LoopIndex = LoopIndex - 1 ; \
667 } \
668 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
669 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
670 break ; \
671 } \
672 if ( LoopIndex != MinLen ) { \
673 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
674 KLess = Standard_False ; \
675 } \
676 else if ( aStringLen >= anOtherStringLen ) \
677 KLess = Standard_False ; \
678 } \
679}
680
681// aString is an ExtendedString and is word aligned
682// anOtherString is an ExtendedString and may be not word aligned
683// aStringLen is the length of aString
684// The length of anOtherString is unknown
685#define LEXTSTRINGLESS( aString , aStringLen , anOtherString , KLess ) { \
686 Standard_Integer LoopIndex ; \
687 KLess = Standard_True ; \
688 LoopIndex = 0 ; \
689 if ((ptrdiff_t(anOtherString) & 3 ) == 0 ) { \
690 if ( aStringLen > 1 ) { \
691 for(; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
692 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
693 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
694 LoopIndex++ ; \
695 break ; \
696 } \
697 } \
698 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
699 } \
700 for (; LoopIndex < aStringLen ; LoopIndex++ ) { \
701 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
702 break ; \
703 } \
704 if ( LoopIndex != aStringLen ) { \
705 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
706 KLess = Standard_False ; \
707 } \
708 else if ( anOtherString[ LoopIndex ] == 0 ) \
709 KLess = Standard_False ; \
710 } \
711 else { \
712 if ( aStringLen > 1 ) { \
713 for(; LoopIndex < aStringLen ; LoopIndex++ ) { \
714 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
715 LoopIndex++ ; \
716 break ; \
717 } \
718 } \
719 LoopIndex = LoopIndex - 1 ; \
720 } \
721 for (; LoopIndex < aStringLen ; LoopIndex++ ) { \
722 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
723 break ; \
724 } \
725 if ( LoopIndex != aStringLen ) { \
726 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
727 KLess = Standard_False ; \
728 } \
729 else if ( anOtherString[ LoopIndex ] == 0 ) \
730 KLess = Standard_False ; \
731 } \
732}
733
734// aString is an ExtendedString and is word aligned
735// anOtherString is an ExtendedString and is word aligned
736#define EXTENDEDSTRINGLESS( aString , aStringLen , anOtherString , \
737 anOtherStringLen , MinLen , KLess ) { \
738 Standard_Integer LoopIndex ; \
739 KLess = Standard_True ; \
740 LoopIndex = 0 ; \
741 if ( MinLen > 1 ) { \
742 for(; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
743 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
744 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
745 LoopIndex++ ; \
746 break ; \
747 } \
748 } \
749 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
750 } \
751 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
752 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
753 break ; \
754 } \
755 if ( LoopIndex != MinLen ) { \
756 if ( aString[ LoopIndex ] > anOtherString[ LoopIndex ] ) \
757 KLess = Standard_False ; \
758 } \
759 else if ( aStringLen >= anOtherStringLen ) \
760 KLess = Standard_False ; \
761}
762
763// aString is an ExtendedString and is word aligned
764// anOtherString is an ExtendedString and may be not word aligned
765#define EXTSTRINGGREATER( aString , aStringLen , anOtherString , \
766 anOtherStringLen , MinLen , KGreater ) { \
767 Standard_Integer LoopIndex ; \
768 KGreater = Standard_True ; \
769 LoopIndex = 0 ; \
770 if ((ptrdiff_t(anOtherString) & 3 ) == 0 ) { \
771 if ( MinLen > 1 ) { \
772 for(; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
773 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
774 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
775 LoopIndex++ ; \
776 break ; \
777 } \
778 } \
779 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
780 } \
781 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
782 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
783 break ; \
784 } \
785 if ( LoopIndex != MinLen ) { \
786 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
787 KGreater = Standard_False ; \
788 } \
789 else if ( aStringLen <= anOtherStringLen ) \
790 KGreater = Standard_False ; \
791 } \
792 else { \
793 if ( MinLen > 1 ) { \
794 for(; LoopIndex < aStringLen ; LoopIndex++ ) { \
795 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
796 LoopIndex++ ; \
797 break ; \
798 } \
799 } \
800 LoopIndex = LoopIndex - 1 ; \
801 } \
802 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
803 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
804 break ; \
805 } \
806 if ( LoopIndex != MinLen ) { \
807 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
808 KGreater = Standard_False ; \
809 } \
810 else if ( aStringLen <= anOtherStringLen ) \
811 KGreater = Standard_False ; \
812 } \
813}
814
815// aString is an ExtendedString and is word aligned
816// anOtherString is an ExtendedString and may be not word aligned
817// aStringLen is the length of aString
818// The length of anOtherString is unknown
819#define LEXTSTRINGGREATER( aString , aStringLen , anOtherString , KGreater ) { \
820 Standard_Integer LoopIndex ; \
821 KGreater = Standard_True ; \
822 LoopIndex = 0 ; \
823 if ((ptrdiff_t(anOtherString) & 3 ) == 0 ) { \
824 if ( aStringLen > 1 ) { \
825 for(; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
826 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
827 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
828 LoopIndex++ ; \
829 break ; \
830 } \
831 } \
832 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
833 } \
834 for (; LoopIndex < aStringLen ; LoopIndex++ ) { \
835 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
836 break ; \
837 } \
838 if ( LoopIndex != aStringLen ) { \
839 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
840 KGreater = Standard_False ; \
841 } \
842 else \
843 KGreater = Standard_False ; \
844 } \
845 else { \
846 if ( aStringLen > 1 ) { \
847 for(; LoopIndex < aStringLen ; LoopIndex++ ) { \
848 if ( aString [ LoopIndex ] != anOtherString [ LoopIndex ] ) { \
849 LoopIndex++ ; \
850 break ; \
851 } \
852 } \
853 LoopIndex = LoopIndex - 1 ; \
854 } \
855 for (; LoopIndex < aStringLen ; LoopIndex++ ) { \
856 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
857 break ; \
858 } \
859 if ( LoopIndex != aStringLen ) { \
860 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
861 KGreater = Standard_False ; \
862 } \
863 else \
864 KGreater = Standard_False ; \
865 } \
866}
867
868// aString is an ExtendedString and is word aligned
869// anOtherString is an ExtendedString and is word aligned
870#define EXTENDEDSTRINGGREATER( aString , aStringLen , anOtherString , \
871 anOtherStringLen , MinLen , KGreater ) { \
872 Standard_Integer LoopIndex ; \
873 KGreater = Standard_True ; \
874 LoopIndex = 0 ; \
875 if ( MinLen > 1 ) { \
876 for(; LoopIndex < ( aStringLen >> 1 ) ; LoopIndex++ ) { \
877 if ( ((Standard_Integer *) aString )[ LoopIndex ] != \
878 ((Standard_Integer *) anOtherString )[ LoopIndex ] ) { \
879 LoopIndex++ ; \
880 break ; \
881 } \
882 } \
883 LoopIndex = ( LoopIndex - 1 ) << 1 ; \
884 } \
885 for (; LoopIndex < MinLen ; LoopIndex++ ) { \
886 if ( aString[ LoopIndex ] != anOtherString[ LoopIndex ] ) \
887 break ; \
888 } \
889 if ( LoopIndex != MinLen ) { \
890 if ( aString[ LoopIndex ] < anOtherString[ LoopIndex ] ) \
891 KGreater = Standard_False ; \
892 } \
893 else if ( aStringLen <= anOtherStringLen ) \
894 KGreater = Standard_False ; \
895}
896
897# else
898
899#define STRLEN(s,i) {(i) = 0;while((s)[(i)++] != '\0');(i)--;}
900#define EXTSTRLEN(s,i) {(i) = 0;while((s)[(i)++] != 0);(i)--;}
901#define STRCPY(s1,s2,i) {for(int j=0; j<(i); j++)(s1)[j] = (s2)[j];}
902#define STRCAT(s1,i,s2,j) {for(int k=0; k<(j); k++) (s1)[(i)+k] = (s2)[k];}
903
904# endif
905
906#endif
Open CASCADE Technology repository