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