?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update dev300-m58
[ooovba.git] / sal / rtl / source / strtmpl.c
blobe01f935bd5d9fe7d85022f4c0f626836caa0b3be
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: strtmpl.c,v $
10 * $Revision: 1.26 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 /* ======================================================================= */
32 /* Internal C-String help functions which could be used without the */
33 /* String-Class */
34 /* ======================================================================= */
35
36 /*
37 inline void rtl_str_ImplCopy( IMPL_RTL_STRCODE* pDest,
38 const IMPL_RTL_STRCODE* pSrc,
39 sal_Int32 nCount )
40 {
41 while ( nCount > 0 )
42 {
43 *pDest = *pSrc;
44 pDest++;
45 pSrc++;
46 nCount--;
47 }
48 }
49 */
50
51 #define rtl_str_ImplCopy( _pDest, _pSrc, _nCount ) \
52 { \
53 IMPL_RTL_STRCODE* __mm_pDest = _pDest; \
54 const IMPL_RTL_STRCODE* __mm_pSrc = _pSrc; \
55 sal_Int32 __mm_nCount = _nCount; \
56 while ( __mm_nCount > 0 ) \
57 { \
58 *__mm_pDest = *__mm_pSrc; \
59 __mm_pDest++; \
60 __mm_pSrc++; \
61 __mm_nCount--; \
62 } \
63 }
64
65 /* ======================================================================= */
66 /* C-String functions which could be used without the String-Class */
67 /* ======================================================================= */
68
69 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( getLength )( const IMPL_RTL_STRCODE* pStr )
70 {
71 const IMPL_RTL_STRCODE* pTempStr = pStr;
72 while( *pTempStr )
73 pTempStr++;
74 return pTempStr-pStr;
75 }
76
77 /* ----------------------------------------------------------------------- */
78
79 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compare )( const IMPL_RTL_STRCODE* pStr1,
80 const IMPL_RTL_STRCODE* pStr2 )
81 {
82 sal_Int32 nRet;
83 while ( ((nRet = ((sal_Int32)(IMPL_RTL_USTRCODE(*pStr1)))-
84 ((sal_Int32)(IMPL_RTL_USTRCODE(*pStr2)))) == 0) &&
85 *pStr2 )
86 {
87 pStr1++;
88 pStr2++;
89 }
90
91 return nRet;
92 }
93
94 /* ----------------------------------------------------------------------- */
95
96 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compare_WithLength )( const IMPL_RTL_STRCODE* pStr1,
97 sal_Int32 nStr1Len,
98 const IMPL_RTL_STRCODE* pStr2,
99 sal_Int32 nStr2Len )
100 {
101 sal_Int32 nRet = nStr1Len - nStr2Len;
102 int nCount = (nRet <= 0) ? nStr1Len : nStr2Len;
103
104 --pStr1;
105 --pStr2;
106 while( (--nCount >= 0) && (*++pStr1 == *++pStr2) );
107
108 if( nCount >= 0 )
109 nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1 )))
110 - ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2 )));
111
112 return nRet;
113 }
114
115 /* ----------------------------------------------------------------------- */
116
117 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( shortenedCompare_WithLength )( const IMPL_RTL_STRCODE* pStr1,
118 sal_Int32 nStr1Len,
119 const IMPL_RTL_STRCODE* pStr2,
120 sal_Int32 nStr2Len,
121 sal_Int32 nShortenedLength )
122 {
123 const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
124 const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
125 sal_Int32 nRet;
126 while ( (nShortenedLength > 0) &&
127 (pStr1 < pStr1End) && (pStr2 < pStr2End) )
128 {
129 nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1 )))-
130 ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2 )));
131 if ( nRet )
132 return nRet;
133
134 nShortenedLength--;
135 pStr1++;
136 pStr2++;
137 }
138
139 if ( nShortenedLength <= 0 )
140 return 0;
141 return nStr1Len - nStr2Len;
142 }
143
144 /* ----------------------------------------------------------------------- */
145
146 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( reverseCompare_WithLength )( const IMPL_RTL_STRCODE* pStr1,
147 sal_Int32 nStr1Len,
148 const IMPL_RTL_STRCODE* pStr2,
149 sal_Int32 nStr2Len )
150 {
151 const IMPL_RTL_STRCODE* pStr1Run = pStr1+nStr1Len;
152 const IMPL_RTL_STRCODE* pStr2Run = pStr2+nStr2Len;
153 sal_Int32 nRet;
154 while ( (pStr1 < pStr1Run) && (pStr2 < pStr2Run) )
155 {
156 pStr1Run--;
157 pStr2Run--;
158 nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1Run )))-
159 ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2Run )));
160 if ( nRet )
161 return nRet;
162 }
163
164 return nStr1Len - nStr2Len;
165 }
166
167 /* ----------------------------------------------------------------------- */
168
169 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCase )( const IMPL_RTL_STRCODE* pStr1,
170 const IMPL_RTL_STRCODE* pStr2 )
171 {
172 sal_Int32 nRet;
173 sal_Int32 c1;
174 sal_Int32 c2;
175 do
176 {
177 /* If character between 'A' and 'Z', than convert it to lowercase */
178 c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
179 c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
180 if ( (c1 >= 65) && (c1 <= 90) )
181 c1 += 32;
182 if ( (c2 >= 65) && (c2 <= 90) )
183 c2 += 32;
184 nRet = c1-c2;
185 if ( nRet != 0 )
186 return nRet;
187
188 pStr1++;
189 pStr2++;
190 }
191 while ( c2 );
192
193 return 0;
194 }
195
196 /* ----------------------------------------------------------------------- */
197
198 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( compareIgnoreAsciiCase_WithLength )( const IMPL_RTL_STRCODE* pStr1,
199 sal_Int32 nStr1Len,
200 const IMPL_RTL_STRCODE* pStr2,
201 sal_Int32 nStr2Len )
202 {
203 const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
204 const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
205 sal_Int32 nRet;
206 sal_Int32 c1;
207 sal_Int32 c2;
208 while ( (pStr1 < pStr1End) && (pStr2 < pStr2End) )
209 {
210 /* If character between 'A' and 'Z', than convert it to lowercase */
211 c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
212 c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
213 if ( (c1 >= 65) && (c1 <= 90) )
214 c1 += 32;
215 if ( (c2 >= 65) && (c2 <= 90) )
216 c2 += 32;
217 nRet = c1-c2;
218 if ( nRet != 0 )
219 return nRet;
220
221 pStr1++;
222 pStr2++;
223 }
224
225 return nStr1Len - nStr2Len;
226 }
227
228 /* ----------------------------------------------------------------------- */
229
230 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( shortenedCompareIgnoreAsciiCase_WithLength )( const IMPL_RTL_STRCODE* pStr1,
231 sal_Int32 nStr1Len,
232 const IMPL_RTL_STRCODE* pStr2,
233 sal_Int32 nStr2Len,
234 sal_Int32 nShortenedLength )
235 {
236 const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
237 const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
238 sal_Int32 nRet;
239 sal_Int32 c1;
240 sal_Int32 c2;
241 while ( (nShortenedLength > 0) &&
242 (pStr1 < pStr1End) && (pStr2 < pStr2End) )
243 {
244 /* If character between 'A' and 'Z', than convert it to lowercase */
245 c1 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr1 );
246 c2 = (sal_Int32)IMPL_RTL_USTRCODE( *pStr2 );
247 if ( (c1 >= 65) && (c1 <= 90) )
248 c1 += 32;
249 if ( (c2 >= 65) && (c2 <= 90) )
250 c2 += 32;
251 nRet = c1-c2;
252 if ( nRet != 0 )
253 return nRet;
254
255 nShortenedLength--;
256 pStr1++;
257 pStr2++;
258 }
259
260 if ( nShortenedLength <= 0 )
261 return 0;
262 return nStr1Len - nStr2Len;
263 }
264
265 /* ----------------------------------------------------------------------- */
266
267 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( hashCode )( const IMPL_RTL_STRCODE* pStr )
268 {
269 return IMPL_RTL_STRNAME( hashCode_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
270 }
271
272 /* ----------------------------------------------------------------------- */
273
274 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( hashCode_WithLength )( const IMPL_RTL_STRCODE* pStr,
275 sal_Int32 nLen )
276 {
277 sal_Int32 h = nLen;
278
279 if ( nLen < 256 )
280 {
281 while ( nLen > 0 )
282 {
283 h = (h*37) + IMPL_RTL_USTRCODE( *pStr );
284 pStr++;
285 nLen--;
286 }
287 }
288 else
289 {
290 sal_Int32 nSkip;
291 const IMPL_RTL_STRCODE* pEndStr = pStr+nLen-5;
292
293 /* only sample some characters */
294 /* the first 3, some characters between, and the last 5 */
295 h = (h*39) + IMPL_RTL_USTRCODE( *pStr );
296 pStr++;
297 h = (h*39) + IMPL_RTL_USTRCODE( *pStr );
298 pStr++;
299 h = (h*39) + IMPL_RTL_USTRCODE( *pStr );
300 pStr++;
301
302 if ( nLen < 32 )
303 nSkip = nLen / 4;
304 else
305 nSkip = nLen / 8;
306 nLen -= 8;
307 while ( nLen > 0 )
308 {
309 h = (h*39) + IMPL_RTL_USTRCODE( *pStr );
310 pStr += nSkip;
311 nLen -= nSkip;
312 }
313
314 h = (h*39) + IMPL_RTL_USTRCODE( *pEndStr );
315 pEndStr++;
316 h = (h*39) + IMPL_RTL_USTRCODE( *pEndStr );
317 pEndStr++;
318 h = (h*39) + IMPL_RTL_USTRCODE( *pEndStr );
319 pEndStr++;
320 h = (h*39) + IMPL_RTL_USTRCODE( *pEndStr );
321 pEndStr++;
322 h = (h*39) + IMPL_RTL_USTRCODE( *pEndStr );
323 }
324
325 return h;
326 }
327
328 /* ----------------------------------------------------------------------- */
329
330 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( indexOfChar )( const IMPL_RTL_STRCODE* pStr,
331 IMPL_RTL_STRCODE c )
332 {
333 const IMPL_RTL_STRCODE* pTempStr = pStr;
334 while ( *pTempStr )
335 {
336 if ( *pTempStr == c )
337 return pTempStr-pStr;
338
339 pTempStr++;
340 }
341
342 return -1;
343 }
344
345 /* ----------------------------------------------------------------------- */
346
347 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( indexOfChar_WithLength )( const IMPL_RTL_STRCODE* pStr,
348 sal_Int32 nLen,
349 IMPL_RTL_STRCODE c )
350 {
351 const IMPL_RTL_STRCODE* pTempStr = pStr;
352 while ( nLen > 0 )
353 {
354 if ( *pTempStr == c )
355 return pTempStr-pStr;
356
357 pTempStr++;
358 nLen--;
359 }
360
361 return -1;
362 }
363
364 /* ----------------------------------------------------------------------- */
365
366 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( lastIndexOfChar )( const IMPL_RTL_STRCODE* pStr,
367 IMPL_RTL_STRCODE c )
368 {
369 return IMPL_RTL_STRNAME( lastIndexOfChar_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ), c );
370 }
371
372 /* ----------------------------------------------------------------------- */
373
374 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( lastIndexOfChar_WithLength )( const IMPL_RTL_STRCODE* pStr,
375 sal_Int32 nLen,
376 IMPL_RTL_STRCODE c )
377 {
378 pStr += nLen;
379 while ( nLen > 0 )
380 {
381 nLen--;
382 pStr--;
383
384 if ( *pStr == c )
385 return nLen;
386 }
387
388 return -1;
389 }
390
391 /* ----------------------------------------------------------------------- */
392
393 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( indexOfStr )( const IMPL_RTL_STRCODE* pStr,
394 const IMPL_RTL_STRCODE* pSubStr )
395 {
396 return IMPL_RTL_STRNAME( indexOfStr_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ),
397 pSubStr, IMPL_RTL_STRNAME( getLength )( pSubStr ) );
398 }
399
400 /* ----------------------------------------------------------------------- */
401
402 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( indexOfStr_WithLength )( const IMPL_RTL_STRCODE* pStr,
403 sal_Int32 nStrLen,
404 const IMPL_RTL_STRCODE* pSubStr,
405 sal_Int32 nSubLen )
406 {
407 /* faster search for a single character */
408 if ( nSubLen < 2 )
409 {
410 /* an empty SubString is always not foundable */
411 if ( nSubLen == 1 )
412 {
413 IMPL_RTL_STRCODE c = *pSubStr;
414 const IMPL_RTL_STRCODE* pTempStr = pStr;
415 while ( nStrLen > 0 )
416 {
417 if ( *pTempStr == c )
418 return pTempStr-pStr;
419
420 pTempStr++;
421 nStrLen--;
422 }
423 }
424 }
425 else
426 {
427 const IMPL_RTL_STRCODE* pTempStr = pStr;
428 while ( nStrLen > 0 )
429 {
430 if ( *pTempStr == *pSubStr )
431 {
432 /* Compare SubString */
433 if ( nSubLen <= nStrLen )
434 {
435 const IMPL_RTL_STRCODE* pTempStr1 = pTempStr;
436 const IMPL_RTL_STRCODE* pTempStr2 = pSubStr;
437 sal_Int32 nTempLen = nSubLen;
438 while ( nTempLen )
439 {
440 if ( *pTempStr1 != *pTempStr2 )
441 break;
442
443 pTempStr1++;
444 pTempStr2++;
445 nTempLen--;
446 }
447
448 if ( !nTempLen )
449 return pTempStr-pStr;
450 }
451 else
452 break;
453 }
454
455 nStrLen--;
456 pTempStr++;
457 }
458 }
459
460 return -1;
461 }
462
463 /* ----------------------------------------------------------------------- */
464
465 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( lastIndexOfStr )( const IMPL_RTL_STRCODE* pStr,
466 const IMPL_RTL_STRCODE* pSubStr )
467 {
468 return IMPL_RTL_STRNAME( lastIndexOfStr_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ),
469 pSubStr, IMPL_RTL_STRNAME( getLength )( pSubStr ) );
470 }
471
472 /* ----------------------------------------------------------------------- */
473
474 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( lastIndexOfStr_WithLength )( const IMPL_RTL_STRCODE* pStr,
475 sal_Int32 nStrLen,
476 const IMPL_RTL_STRCODE* pSubStr,
477 sal_Int32 nSubLen )
478 {
479 /* faster search for a single character */
480 if ( nSubLen < 2 )
481 {
482 /* an empty SubString is always not foundable */
483 if ( nSubLen == 1 )
484 {
485 IMPL_RTL_STRCODE c = *pSubStr;
486 pStr += nStrLen;
487 while ( nStrLen > 0 )
488 {
489 nStrLen--;
490 pStr--;
491
492 if ( *pStr == c )
493 return nStrLen;
494 }
495 }
496 }
497 else
498 {
499 pStr += nStrLen;
500 nStrLen -= nSubLen;
501 pStr -= nSubLen;
502 while ( nStrLen >= 0 )
503 {
504 const IMPL_RTL_STRCODE* pTempStr1 = pStr;
505 const IMPL_RTL_STRCODE* pTempStr2 = pSubStr;
506 sal_Int32 nTempLen = nSubLen;
507 while ( nTempLen )
508 {
509 if ( *pTempStr1 != *pTempStr2 )
510 break;
511
512 pTempStr1++;
513 pTempStr2++;
514 nTempLen--;
515 }
516
517 if ( !nTempLen )
518 return nStrLen;
519
520 nStrLen--;
521 pStr--;
522 }
523 }
524
525 return -1;
526 }
527
528 /* ----------------------------------------------------------------------- */
529
530 void SAL_CALL IMPL_RTL_STRNAME( replaceChar )( IMPL_RTL_STRCODE* pStr,
531 IMPL_RTL_STRCODE cOld,
532 IMPL_RTL_STRCODE cNew )
533 {
534 while ( *pStr )
535 {
536 if ( *pStr == cOld )
537 *pStr = cNew;
538
539 pStr++;
540 }
541 }
542
543 /* ----------------------------------------------------------------------- */
544
545 void SAL_CALL IMPL_RTL_STRNAME( replaceChar_WithLength )( IMPL_RTL_STRCODE* pStr,
546 sal_Int32 nLen,
547 IMPL_RTL_STRCODE cOld,
548 IMPL_RTL_STRCODE cNew )
549 {
550 while ( nLen > 0 )
551 {
552 if ( *pStr == cOld )
553 *pStr = cNew;
554
555 pStr++;
556 nLen--;
557 }
558 }
559
560 /* ----------------------------------------------------------------------- */
561
562 void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase )( IMPL_RTL_STRCODE* pStr )
563 {
564 while ( *pStr )
565 {
566 /* Between A-Z (65-90), than to lowercase (+32) */
567 if ( (*pStr >= 65) && (*pStr <= 90) )
568 *pStr += 32;
569
570 pStr++;
571 }
572 }
573
574 /* ----------------------------------------------------------------------- */
575
576 void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase_WithLength )( IMPL_RTL_STRCODE* pStr,
577 sal_Int32 nLen )
578 {
579 while ( nLen > 0 )
580 {
581 /* Between A-Z (65-90), than to lowercase (+32) */
582 if ( (*pStr >= 65) && (*pStr <= 90) )
583 *pStr += 32;
584
585 pStr++;
586 nLen--;
587 }
588 }
589
590 /* ----------------------------------------------------------------------- */
591
592 void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase )( IMPL_RTL_STRCODE* pStr )
593 {
594 while ( *pStr )
595 {
596 /* Between a-z (97-122), than to uppercase (-32) */
597 if ( (*pStr >= 97) && (*pStr <= 122) )
598 *pStr -= 32;
599
600 pStr++;
601 }
602 }
603
604 /* ----------------------------------------------------------------------- */
605
606 void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase_WithLength )( IMPL_RTL_STRCODE* pStr,
607 sal_Int32 nLen )
608 {
609 while ( nLen > 0 )
610 {
611 /* Between a-z (97-122), than to uppercase (-32) */
612 if ( (*pStr >= 97) && (*pStr <= 122) )
613 *pStr -= 32;
614
615 pStr++;
616 nLen--;
617 }
618 }
619
620 /* ----------------------------------------------------------------------- */
621
622 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim )( IMPL_RTL_STRCODE* pStr )
623 {
624 return IMPL_RTL_STRNAME( trim_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
625 }
626
627 /* ----------------------------------------------------------------------- */
628
629 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim_WithLength )( IMPL_RTL_STRCODE* pStr, sal_Int32 nLen )
630 {
631 sal_Int32 nPreSpaces = 0;
632 sal_Int32 nPostSpaces = 0;
633 sal_Int32 nIndex = nLen-1;
634
635 while ( (nPreSpaces < nLen) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nPreSpaces)) ) )
636 nPreSpaces++;
637
638 while ( (nIndex > nPreSpaces) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nIndex)) ) )
639 {
640 nPostSpaces++;
641 nIndex--;
642 }
643
644 if ( nPostSpaces )
645 {
646 nLen -= nPostSpaces;
647 *(pStr+nLen) = 0;
648 }
649
650 if ( nPreSpaces )
651 {
652 IMPL_RTL_STRCODE* pNewStr = pStr+nPreSpaces;
653
654 nLen -= nPreSpaces;
655 nIndex = nLen;
656
657 while ( nIndex )
658 {
659 *pStr = *pNewStr;
660 pStr++;
661 pNewStr++;
662 nIndex--;
663 }
664 *pStr = 0;
665 }
666
667 return nLen;
668 }
669
670 /* ----------------------------------------------------------------------- */
671
672 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( valueOfBoolean )( IMPL_RTL_STRCODE* pStr, sal_Bool b )
673 {
674 if ( b )
675 {
676 *pStr = 't';
677 pStr++;
678 *pStr = 'r';
679 pStr++;
680 *pStr = 'u';
681 pStr++;
682 *pStr = 'e';
683 pStr++;
684 *pStr = 0;
685 return 4;
686 }
687 else
688 {
689 *pStr = 'f';
690 pStr++;
691 *pStr = 'a';
692 pStr++;
693 *pStr = 'l';
694 pStr++;
695 *pStr = 's';
696 pStr++;
697 *pStr = 'e';
698 pStr++;
699 *pStr = 0;
700 return 5;
701 }
702 }
703
704 /* ----------------------------------------------------------------------- */
705
706 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( valueOfChar )( IMPL_RTL_STRCODE* pStr,
707 IMPL_RTL_STRCODE c )
708 {
709 *pStr++ = c;
710 *pStr = 0;
711 return 1;
712 }
713
714 /* ----------------------------------------------------------------------- */
715
716 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( valueOfInt32 )( IMPL_RTL_STRCODE* pStr,
717 sal_Int32 n,
718 sal_Int16 nRadix )
719 {
720 sal_Char aBuf[RTL_STR_MAX_VALUEOFINT32];
721 sal_Char* pBuf = aBuf;
722 sal_Int32 nLen = 0;
723 sal_uInt32 nValue;
724
725 /* Radix must be valid */
726 if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
727 nRadix = 10;
728
729 /* is value negativ */
730 if ( n < 0 )
731 {
732 *pStr = '-';
733 pStr++;
734 nLen++;
735 nValue = -n; /* FIXME this code is not portable for n == -2147483648
736 (smallest negative value for sal_Int32) */
737 }
738 else
739 nValue = n;
740
741 /* create a recursive buffer with all values, except the last one */
742 do
743 {
744 sal_Char nDigit = (sal_Char)(nValue % nRadix);
745 nValue /= nRadix;
746 if ( nDigit > 9 )
747 *pBuf = (nDigit-10) + 'a';
748 else
749 *pBuf = (nDigit + '0' );
750 pBuf++;
751 }
752 while ( nValue > 0 );
753
754 /* copy the values in the right direction into the destination buffer */
755 do
756 {
757 pBuf--;
758 *pStr = *pBuf;
759 pStr++;
760 nLen++;
761 }
762 while ( pBuf != aBuf );
763 *pStr = 0;
764
765 return nLen;
766 }
767
768 /* ----------------------------------------------------------------------- */
769
770 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( valueOfInt64 )( IMPL_RTL_STRCODE* pStr,
771 sal_Int64 n,
772 sal_Int16 nRadix )
773 {
774 sal_Char aBuf[RTL_STR_MAX_VALUEOFINT64];
775 sal_Char* pBuf = aBuf;
776 sal_Int32 nLen = 0;
777 sal_uInt64 nValue;
778
779 /* Radix must be valid */
780 if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
781 nRadix = 10;
782
783 /* is value negativ */
784 if ( n < 0 )
785 {
786 *pStr = '-';
787 pStr++;
788 nLen++;
789 nValue = -n; /* FIXME this code is not portable for
790 n == -9223372036854775808 (smallest negative value for
791 sal_Int64) */
792 }
793 else
794 nValue = n;
795
796 /* create a recursive buffer with all values, except the last one */
797 do
798 {
799 sal_Char nDigit = (sal_Char)(nValue % nRadix);
800 nValue /= nRadix;
801 if ( nDigit > 9 )
802 *pBuf = (nDigit-10) + 'a';
803 else
804 *pBuf = (nDigit + '0' );
805 pBuf++;
806 }
807 while ( nValue > 0 );
808
809 /* copy the values in the right direction into the destination buffer */
810 do
811 {
812 pBuf--;
813 *pStr = *pBuf;
814 pStr++;
815 nLen++;
816 }
817 while ( pBuf != aBuf );
818 *pStr = 0;
819
820 return nLen;
821 }
822
823 /* ----------------------------------------------------------------------- */
824
825 sal_Bool SAL_CALL IMPL_RTL_STRNAME( toBoolean )( const IMPL_RTL_STRCODE* pStr )
826 {
827 if ( *pStr == '1' )
828 return sal_True;
829
830 if ( (*pStr == 'T') || (*pStr == 't') )
831 {
832 pStr++;
833 if ( (*pStr == 'R') || (*pStr == 'r') )
834 {
835 pStr++;
836 if ( (*pStr == 'U') || (*pStr == 'u') )
837 {
838 pStr++;
839 if ( (*pStr == 'E') || (*pStr == 'e') )
840 return sal_True;
841 }
842 }
843 }
844
845 return sal_False;
846 }
847
848 /* ----------------------------------------------------------------------- */
849
850 sal_Int32 SAL_CALL IMPL_RTL_STRNAME( toInt32 )( const IMPL_RTL_STRCODE* pStr,
851 sal_Int16 nRadix )
852 {
853 sal_Bool bNeg;
854 sal_Int16 nDigit;
855 sal_Int32 n = 0;
856
857 if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
858 nRadix = 10;
859
860 /* Skip whitespaces */
861 while ( *pStr && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE( *pStr ) ) )
862 pStr++;
863
864 if ( *pStr == '-' )
865 {
866 bNeg = sal_True;
867 pStr++;
868 }
869 else
870 {
871 if ( *pStr == '+' )
872 pStr++;
873 bNeg = sal_False;
874 }
875
876 while ( *pStr )
877 {
878 nDigit = rtl_ImplGetDigit( IMPL_RTL_USTRCODE( *pStr ), nRadix );
879 if ( nDigit < 0 )
880 break;
881
882 n *= nRadix;
883 n += nDigit;
884
885 pStr++;
886 }
887
888 if ( bNeg )
889 return -n;
890 else
891 return n;
892 }
893
894 /* ----------------------------------------------------------------------- */
895
896 sal_Int64 SAL_CALL IMPL_RTL_STRNAME( toInt64 )( const IMPL_RTL_STRCODE* pStr,
897 sal_Int16 nRadix )
898 {
899 sal_Bool bNeg;
900 sal_Int16 nDigit;
901 sal_Int64 n = 0;
902
903 if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
904 nRadix = 10;
905
906 /* Skip whitespaces */
907 while ( *pStr && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE( *pStr ) ) )
908 pStr++;
909
910 if ( *pStr == '-' )
911 {
912 bNeg = sal_True;
913 pStr++;
914 }
915 else
916 {
917 if ( *pStr == '+' )
918 pStr++;
919 bNeg = sal_False;
920 }
921
922 while ( *pStr )
923 {
924 nDigit = rtl_ImplGetDigit( IMPL_RTL_USTRCODE( *pStr ), nRadix );
925 if ( nDigit < 0 )
926 break;
927
928 n *= nRadix;
929 n += nDigit;
930
931 pStr++;
932 }
933
934 if ( bNeg )
935 return -n;
936 else
937 return n;
938 }
939
940 /* ======================================================================= */
941 /* Internal String-Class help functions */
942 /* ======================================================================= */
943
944 static IMPL_RTL_STRINGDATA* IMPL_RTL_STRINGNAME( ImplAlloc )( sal_Int32 nLen )
945 {
946 IMPL_RTL_STRINGDATA * pData
947 = (SAL_INT_CAST(sal_uInt32, nLen)
948 <= ((SAL_MAX_UINT32 - sizeof (IMPL_RTL_STRINGDATA))
949 / sizeof (IMPL_RTL_STRCODE)))
950 ? (IMPL_RTL_STRINGDATA *) rtl_allocateMemory(
951 sizeof (IMPL_RTL_STRINGDATA) + nLen * sizeof (IMPL_RTL_STRCODE))
952 : NULL;
953 if (pData != NULL) {
954 pData->refCount = 1;
955 pData->length = nLen;
956 pData->buffer[nLen] = 0;
957 }
958 return pData;
959 }
960
961 /* ----------------------------------------------------------------------- */
962
963 static IMPL_RTL_STRCODE* IMPL_RTL_STRINGNAME( ImplNewCopy )( IMPL_RTL_STRINGDATA** ppThis,
964 IMPL_RTL_STRINGDATA* pStr,
965 sal_Int32 nCount )
966 {
967 IMPL_RTL_STRCODE* pDest;
968 const IMPL_RTL_STRCODE* pSrc;
969 IMPL_RTL_STRINGDATA* pData = IMPL_RTL_STRINGNAME( ImplAlloc )( pStr->length );
970 OSL_ASSERT(pData != NULL);
971
972 pDest = pData->buffer;
973 pSrc = pStr->buffer;
974 while ( nCount > 0 )
975 {
976 *pDest = *pSrc;
977 pDest++;
978 pSrc++;
979 nCount--;
980 }
981
982 *ppThis = pData;
983 return pDest;
984 }
985
986 /* ======================================================================= */
987 /* String-Class functions */
988 /* ======================================================================= */
989
990 #define IMPL_RTL_AQUIRE( pThis ) \
991 { \
992 if (!SAL_STRING_IS_STATIC (pThis)) \
993 osl_incrementInterlockedCount( &((pThis)->refCount) ); \
994 }
995
996 /* ----------------------------------------------------------------------- */
997
998 void SAL_CALL IMPL_RTL_STRINGNAME( acquire )( IMPL_RTL_STRINGDATA* pThis )
999 {
1000 IMPL_RTL_AQUIRE( pThis );
1001 }
1002
1003 /* ----------------------------------------------------------------------- */
1004
1005 void SAL_CALL IMPL_RTL_STRINGNAME( release )( IMPL_RTL_STRINGDATA* pThis )
1006 {
1007 if (SAL_STRING_IS_STATIC (pThis))
1008 return;
1009
1010 /* OString doesn't have an 'intern' */
1011 #ifdef IMPL_RTL_INTERN
1012 if (SAL_STRING_IS_INTERN (pThis))
1013 {
1014 internRelease (pThis);
1015 return;
1016 }
1017 #endif
1018
1019 if ( pThis->refCount == 1 ||
1020 !osl_decrementInterlockedCount( &(pThis->refCount) ) )
1021 {
1022 rtl_freeMemory( pThis );
1023 }
1024 }
1025
1026 /* ----------------------------------------------------------------------- */
1027
1028 void SAL_CALL IMPL_RTL_STRINGNAME( new )( IMPL_RTL_STRINGDATA** ppThis )
1029 {
1030 if ( *ppThis)
1031 IMPL_RTL_STRINGNAME( release )( *ppThis );
1032
1033 *ppThis = (IMPL_RTL_STRINGDATA*) (&IMPL_RTL_EMPTYSTRING);
1034 IMPL_RTL_AQUIRE( *ppThis );
1035 }
1036
1037 /* ----------------------------------------------------------------------- */
1038
1039 void SAL_CALL IMPL_RTL_STRINGNAME( new_WithLength )( IMPL_RTL_STRINGDATA** ppThis, sal_Int32 nLen )
1040 {
1041 if ( nLen <= 0 )
1042 IMPL_RTL_STRINGNAME( new )( ppThis );
1043 else
1044 {
1045 if ( *ppThis)
1046 IMPL_RTL_STRINGNAME( release )( *ppThis );
1047
1048 *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1049 OSL_ASSERT(*ppThis != NULL);
1050 (*ppThis)->length = 0;
1051
1052 {
1053 IMPL_RTL_STRCODE* pTempStr = (*ppThis)->buffer;
1054 while ( nLen >= 0 )
1055 {
1056 *pTempStr = 0;
1057 pTempStr++;
1058 nLen--;
1059 }
1060 }
1061 }
1062 }
1063
1064 /* ----------------------------------------------------------------------- */
1065
1066 void SAL_CALL IMPL_RTL_STRINGNAME( newFromString )( IMPL_RTL_STRINGDATA** ppThis,
1067 const IMPL_RTL_STRINGDATA* pStr )
1068 {
1069 IMPL_RTL_STRINGDATA* pOrg;
1070
1071 if ( !pStr->length )
1072 {
1073 IMPL_RTL_STRINGNAME( new )( ppThis );
1074 return;
1075 }
1076
1077 pOrg = *ppThis;
1078 *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( pStr->length );
1079 OSL_ASSERT(*ppThis != NULL);
1080 rtl_str_ImplCopy( (*ppThis)->buffer, pStr->buffer, pStr->length );
1081
1082 /* must be done at least, if pStr == *ppThis */
1083 if ( pOrg )
1084 IMPL_RTL_STRINGNAME( release )( pOrg );
1085 }
1086
1087 /* ----------------------------------------------------------------------- */
1088
1089 void SAL_CALL IMPL_RTL_STRINGNAME( newFromStr )( IMPL_RTL_STRINGDATA** ppThis,
1090 const IMPL_RTL_STRCODE* pCharStr )
1091 {
1092 IMPL_RTL_STRCODE* pBuffer;
1093 IMPL_RTL_STRINGDATA* pOrg;
1094 sal_Int32 nLen;
1095
1096 if ( pCharStr )
1097 {
1098 const IMPL_RTL_STRCODE* pTempStr = pCharStr;
1099 while( *pTempStr )
1100 pTempStr++;
1101 nLen = pTempStr-pCharStr;
1102 }
1103 else
1104 nLen = 0;
1105
1106 if ( !nLen )
1107 {
1108 IMPL_RTL_STRINGNAME( new )( ppThis );
1109 return;
1110 }
1111
1112 pOrg = *ppThis;
1113 *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1114 OSL_ASSERT(*ppThis != NULL);
1115 pBuffer = (*ppThis)->buffer;
1116 do
1117 {
1118 *pBuffer = *pCharStr;
1119 pBuffer++;
1120 pCharStr++;
1121 }
1122 while ( *pCharStr );
1123
1124 /* must be done at least, if pCharStr == *ppThis */
1125 if ( pOrg )
1126 IMPL_RTL_STRINGNAME( release )( pOrg );
1127 }
1128
1129 /* ----------------------------------------------------------------------- */
1130
1131 void SAL_CALL IMPL_RTL_STRINGNAME( newFromStr_WithLength )( IMPL_RTL_STRINGDATA** ppThis,
1132 const IMPL_RTL_STRCODE* pCharStr,
1133 sal_Int32 nLen )
1134 {
1135 IMPL_RTL_STRINGDATA* pOrg;
1136
1137 if ( !pCharStr || (nLen <= 0) )
1138 {
1139 IMPL_RTL_STRINGNAME( new )( ppThis );
1140 return;
1141 }
1142
1143 pOrg = *ppThis;
1144 *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1145 OSL_ASSERT(*ppThis != NULL);
1146 rtl_str_ImplCopy( (*ppThis)->buffer, pCharStr, nLen );
1147
1148 /* must be done at least, if pCharStr == *ppThis */
1149 if ( pOrg )
1150 IMPL_RTL_STRINGNAME( release )( pOrg );
1151 }
1152
1153 /* ----------------------------------------------------------------------- */
1154
1155 void SAL_CALL IMPL_RTL_STRINGNAME( assign )( IMPL_RTL_STRINGDATA** ppThis,
1156 IMPL_RTL_STRINGDATA* pStr )
1157 {
1158 /* must be done at first, if pStr == *ppThis */
1159 IMPL_RTL_AQUIRE( pStr );
1160
1161 if ( *ppThis )
1162 IMPL_RTL_STRINGNAME( release )( *ppThis );
1163
1164 *ppThis = pStr;
1165 }
1166
1167 /* ----------------------------------------------------------------------- */
1168
1169 sal_Int32 SAL_CALL IMPL_RTL_STRINGNAME( getLength )( const IMPL_RTL_STRINGDATA* pThis )
1170 {
1171 return pThis->length;
1172 }
1173
1174 /* ----------------------------------------------------------------------- */
1175
1176 IMPL_RTL_STRCODE* SAL_CALL IMPL_RTL_STRINGNAME( getStr )( IMPL_RTL_STRINGDATA * pThis )
1177 {
1178 return pThis->buffer;
1179 }
1180
1181 /* ----------------------------------------------------------------------- */
1182
1183 void SAL_CALL IMPL_RTL_STRINGNAME( newConcat )( IMPL_RTL_STRINGDATA** ppThis,
1184 IMPL_RTL_STRINGDATA* pLeft,
1185 IMPL_RTL_STRINGDATA* pRight )
1186 {
1187 IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1188
1189 /* Test for 0-Pointer - if not, change newReplaceStrAt! */
1190 if ( !pRight || !pRight->length )
1191 {
1192 *ppThis = pLeft;
1193 IMPL_RTL_AQUIRE( pLeft );
1194 }
1195 else if ( !pLeft || !pLeft->length )
1196 {
1197 *ppThis = pRight;
1198 IMPL_RTL_AQUIRE( pRight );
1199 }
1200 else
1201 {
1202 IMPL_RTL_STRINGDATA* pTempStr = IMPL_RTL_STRINGNAME( ImplAlloc )( pLeft->length + pRight->length );
1203 OSL_ASSERT(pTempStr != NULL);
1204 rtl_str_ImplCopy( pTempStr->buffer, pLeft->buffer, pLeft->length );
1205 rtl_str_ImplCopy( pTempStr->buffer+pLeft->length, pRight->buffer, pRight->length );
1206 *ppThis = pTempStr;
1207 }
1208
1209 /* must be done at least, if left or right == *ppThis */
1210 if ( pOrg )
1211 IMPL_RTL_STRINGNAME( release )( pOrg );
1212 }
1213
1214 /* ----------------------------------------------------------------------- */
1215
1216 void SAL_CALL IMPL_RTL_STRINGNAME( newReplaceStrAt )( IMPL_RTL_STRINGDATA** ppThis,
1217 IMPL_RTL_STRINGDATA* pStr,
1218 sal_Int32 nIndex,
1219 sal_Int32 nCount,
1220 IMPL_RTL_STRINGDATA* pNewSubStr )
1221 {
1222 /* Append? */
1223 if ( nIndex >= pStr->length )
1224 {
1225 /* newConcat test, if pNewSubStr is 0 */
1226 IMPL_RTL_STRINGNAME( newConcat )( ppThis, pStr, pNewSubStr );
1227 return;
1228 }
1229
1230 /* negativ index? */
1231 if ( nIndex < 0 )
1232 {
1233 nCount -= nIndex;
1234 nIndex = 0;
1235 }
1236
1237 /* not more than the String length could be deleted */
1238 if ( nCount >= pStr->length-nIndex )
1239 {
1240 nCount = pStr->length-nIndex;
1241
1242 /* Assign of NewSubStr? */
1243 if ( !nIndex && (nCount >= pStr->length) )
1244 {
1245 if ( !pNewSubStr )
1246 IMPL_RTL_STRINGNAME( new )( ppThis );
1247 else
1248 IMPL_RTL_STRINGNAME( assign )( ppThis, pNewSubStr );
1249 return;
1250 }
1251 }
1252
1253 /* Assign of Str? */
1254 if ( !nCount && (!pNewSubStr || !pNewSubStr->length) )
1255 {
1256 IMPL_RTL_STRINGNAME( assign )( ppThis, pStr );
1257 return;
1258 }
1259
1260 {
1261 IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1262 IMPL_RTL_STRCODE* pBuffer;
1263 sal_Int32 nNewLen;
1264
1265 /* Calculate length of the new string */
1266 nNewLen = pStr->length-nCount;
1267 if ( pNewSubStr )
1268 nNewLen += pNewSubStr->length;
1269
1270 /* Alloc New Buffer */
1271 *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nNewLen );
1272 OSL_ASSERT(*ppThis != NULL);
1273 pBuffer = (*ppThis)->buffer;
1274 if ( nIndex )
1275 {
1276 rtl_str_ImplCopy( pBuffer, pStr->buffer, nIndex );
1277 pBuffer += nIndex;
1278 }
1279 if ( pNewSubStr && pNewSubStr->length )
1280 {
1281 rtl_str_ImplCopy( pBuffer, pNewSubStr->buffer, pNewSubStr->length );
1282 pBuffer += pNewSubStr->length;
1283 }
1284 rtl_str_ImplCopy( pBuffer, pStr->buffer+nIndex+nCount, pStr->length-nIndex-nCount );
1285
1286 /* must be done at least, if pStr or pNewSubStr == *ppThis */
1287 if ( pOrg )
1288 IMPL_RTL_STRINGNAME( release )( pOrg );
1289 }
1290 }
1291
1292 /* ----------------------------------------------------------------------- */
1293
1294 void SAL_CALL IMPL_RTL_STRINGNAME( newReplace )( IMPL_RTL_STRINGDATA** ppThis,
1295 IMPL_RTL_STRINGDATA* pStr,
1296 IMPL_RTL_STRCODE cOld,
1297 IMPL_RTL_STRCODE cNew )
1298 {
1299 IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1300 int bChanged = 0;
1301 sal_Int32 nLen = pStr->length;
1302 const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1303
1304 while ( nLen > 0 )
1305 {
1306 if ( *pCharStr == cOld )
1307 {
1308 /* Copy String */
1309 IMPL_RTL_STRCODE* pNewCharStr = IMPL_RTL_STRINGNAME( ImplNewCopy )( ppThis, pStr, pCharStr-pStr->buffer );
1310
1311 /* replace/copy rest of the string */
1312 if ( pNewCharStr )
1313 {
1314 *pNewCharStr = cNew;
1315 pNewCharStr++;
1316 pCharStr++;
1317 nLen--;
1318
1319 while ( nLen > 0 )
1320 {
1321 if ( *pCharStr == cOld )
1322 *pNewCharStr = cNew;
1323 else
1324 *pNewCharStr = *pCharStr;
1325
1326 pNewCharStr++;
1327 pCharStr++;
1328 nLen--;
1329 }
1330 }
1331
1332 bChanged = 1;
1333 break;
1334 }
1335
1336 pCharStr++;
1337 nLen--;
1338 }
1339
1340 if ( !bChanged )
1341 {
1342 *ppThis = pStr;
1343 IMPL_RTL_AQUIRE( pStr );
1344 }
1345
1346 /* must be done at least, if pStr == *ppThis */
1347 if ( pOrg )
1348 IMPL_RTL_STRINGNAME( release )( pOrg );
1349 }
1350
1351 /* ----------------------------------------------------------------------- */
1352
1353 void SAL_CALL IMPL_RTL_STRINGNAME( newToAsciiLowerCase )( IMPL_RTL_STRINGDATA** ppThis,
1354 IMPL_RTL_STRINGDATA* pStr )
1355 {
1356 IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1357 int bChanged = 0;
1358 sal_Int32 nLen = pStr->length;
1359 const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1360
1361 while ( nLen > 0 )
1362 {
1363 /* Between A-Z (65-90), than to lowercase (+32) */
1364 if ( (*pCharStr >= 65) && (*pCharStr <= 90) )
1365 {
1366 /* Copy String */
1367 IMPL_RTL_STRCODE* pNewCharStr = IMPL_RTL_STRINGNAME( ImplNewCopy )( ppThis, pStr, pCharStr-pStr->buffer );
1368
1369 /* replace/copy rest of the string */
1370 if ( pNewCharStr )
1371 {
1372 /* to lowercase (+32) */
1373 *pNewCharStr = *pCharStr+32;
1374 pNewCharStr++;
1375 pCharStr++;
1376 nLen--;
1377
1378 while ( nLen > 0 )
1379 {
1380 /* Between A-Z (65-90), than to lowercase (+32) */
1381 if ( (*pCharStr >= 65) && (*pCharStr <= 90) )
1382 *pNewCharStr = *pCharStr+32;
1383 else
1384 *pNewCharStr = *pCharStr;
1385
1386 pNewCharStr++;
1387 pCharStr++;
1388 nLen--;
1389 }
1390 }
1391
1392 bChanged = 1;
1393 break;
1394 }
1395
1396 pCharStr++;
1397 nLen--;
1398 }
1399
1400 if ( !bChanged )
1401 {
1402 *ppThis = pStr;
1403 IMPL_RTL_AQUIRE( pStr );
1404 }
1405
1406 /* must be done at least, if pStr == *ppThis */
1407 if ( pOrg )
1408 IMPL_RTL_STRINGNAME( release )( pOrg );
1409 }
1410
1411 /* ----------------------------------------------------------------------- */
1412
1413 void SAL_CALL IMPL_RTL_STRINGNAME( newToAsciiUpperCase )( IMPL_RTL_STRINGDATA** ppThis,
1414 IMPL_RTL_STRINGDATA* pStr )
1415 {
1416 IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1417 int bChanged = 0;
1418 sal_Int32 nLen = pStr->length;
1419 const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1420
1421 while ( nLen > 0 )
1422 {
1423 /* Between a-z (97-122), than to uppercase (-32) */
1424 if ( (*pCharStr >= 97) && (*pCharStr <= 122) )
1425 {
1426 /* Copy String */
1427 IMPL_RTL_STRCODE* pNewCharStr = IMPL_RTL_STRINGNAME( ImplNewCopy )( ppThis, pStr, pCharStr-pStr->buffer );
1428
1429 /* replace/copy rest of the string */
1430 if ( pNewCharStr )
1431 {
1432 /* to uppercase (-32) */
1433 *pNewCharStr = *pCharStr-32;
1434 pNewCharStr++;
1435 pCharStr++;
1436 nLen--;
1437
1438 while ( nLen > 0 )
1439 {
1440 /* Between a-z (97-122), than to uppercase (-32) */
1441 if ( (*pCharStr >= 97) && (*pCharStr <= 122) )
1442 *pNewCharStr = *pCharStr-32;
1443 else
1444 *pNewCharStr = *pCharStr;
1445
1446 pNewCharStr++;
1447 pCharStr++;
1448 nLen--;
1449 }
1450 }
1451
1452 bChanged = 1;
1453 break;
1454 }
1455
1456 pCharStr++;
1457 nLen--;
1458 }
1459
1460 if ( !bChanged )
1461 {
1462 *ppThis = pStr;
1463 IMPL_RTL_AQUIRE( pStr );
1464 }
1465
1466 /* must be done at least, if pStr == *ppThis */
1467 if ( pOrg )
1468 IMPL_RTL_STRINGNAME( release )( pOrg );
1469 }
1470
1471 /* ----------------------------------------------------------------------- */
1472
1473 void SAL_CALL IMPL_RTL_STRINGNAME( newTrim )( IMPL_RTL_STRINGDATA** ppThis,
1474 IMPL_RTL_STRINGDATA* pStr )
1475 {
1476 IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1477 const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1478 sal_Int32 nPreSpaces = 0;
1479 sal_Int32 nPostSpaces = 0;
1480 sal_Int32 nLen = pStr->length;
1481 sal_Int32 nIndex = nLen-1;
1482
1483 while ( (nPreSpaces < nLen) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pCharStr+nPreSpaces)) ) )
1484 nPreSpaces++;
1485
1486 while ( (nIndex > nPreSpaces) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pCharStr+nIndex)) ) )
1487 {
1488 nPostSpaces++;
1489 nIndex--;
1490 }
1491
1492 if ( !nPreSpaces && !nPostSpaces )
1493 {
1494 *ppThis = pStr;
1495 IMPL_RTL_AQUIRE( pStr );
1496 }
1497 else
1498 {
1499 nLen -= nPostSpaces+nPreSpaces;
1500 *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1501 OSL_ASSERT(*ppThis != NULL);
1502 if ( *ppThis )
1503 rtl_str_ImplCopy( (*ppThis)->buffer, pStr->buffer+nPreSpaces, nLen );
1504 }
1505
1506 /* must be done at least, if pStr == *ppThis */
1507 if ( pOrg )
1508 IMPL_RTL_STRINGNAME( release )( pOrg );
1509 }
1510
1511 /* ----------------------------------------------------------------------- */
1512
1513 sal_Int32 SAL_CALL IMPL_RTL_STRINGNAME( getToken )( IMPL_RTL_STRINGDATA** ppThis,
1514 IMPL_RTL_STRINGDATA* pStr,
1515 sal_Int32 nToken,
1516 IMPL_RTL_STRCODE cTok,
1517 sal_Int32 nIndex )
1518 {
1519 const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1520 const IMPL_RTL_STRCODE* pCharStrStart;
1521 const IMPL_RTL_STRCODE* pOrgCharStr;
1522 sal_Int32 nLen = pStr->length-nIndex;
1523 sal_Int32 nTokCount = 0;
1524
1525 // Set ppThis to an empty string and return -1 if either nToken or nIndex is
1526 // negative:
1527 if (nIndex < 0) {
1528 nToken = -1;
1529 }
1530
1531 pCharStr += nIndex;
1532 pOrgCharStr = pCharStr;
1533 pCharStrStart = pCharStr;
1534 while ( nLen > 0 )
1535 {
1536 if ( *pCharStr == cTok )
1537 {
1538 nTokCount++;
1539
1540 if ( nTokCount == nToken )
1541 pCharStrStart = pCharStr+1;
1542 else
1543 {
1544 if ( nTokCount > nToken )
1545 break;
1546 }
1547 }
1548
1549 pCharStr++;
1550 nLen--;
1551 }
1552
1553 if ( (nToken < 0) || (nTokCount < nToken) || (pCharStr == pCharStrStart) )
1554 {
1555 IMPL_RTL_STRINGNAME( new )( ppThis );
1556 if( (nToken < 0) || (nTokCount < nToken ) )
1557 return -1;
1558 else if( nLen > 0 )
1559 return nIndex+(pCharStr-pOrgCharStr)+1;
1560 else return -1;
1561 }
1562 else
1563 {
1564 IMPL_RTL_STRINGNAME( newFromStr_WithLength )( ppThis, pCharStrStart, pCharStr-pCharStrStart );
1565 if ( nLen )
1566 return nIndex+(pCharStr-pOrgCharStr)+1;
1567 else
1568 return -1;
1569 }
1570 }
vba interoperability for OOo