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