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