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 <cstring>
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 523108637 : 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 523108637 : memcpy( _pDest, _pSrc, _nCount * sizeof(IMPL_RTL_STRCODE));
55 523108637 : }
56 :
57 : /* ======================================================================= */
58 : /* C-String functions which could be used without the String-Class */
59 : /* ======================================================================= */
60 :
61 186622156 : 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 174335030 : 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 12287126 : const IMPL_RTL_STRCODE* pTempStr = pStr;
77 493723263 : while( *pTempStr )
78 469149011 : pTempStr++;
79 12287126 : return pTempStr-pStr;
80 : }
81 : #endif
82 : }
83 :
84 : /* ----------------------------------------------------------------------- */
85 :
86 61978852 : 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 394453 : 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 1989147313 : while ( ((nRet = ((sal_Int32)(IMPL_RTL_USTRCODE(*pStr1)))-
105 963781457 : ((sal_Int32)(IMPL_RTL_USTRCODE(*pStr2)))) == 0) &&
106 : *pStr2 )
107 : {
108 902197058 : pStr1++;
109 902197058 : pStr2++;
110 : }
111 :
112 61584399 : return nRet;
113 : }
114 : #endif
115 : }
116 :
117 : /* ----------------------------------------------------------------------- */
118 :
119 3483223385 : 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 78560190 : sal_Int32 nMin = std::min(nStr1Len, nStr2Len);
130 78560190 : sal_Int32 nRet = strncmp(pStr1, pStr2, nMin);
131 78560190 : 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 3404663195 : sal_Int32 nRet = nStr1Len - nStr2Len;
143 3404663195 : int nCount = (nRet <= 0) ? nStr1Len : nStr2Len;
144 :
145 3404663195 : --pStr1;
146 3404663195 : --pStr2;
147 3404663195 : while( (--nCount >= 0) && (*++pStr1 == *++pStr2) ) ;
148 :
149 3404663195 : if( nCount >= 0 )
150 : nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1 )))
151 2538493118 : - ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2 )));
152 :
153 3404663195 : return nRet;
154 : }
155 : #endif
156 : }
157 :
158 : /* ----------------------------------------------------------------------- */
159 :
160 39879312 : 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 1289551 : sal_Int32 nMin = std::min(std::min(nStr1Len, nStr2Len), nShortenedLength);
173 1289551 : sal_Int32 nRet = strncmp(pStr1, pStr2, nMin);
174 1289551 : if (nRet == 0 && nShortenedLength > std::min(nStr1Len, nStr2Len))
175 221991 : return nStr1Len - nStr2Len;
176 1067560 : 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 38589761 : const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
190 38589761 : const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
191 : sal_Int32 nRet;
192 86915979 : while ( (nShortenedLength > 0) &&
193 47486863 : (pStr1 < pStr1End) && (pStr2 < pStr2End) )
194 : {
195 47486863 : nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1 )))-
196 47486863 : ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2 )));
197 47486863 : if ( nRet )
198 37750406 : return nRet;
199 :
200 9736457 : nShortenedLength--;
201 9736457 : pStr1++;
202 9736457 : pStr2++;
203 : }
204 :
205 839355 : if ( nShortenedLength <= 0 )
206 804455 : return 0;
207 34900 : return nStr1Len - nStr2Len;
208 : }
209 : #endif
210 : }
211 :
212 : /* ----------------------------------------------------------------------- */
213 :
214 3192937488 : 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 3192937488 : const IMPL_RTL_STRCODE* pStr1Run = pStr1+nStr1Len;
223 3192937488 : const IMPL_RTL_STRCODE* pStr2Run = pStr2+nStr2Len;
224 : sal_Int32 nRet;
225 14295044505 : while ( (pStr1 < pStr1Run) && (pStr2 < pStr2Run) )
226 : {
227 9443190926 : pStr1Run--;
228 9443190926 : pStr2Run--;
229 9443190926 : nRet = ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr1Run )))-
230 9443190926 : ((sal_Int32)(IMPL_RTL_USTRCODE( *pStr2Run )));
231 9443190926 : if ( nRet )
232 1534021397 : return nRet;
233 : }
234 :
235 1658916091 : return nStr1Len - nStr2Len;
236 : }
237 :
238 : /* ----------------------------------------------------------------------- */
239 :
240 203405 : 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 167853 : do
248 : {
249 203405 : c1 = IMPL_RTL_USTRCODE(*pStr1);
250 : sal_Int32 nRet = rtl::compareIgnoreAsciiCase(
251 203405 : c1, IMPL_RTL_USTRCODE(*pStr2));
252 203405 : if ( nRet != 0 )
253 35552 : return nRet;
254 :
255 167853 : pStr1++;
256 167853 : pStr2++;
257 : }
258 : while (c1);
259 :
260 14855 : return 0;
261 : }
262 :
263 : /* ----------------------------------------------------------------------- */
264 :
265 8564409362 : 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 8564409362 : const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
274 8564409362 : const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
275 29592460223 : while ( (pStr1 < pStr1End) && (pStr2 < pStr2End) )
276 : {
277 : sal_Int32 nRet = rtl::compareIgnoreAsciiCase(
278 19276856980 : IMPL_RTL_USTRCODE(*pStr1), IMPL_RTL_USTRCODE(*pStr2));
279 19276856980 : if ( nRet != 0 )
280 6813215481 : return nRet;
281 :
282 12463641499 : pStr1++;
283 12463641499 : pStr2++;
284 : }
285 :
286 1751193881 : return nStr1Len - nStr2Len;
287 : }
288 :
289 : /* ----------------------------------------------------------------------- */
290 :
291 1078946 : 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 1078946 : const IMPL_RTL_STRCODE* pStr1End = pStr1 + nStr1Len;
302 1078946 : const IMPL_RTL_STRCODE* pStr2End = pStr2 + nStr2Len;
303 2385973 : while ( (nShortenedLength > 0) &&
304 1177820 : (pStr1 < pStr1End) && (pStr2 < pStr2End) )
305 : {
306 : sal_Int32 nRet = rtl::compareIgnoreAsciiCase(
307 1177820 : IMPL_RTL_USTRCODE(*pStr1), IMPL_RTL_USTRCODE(*pStr2));
308 1177820 : if ( nRet != 0 )
309 949739 : return nRet;
310 :
311 228081 : nShortenedLength--;
312 228081 : pStr1++;
313 228081 : pStr2++;
314 : }
315 :
316 129207 : if ( nShortenedLength <= 0 )
317 1261 : return 0;
318 127946 : return nStr1Len - nStr2Len;
319 : }
320 :
321 : /* ----------------------------------------------------------------------- */
322 :
323 4408789 : sal_Int32 SAL_CALL IMPL_RTL_STRNAME( hashCode )( const IMPL_RTL_STRCODE* pStr )
324 : SAL_THROW_EXTERN_C()
325 : {
326 4408789 : return IMPL_RTL_STRNAME( hashCode_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
327 : }
328 :
329 : /* ----------------------------------------------------------------------- */
330 :
331 111899454 : 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 111899454 : sal_uInt32 h = static_cast<sal_uInt32>(nLen);
337 3408807793 : while ( nLen > 0 )
338 : {
339 3185008885 : h = (h*37U) + IMPL_RTL_USTRCODE( *pStr );
340 3185008885 : pStr++;
341 3185008885 : nLen--;
342 : }
343 111899454 : return static_cast<sal_Int32>(h);
344 : }
345 :
346 : /* ----------------------------------------------------------------------- */
347 :
348 5763 : 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 0 : const IMPL_RTL_STRCODE* p = strchr(pStr, c);
356 0 : 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 5763 : const IMPL_RTL_STRCODE* pTempStr = pStr;
367 83370 : while ( *pTempStr )
368 : {
369 77607 : if ( *pTempStr == c )
370 5763 : return pTempStr-pStr;
371 :
372 71844 : pTempStr++;
373 : }
374 :
375 0 : return -1;
376 : }
377 : #endif
378 : }
379 :
380 : /* ----------------------------------------------------------------------- */
381 :
382 160413310 : 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 124239479 : IMPL_RTL_STRCODE* p = static_cast<IMPL_RTL_STRCODE*>(std::memchr(const_cast<IMPL_RTL_STRCODE *>(pStr), c, nLen));
391 124239479 : return p ? p - pStr : -1;
392 : #else
393 36173831 : const IMPL_RTL_STRCODE* pTempStr = pStr;
394 386673168 : while ( nLen > 0 )
395 : {
396 330464770 : if ( *pTempStr == c )
397 16139264 : return pTempStr-pStr;
398 :
399 314325506 : pTempStr++;
400 314325506 : nLen--;
401 : }
402 :
403 20034567 : return -1;
404 : #endif
405 : }
406 :
407 : /* ----------------------------------------------------------------------- */
408 :
409 69 : 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 0 : const IMPL_RTL_STRCODE* p = strrchr(pStr, c);
417 0 : 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 69 : return IMPL_RTL_STRNAME( lastIndexOfChar_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ), c );
428 : }
429 : #endif
430 : }
431 :
432 : /* ----------------------------------------------------------------------- */
433 :
434 1834899 : 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 1834899 : pStr += nLen;
441 34454452 : while ( nLen > 0 )
442 : {
443 32286773 : nLen--;
444 32286773 : pStr--;
445 :
446 32286773 : if ( *pStr == c )
447 1502119 : return nLen;
448 : }
449 :
450 332780 : return -1;
451 : }
452 :
453 : /* ----------------------------------------------------------------------- */
454 :
455 245 : 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 245 : const IMPL_RTL_STRCODE* p = strstr(pStr, pSubStr);
464 245 : 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 0 : pSubStr, IMPL_RTL_STRNAME( getLength )( pSubStr ) );
476 : }
477 : #endif
478 : }
479 :
480 : /* ----------------------------------------------------------------------- */
481 :
482 192834800 : 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 192834800 : if ( nSubLen < 2 )
492 : {
493 : /* an empty SubString is always not findable */
494 175597718 : if ( nSubLen == 1 )
495 : {
496 175597658 : IMPL_RTL_STRCODE c = *pSubStr;
497 175597658 : const IMPL_RTL_STRCODE* pTempStr = pStr;
498 1870418514 : while ( nStrLen > 0 )
499 : {
500 1521233368 : if ( *pTempStr == c )
501 2010170 : return pTempStr-pStr;
502 :
503 1519223198 : pTempStr++;
504 1519223198 : nStrLen--;
505 : }
506 : }
507 : }
508 : else
509 : {
510 17237082 : const IMPL_RTL_STRCODE* pTempStr = pStr;
511 443976471 : while ( nStrLen > 0 )
512 : {
513 414031370 : if ( *pTempStr == *pSubStr )
514 : {
515 : /* Compare SubString */
516 13776740 : if ( nSubLen <= nStrLen )
517 : {
518 12933873 : const IMPL_RTL_STRCODE* pTempStr1 = pTempStr;
519 12933873 : const IMPL_RTL_STRCODE* pTempStr2 = pSubStr;
520 12933873 : sal_Int32 nTempLen = nSubLen;
521 50303219 : while ( nTempLen )
522 : {
523 33683150 : if ( *pTempStr1 != *pTempStr2 )
524 9247677 : break;
525 :
526 24435473 : pTempStr1++;
527 24435473 : pTempStr2++;
528 24435473 : nTempLen--;
529 : }
530 :
531 12933873 : if ( !nTempLen )
532 3686196 : return pTempStr-pStr;
533 : }
534 : else
535 842867 : break;
536 : }
537 :
538 409502307 : nStrLen--;
539 409502307 : pTempStr++;
540 : }
541 : }
542 :
543 187138434 : return -1;
544 : }
545 :
546 : /* ----------------------------------------------------------------------- */
547 :
548 0 : 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 0 : pSubStr, IMPL_RTL_STRNAME( getLength )( pSubStr ) );
554 : }
555 :
556 : /* ----------------------------------------------------------------------- */
557 :
558 135005 : 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 135005 : if ( nSubLen < 2 )
568 : {
569 : /* an empty SubString is always not findable */
570 4714 : if ( nSubLen == 1 )
571 : {
572 4713 : IMPL_RTL_STRCODE c = *pSubStr;
573 4713 : pStr += nStrLen;
574 53409 : while ( nStrLen > 0 )
575 : {
576 45757 : nStrLen--;
577 45757 : pStr--;
578 :
579 45757 : if ( *pStr == c )
580 1774 : return nStrLen;
581 : }
582 : }
583 : }
584 : else
585 : {
586 130291 : pStr += nStrLen;
587 130291 : nStrLen -= nSubLen;
588 130291 : pStr -= nSubLen;
589 4789849 : while ( nStrLen >= 0 )
590 : {
591 4585519 : const IMPL_RTL_STRCODE* pTempStr1 = pStr;
592 4585519 : const IMPL_RTL_STRCODE* pTempStr2 = pSubStr;
593 4585519 : sal_Int32 nTempLen = nSubLen;
594 9412548 : while ( nTempLen )
595 : {
596 4770777 : if ( *pTempStr1 != *pTempStr2 )
597 4529267 : break;
598 :
599 241510 : pTempStr1++;
600 241510 : pTempStr2++;
601 241510 : nTempLen--;
602 : }
603 :
604 4585519 : if ( !nTempLen )
605 56252 : return nStrLen;
606 :
607 4529267 : nStrLen--;
608 4529267 : pStr--;
609 : }
610 : }
611 :
612 76979 : return -1;
613 : }
614 :
615 : /* ----------------------------------------------------------------------- */
616 :
617 0 : 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 0 : while ( *pStr )
624 : {
625 0 : if ( *pStr == cOld )
626 0 : *pStr = cNew;
627 :
628 0 : pStr++;
629 : }
630 0 : }
631 :
632 : /* ----------------------------------------------------------------------- */
633 :
634 0 : 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 0 : while ( nLen > 0 )
642 : {
643 0 : if ( *pStr == cOld )
644 0 : *pStr = cNew;
645 :
646 0 : pStr++;
647 0 : nLen--;
648 : }
649 0 : }
650 :
651 : /* ----------------------------------------------------------------------- */
652 :
653 0 : void SAL_CALL IMPL_RTL_STRNAME( toAsciiLowerCase )( IMPL_RTL_STRCODE* pStr )
654 : SAL_THROW_EXTERN_C()
655 : {
656 : assert(pStr);
657 0 : while ( *pStr )
658 : {
659 0 : *pStr = rtl::toAsciiLowerCase(IMPL_RTL_USTRCODE(*pStr));
660 :
661 0 : pStr++;
662 : }
663 0 : }
664 :
665 : /* ----------------------------------------------------------------------- */
666 :
667 2074587 : 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 21713172 : while ( nLen > 0 )
673 : {
674 17563998 : *pStr = rtl::toAsciiLowerCase(IMPL_RTL_USTRCODE(*pStr));
675 :
676 17563998 : pStr++;
677 17563998 : nLen--;
678 : }
679 2074587 : }
680 :
681 : /* ----------------------------------------------------------------------- */
682 :
683 0 : void SAL_CALL IMPL_RTL_STRNAME( toAsciiUpperCase )( IMPL_RTL_STRCODE* pStr )
684 : SAL_THROW_EXTERN_C()
685 : {
686 : assert(pStr);
687 0 : while ( *pStr )
688 : {
689 0 : *pStr = rtl::toAsciiUpperCase(IMPL_RTL_USTRCODE(*pStr));
690 :
691 0 : pStr++;
692 : }
693 0 : }
694 :
695 : /* ----------------------------------------------------------------------- */
696 :
697 0 : 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 0 : while ( nLen > 0 )
703 : {
704 0 : *pStr = rtl::toAsciiUpperCase(IMPL_RTL_USTRCODE(*pStr));
705 :
706 0 : pStr++;
707 0 : nLen--;
708 : }
709 0 : }
710 :
711 : /* ----------------------------------------------------------------------- */
712 :
713 0 : sal_Int32 SAL_CALL IMPL_RTL_STRNAME( trim )( IMPL_RTL_STRCODE* pStr )
714 : SAL_THROW_EXTERN_C()
715 : {
716 0 : return IMPL_RTL_STRNAME( trim_WithLength )( pStr, IMPL_RTL_STRNAME( getLength )( pStr ) );
717 : }
718 :
719 : /* ----------------------------------------------------------------------- */
720 :
721 0 : 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 0 : sal_Int32 nPreSpaces = 0;
726 0 : sal_Int32 nPostSpaces = 0;
727 0 : sal_Int32 nIndex = nLen-1;
728 :
729 0 : while ( (nPreSpaces < nLen) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nPreSpaces)) ) )
730 0 : nPreSpaces++;
731 :
732 0 : while ( (nIndex > nPreSpaces) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pStr+nIndex)) ) )
733 : {
734 0 : nPostSpaces++;
735 0 : nIndex--;
736 : }
737 :
738 0 : if ( nPostSpaces )
739 : {
740 0 : nLen -= nPostSpaces;
741 0 : *(pStr+nLen) = 0;
742 : }
743 :
744 0 : if ( nPreSpaces )
745 : {
746 0 : IMPL_RTL_STRCODE* pNewStr = pStr+nPreSpaces;
747 :
748 0 : nLen -= nPreSpaces;
749 0 : nIndex = nLen;
750 :
751 0 : while ( nIndex )
752 : {
753 0 : *pStr = *pNewStr;
754 0 : pStr++;
755 0 : pNewStr++;
756 0 : nIndex--;
757 : }
758 0 : *pStr = 0;
759 : }
760 :
761 0 : return nLen;
762 : }
763 :
764 : /* ----------------------------------------------------------------------- */
765 :
766 850 : 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 850 : if ( b )
771 : {
772 677 : *pStr = 't';
773 677 : pStr++;
774 677 : *pStr = 'r';
775 677 : pStr++;
776 677 : *pStr = 'u';
777 677 : pStr++;
778 677 : *pStr = 'e';
779 677 : pStr++;
780 677 : *pStr = 0;
781 677 : return 4;
782 : }
783 : else
784 : {
785 173 : *pStr = 'f';
786 173 : pStr++;
787 173 : *pStr = 'a';
788 173 : pStr++;
789 173 : *pStr = 'l';
790 173 : pStr++;
791 173 : *pStr = 's';
792 173 : pStr++;
793 173 : *pStr = 'e';
794 173 : pStr++;
795 173 : *pStr = 0;
796 173 : return 5;
797 : }
798 : }
799 :
800 : /* ----------------------------------------------------------------------- */
801 :
802 0 : 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 0 : *pStr++ = c;
808 0 : *pStr = 0;
809 0 : return 1;
810 : }
811 :
812 : /* ----------------------------------------------------------------------- */
813 :
814 2863637 : 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 2863637 : sal_Char* pBuf = aBuf;
822 2863637 : sal_Int32 nLen = 0;
823 : sal_uInt32 nValue;
824 :
825 : /* Radix must be valid */
826 2863637 : if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
827 5 : nRadix = 10;
828 :
829 : /* is value negativ */
830 2863637 : if ( n < 0 )
831 : {
832 7517 : *pStr = '-';
833 7517 : pStr++;
834 7517 : nLen++;
835 7517 : nValue = n == SAL_MIN_INT32 ? static_cast<sal_uInt32>(n) : -n;
836 : }
837 : else
838 2856120 : nValue = n;
839 :
840 : /* create a recursive buffer with all values, except the last one */
841 5109477 : do
842 : {
843 5109477 : sal_Char nDigit = (sal_Char)(nValue % nRadix);
844 5109477 : nValue /= nRadix;
845 5109477 : if ( nDigit > 9 )
846 88317 : *pBuf = (nDigit-10) + 'a';
847 : else
848 5021160 : *pBuf = (nDigit + '0' );
849 5109477 : pBuf++;
850 : }
851 : while ( nValue > 0 );
852 :
853 : /* copy the values in the right direction into the destination buffer */
854 5109477 : do
855 : {
856 5109477 : pBuf--;
857 5109477 : *pStr = *pBuf;
858 5109477 : pStr++;
859 5109477 : nLen++;
860 : }
861 : while ( pBuf != aBuf );
862 2863637 : *pStr = 0;
863 :
864 2863637 : return nLen;
865 : }
866 :
867 : /* ----------------------------------------------------------------------- */
868 :
869 9627750 : 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 9627750 : sal_Char* pBuf = aBuf;
877 9627750 : sal_Int32 nLen = 0;
878 : sal_uInt64 nValue;
879 :
880 : /* Radix must be valid */
881 9627750 : if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
882 5 : nRadix = 10;
883 :
884 : /* is value negativ */
885 9627750 : if ( n < 0 )
886 : {
887 1119 : *pStr = '-';
888 1119 : pStr++;
889 1119 : nLen++;
890 1119 : nValue = n == SAL_MIN_INT64 ? static_cast<sal_uInt64>(n) : -n;
891 : }
892 : else
893 9626631 : nValue = n;
894 :
895 : /* create a recursive buffer with all values, except the last one */
896 19728840 : do
897 : {
898 19728840 : sal_Char nDigit = (sal_Char)(nValue % nRadix);
899 19728840 : nValue /= nRadix;
900 19728840 : if ( nDigit > 9 )
901 8260804 : *pBuf = (nDigit-10) + 'a';
902 : else
903 11468036 : *pBuf = (nDigit + '0' );
904 19728840 : pBuf++;
905 : }
906 : while ( nValue > 0 );
907 :
908 : /* copy the values in the right direction into the destination buffer */
909 19728840 : do
910 : {
911 19728840 : pBuf--;
912 19728840 : *pStr = *pBuf;
913 19728840 : pStr++;
914 19728840 : nLen++;
915 : }
916 : while ( pBuf != aBuf );
917 9627750 : *pStr = 0;
918 :
919 9627750 : return nLen;
920 : }
921 :
922 : /* ----------------------------------------------------------------------- */
923 :
924 154540 : 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 154540 : sal_Char* pBuf = aBuf;
932 154540 : sal_Int32 nLen = 0;
933 : sal_uInt64 nValue;
934 :
935 : /* Radix must be valid */
936 154540 : if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
937 0 : nRadix = 10;
938 :
939 154540 : nValue = n;
940 :
941 : /* create a recursive buffer with all values, except the last one */
942 613938 : do
943 : {
944 613938 : sal_Char nDigit = (sal_Char)(nValue % nRadix);
945 613938 : nValue /= nRadix;
946 613938 : if ( nDigit > 9 )
947 109655 : *pBuf = (nDigit-10) + 'a';
948 : else
949 504283 : *pBuf = (nDigit + '0' );
950 613938 : pBuf++;
951 : }
952 : while ( nValue > 0 );
953 :
954 : /* copy the values in the right direction into the destination buffer */
955 613938 : do
956 : {
957 613938 : pBuf--;
958 613938 : *pStr = *pBuf;
959 613938 : pStr++;
960 613938 : nLen++;
961 : }
962 : while ( pBuf != aBuf );
963 154540 : *pStr = 0;
964 :
965 154540 : return nLen;
966 : }
967 :
968 : /* ----------------------------------------------------------------------- */
969 :
970 6151 : sal_Bool SAL_CALL IMPL_RTL_STRNAME( toBoolean )( const IMPL_RTL_STRCODE* pStr )
971 : SAL_THROW_EXTERN_C()
972 : {
973 : assert(pStr);
974 6151 : if ( *pStr == '1' )
975 2 : return sal_True;
976 :
977 6149 : if ( (*pStr == 'T') || (*pStr == 't') )
978 : {
979 4 : pStr++;
980 4 : if ( (*pStr == 'R') || (*pStr == 'r') )
981 : {
982 4 : pStr++;
983 4 : if ( (*pStr == 'U') || (*pStr == 'u') )
984 : {
985 4 : pStr++;
986 4 : if ( (*pStr == 'E') || (*pStr == 'e') )
987 4 : return sal_True;
988 : }
989 : }
990 : }
991 :
992 6145 : return sal_False;
993 : }
994 :
995 : /* ----------------------------------------------------------------------- */
996 : namespace {
997 2937516 : 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 2937516 : U n = 0;
1004 :
1005 2937516 : if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
1006 0 : nRadix = 10;
1007 :
1008 : /* Skip whitespaces */
1009 5875509 : while ( *pStr && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE( *pStr ) ) )
1010 477 : pStr++;
1011 :
1012 2937516 : if ( *pStr == '-' )
1013 : {
1014 41044 : bNeg = true;
1015 41044 : pStr++;
1016 : }
1017 : else
1018 : {
1019 2896472 : if ( *pStr == '+' )
1020 51 : pStr++;
1021 2896472 : bNeg = false;
1022 : }
1023 :
1024 : T nDiv;
1025 : sal_Int16 nMod;
1026 2937516 : if ( bNeg )
1027 : {
1028 41044 : nDiv = std::numeric_limits<T>::min() / nRadix;
1029 41044 : 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 41044 : if ( nMod > 0 )
1033 : {
1034 0 : --nDiv;
1035 0 : nMod -= nRadix;
1036 : }
1037 41044 : nDiv = -nDiv;
1038 41044 : nMod = -nMod;
1039 : }
1040 : else
1041 : {
1042 2896472 : nDiv = std::numeric_limits<T>::max() / nRadix;
1043 2896472 : nMod = std::numeric_limits<T>::max() % nRadix;
1044 : }
1045 :
1046 12269383 : while ( *pStr )
1047 : {
1048 6761908 : nDigit = rtl_ImplGetDigit( IMPL_RTL_USTRCODE( *pStr ), nRadix );
1049 6761908 : if ( nDigit < 0 )
1050 366477 : break;
1051 : assert(nDiv > 0);
1052 6395431 : if( static_cast<U>( nMod < nDigit ? nDiv-1 : nDiv ) < n )
1053 1080 : return 0;
1054 :
1055 6394351 : n *= nRadix;
1056 6394351 : n += nDigit;
1057 :
1058 6394351 : pStr++;
1059 : }
1060 :
1061 2936436 : if ( bNeg )
1062 41040 : return n == static_cast<U>(std::numeric_limits<T>::min())
1063 41040 : ? std::numeric_limits<T>::min() : -static_cast<T>(n);
1064 : else
1065 2895396 : return static_cast<T>(n);
1066 : }
1067 : }
1068 :
1069 2798187 : 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 2798187 : return IMPL_RTL_STRNAME( toInt )<sal_Int32, sal_uInt32>(pStr, nRadix);
1075 : }
1076 :
1077 139329 : 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 139329 : return IMPL_RTL_STRNAME( toInt )<sal_Int64, sal_uInt64>(pStr, nRadix);
1083 : }
1084 :
1085 : /* ----------------------------------------------------------------------- */
1086 : namespace {
1087 463809 : 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 463809 : T n = 0;
1093 :
1094 463809 : if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
1095 0 : nRadix = 10;
1096 :
1097 : /* Skip whitespaces */
1098 927618 : while ( *pStr && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE( *pStr ) ) )
1099 0 : ++pStr;
1100 :
1101 : // skip optional explicit sign
1102 463809 : if ( *pStr == '+' )
1103 0 : ++pStr;
1104 :
1105 463809 : T nDiv = std::numeric_limits<T>::max() / nRadix;
1106 463809 : sal_Int16 nMod = std::numeric_limits<T>::max() % nRadix;
1107 3455922 : while ( *pStr )
1108 : {
1109 2552171 : nDigit = rtl_ImplGetDigit( IMPL_RTL_USTRCODE( *pStr ), nRadix );
1110 2552171 : if ( nDigit < 0 )
1111 18683 : break;
1112 2533488 : if( ( nMod < nDigit ? nDiv-1 : nDiv ) < n )
1113 5184 : return 0;
1114 :
1115 2528304 : n *= nRadix;
1116 2528304 : n += nDigit;
1117 :
1118 2528304 : ++pStr;
1119 : }
1120 :
1121 458625 : return n;
1122 : }
1123 : }
1124 :
1125 449776 : 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 449776 : return IMPL_RTL_STRNAME( toUInt )<sal_uInt32>(pStr, nRadix);
1131 : }
1132 :
1133 14033 : 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 14033 : return IMPL_RTL_STRNAME( toUInt )<sal_uInt64>(pStr, nRadix);
1139 : }
1140 :
1141 : /* ======================================================================= */
1142 : /* Internal String-Class help functions */
1143 : /* ======================================================================= */
1144 :
1145 3220589063 : static IMPL_RTL_STRINGDATA* IMPL_RTL_STRINGNAME( ImplAlloc )( sal_Int32 nLen )
1146 : {
1147 : IMPL_RTL_STRINGDATA * pData
1148 3220589063 : = (sal::static_int_cast< sal_uInt32 >(nLen)
1149 3220588956 : <= ((SAL_MAX_UINT32 - sizeof (IMPL_RTL_STRINGDATA))
1150 3220588956 : / sizeof (IMPL_RTL_STRCODE)))
1151 : ? static_cast<IMPL_RTL_STRINGDATA *>(rtl_allocateMemory(
1152 3220588956 : sizeof (IMPL_RTL_STRINGDATA) + nLen * sizeof (IMPL_RTL_STRCODE)))
1153 6441177912 : : NULL;
1154 3220589279 : if (pData != NULL) {
1155 3220589287 : pData->refCount = 1;
1156 3220589287 : pData->length = nLen;
1157 3220589287 : pData->buffer[nLen] = 0;
1158 : }
1159 3220589279 : return pData;
1160 : }
1161 :
1162 : /* ----------------------------------------------------------------------- */
1163 :
1164 3017878 : 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 3017878 : IMPL_RTL_STRINGDATA* pData = IMPL_RTL_STRINGNAME( ImplAlloc )( pStr->length );
1172 : OSL_ASSERT(pData != NULL);
1173 :
1174 3017878 : pDest = pData->buffer;
1175 3017878 : pSrc = pStr->buffer;
1176 9035676 : while ( nCount > 0 )
1177 : {
1178 2999920 : *pDest = *pSrc;
1179 2999920 : pDest++;
1180 2999920 : pSrc++;
1181 2999920 : nCount--;
1182 : }
1183 :
1184 3017878 : *ppThis = pData;
1185 :
1186 : RTL_LOG_STRING_NEW( pData );
1187 3017878 : return pDest;
1188 : }
1189 :
1190 : /* ======================================================================= */
1191 : /* String-Class functions */
1192 : /* ======================================================================= */
1193 :
1194 : namespace {
1195 :
1196 31444719820 : void IMPL_RTL_ACQUIRE(IMPL_RTL_STRINGDATA * pThis)
1197 : {
1198 31444719820 : if (!SAL_STRING_IS_STATIC (pThis))
1199 23096449485 : osl_atomic_increment( &((pThis)->refCount) );
1200 31444719820 : }
1201 :
1202 : }
1203 :
1204 : /* ----------------------------------------------------------------------- */
1205 :
1206 15582605813 : void SAL_CALL IMPL_RTL_STRINGNAME( acquire )( IMPL_RTL_STRINGDATA* pThis )
1207 : SAL_THROW_EXTERN_C()
1208 : {
1209 15582605813 : IMPL_RTL_ACQUIRE( pThis );
1210 15582605430 : }
1211 :
1212 : /* ----------------------------------------------------------------------- */
1213 :
1214 44617223123 : void SAL_CALL IMPL_RTL_STRINGNAME( release )( IMPL_RTL_STRINGDATA* pThis )
1215 : SAL_THROW_EXTERN_C()
1216 : {
1217 44617223123 : if (SAL_STRING_IS_STATIC (pThis))
1218 18693917097 : return;
1219 :
1220 : /* OString doesn't have an 'intern' */
1221 : #if IMPL_RTL_IS_USTRING
1222 26035744731 : if (SAL_STRING_IS_INTERN (pThis))
1223 : {
1224 7183761 : internRelease (pThis);
1225 7183761 : return;
1226 : }
1227 : #endif
1228 :
1229 26308338158 : if ( !osl_atomic_decrement( &(pThis->refCount) ) )
1230 : {
1231 : RTL_LOG_STRING_DELETE( pThis );
1232 3218855788 : rtl_freeMemory( pThis );
1233 : }
1234 : }
1235 :
1236 : /* ----------------------------------------------------------------------- */
1237 :
1238 9955703417 : void SAL_CALL IMPL_RTL_STRINGNAME( new )( IMPL_RTL_STRINGDATA** ppThis )
1239 : SAL_THROW_EXTERN_C()
1240 : {
1241 : assert(ppThis);
1242 9955703417 : if ( *ppThis)
1243 26252832 : IMPL_RTL_STRINGNAME( release )( *ppThis );
1244 :
1245 9955703408 : *ppThis = const_cast<IMPL_RTL_STRINGDATA*>(&IMPL_RTL_EMPTYSTRING);
1246 9955703408 : }
1247 :
1248 : /* ----------------------------------------------------------------------- */
1249 :
1250 948605785 : IMPL_RTL_STRINGDATA* SAL_CALL IMPL_RTL_STRINGNAME( alloc )( sal_Int32 nLen )
1251 : SAL_THROW_EXTERN_C()
1252 : {
1253 948605785 : if ( nLen < 0 )
1254 0 : return NULL;
1255 : else
1256 948605785 : return IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1257 : }
1258 :
1259 : /* ----------------------------------------------------------------------- */
1260 :
1261 372596337 : 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 372596337 : if ( nLen <= 0 )
1266 432075 : IMPL_RTL_STRINGNAME( new )( ppThis );
1267 : else
1268 : {
1269 372164262 : if ( *ppThis)
1270 3277974 : IMPL_RTL_STRINGNAME( release )( *ppThis );
1271 :
1272 372164262 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1273 : OSL_ASSERT(*ppThis != NULL);
1274 372164266 : (*ppThis)->length = 0;
1275 :
1276 372164266 : IMPL_RTL_STRCODE* pTempStr = (*ppThis)->buffer;
1277 372164266 : memset(pTempStr, 0, nLen*sizeof(IMPL_RTL_STRCODE));
1278 : }
1279 372596341 : }
1280 :
1281 : /* ----------------------------------------------------------------------- */
1282 :
1283 41670 : 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 41670 : if ( !pStr->length )
1292 : {
1293 1 : IMPL_RTL_STRINGNAME( new )( ppThis );
1294 41671 : return;
1295 : }
1296 :
1297 41669 : pOrg = *ppThis;
1298 41669 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( pStr->length );
1299 : OSL_ASSERT(*ppThis != NULL);
1300 41669 : 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 41669 : if ( pOrg )
1305 0 : IMPL_RTL_STRINGNAME( release )( pOrg );
1306 : }
1307 :
1308 : /* ----------------------------------------------------------------------- */
1309 :
1310 514896251 : 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 514896251 : if ( pCharStr )
1320 : {
1321 514894307 : const IMPL_RTL_STRCODE* pTempStr = pCharStr;
1322 4162378699 : while( *pTempStr )
1323 3132590085 : pTempStr++;
1324 514894307 : nLen = pTempStr-pCharStr;
1325 : }
1326 : else
1327 1944 : nLen = 0;
1328 :
1329 514896251 : if ( !nLen )
1330 : {
1331 87287701 : IMPL_RTL_STRINGNAME( new )( ppThis );
1332 602183952 : return;
1333 : }
1334 :
1335 427608550 : pOrg = *ppThis;
1336 427608550 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1337 : OSL_ASSERT(*ppThis != NULL);
1338 427608550 : pBuffer = (*ppThis)->buffer;
1339 3132590069 : do
1340 : {
1341 3132590069 : *pBuffer = *pCharStr;
1342 3132590069 : pBuffer++;
1343 3132590069 : pCharStr++;
1344 : }
1345 : while ( *pCharStr );
1346 :
1347 : RTL_LOG_STRING_NEW( *ppThis );
1348 :
1349 : /* must be done last, if pCharStr == *ppThis */
1350 427608550 : if ( pOrg )
1351 94943 : IMPL_RTL_STRINGNAME( release )( pOrg );
1352 : }
1353 :
1354 : /* ----------------------------------------------------------------------- */
1355 :
1356 504846120 : 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 504846120 : if ( !pCharStr || (nLen <= 0) )
1365 : {
1366 723031 : IMPL_RTL_STRINGNAME( new )( ppThis );
1367 505569156 : return;
1368 : }
1369 :
1370 504123089 : pOrg = *ppThis;
1371 504123089 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1372 : OSL_ASSERT(*ppThis != NULL);
1373 504123092 : rtl_str_ImplCopy( (*ppThis)->buffer, pCharStr, nLen );
1374 :
1375 : RTL_LOG_STRING_NEW( *ppThis );
1376 :
1377 : /* must be done last, if pCharStr == *ppThis */
1378 504123092 : if ( pOrg )
1379 5611190 : IMPL_RTL_STRINGNAME( release )( pOrg );
1380 : }
1381 :
1382 : /* ----------------------------------------------------------------------- */
1383 :
1384 216918869 : 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 216918869 : if ( beginIndex == 0 && count == pFrom->length )
1392 : {
1393 27762287 : IMPL_RTL_STRINGNAME( assign )( ppThis, const_cast< IMPL_RTL_STRINGDATA * >( pFrom ) );
1394 27762289 : return;
1395 : }
1396 189156582 : if ( count < 0 || beginIndex < 0 || beginIndex + count > pFrom->length )
1397 : {
1398 : assert(false); // fail fast at least in debug builds
1399 0 : IMPL_RTL_STRINGNAME( newFromLiteral )( ppThis, "!!br0ken!!", 10, 0 );
1400 0 : return;
1401 : }
1402 :
1403 189156592 : IMPL_RTL_STRINGNAME( newFromStr_WithLength )( ppThis, pFrom->buffer + beginIndex, count );
1404 : }
1405 :
1406 : /* ----------------------------------------------------------------------- */
1407 :
1408 : // Used when creating from string literals.
1409 732847137 : 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 732847137 : if ( nLen + allocExtra == 0 )
1419 : {
1420 0 : IMPL_RTL_STRINGNAME( new )( ppThis );
1421 732847150 : return;
1422 : }
1423 :
1424 732847137 : if ( *ppThis )
1425 32458852 : IMPL_RTL_STRINGNAME( release )( *ppThis );
1426 :
1427 732847137 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen + allocExtra );
1428 : assert( *ppThis != NULL );
1429 :
1430 732847150 : (*ppThis)->length = nLen; // fix after possible allocExtra != 0
1431 732847150 : (*ppThis)->buffer[nLen] = 0;
1432 732847150 : IMPL_RTL_STRCODE* pBuffer = (*ppThis)->buffer;
1433 : sal_Int32 nCount;
1434 18515952373 : 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 17783105223 : *pBuffer = *pCharStr;
1443 17783105223 : pBuffer++;
1444 17783105223 : pCharStr++;
1445 : }
1446 :
1447 : RTL_LOG_STRING_NEW( *ppThis );
1448 : }
1449 :
1450 : /* ----------------------------------------------------------------------- */
1451 :
1452 15767115832 : 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 15767115832 : IMPL_RTL_ACQUIRE( pStr );
1459 :
1460 15767115564 : if ( *ppThis )
1461 15566907925 : IMPL_RTL_STRINGNAME( release )( *ppThis );
1462 :
1463 15767115021 : *ppThis = pStr;
1464 15767115021 : }
1465 :
1466 : /* ----------------------------------------------------------------------- */
1467 :
1468 187738 : sal_Int32 SAL_CALL IMPL_RTL_STRINGNAME( getLength )( const IMPL_RTL_STRINGDATA* pThis )
1469 : SAL_THROW_EXTERN_C()
1470 : {
1471 : assert(pThis);
1472 187738 : return pThis->length;
1473 : }
1474 :
1475 : /* ----------------------------------------------------------------------- */
1476 :
1477 362729 : IMPL_RTL_STRCODE* SAL_CALL IMPL_RTL_STRINGNAME( getStr )( IMPL_RTL_STRINGDATA * pThis )
1478 : SAL_THROW_EXTERN_C()
1479 : {
1480 : assert(pThis);
1481 362729 : return pThis->buffer;
1482 : }
1483 :
1484 : /* ----------------------------------------------------------------------- */
1485 :
1486 14201617 : 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 14201617 : IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1493 :
1494 : /* Test for 0-Pointer - if not, change newReplaceStrAt! */
1495 14201617 : if ( !pRight || !pRight->length )
1496 : {
1497 783070 : *ppThis = pLeft;
1498 783070 : IMPL_RTL_ACQUIRE( pLeft );
1499 : }
1500 13418547 : else if ( !pLeft || !pLeft->length )
1501 : {
1502 4270670 : *ppThis = pRight;
1503 4270670 : IMPL_RTL_ACQUIRE( pRight );
1504 : }
1505 : else
1506 : {
1507 9147877 : IMPL_RTL_STRINGDATA* pTempStr = IMPL_RTL_STRINGNAME( ImplAlloc )( pLeft->length + pRight->length );
1508 : OSL_ASSERT(pTempStr != NULL);
1509 9147877 : rtl_str_ImplCopy( pTempStr->buffer, pLeft->buffer, pLeft->length );
1510 9147877 : rtl_str_ImplCopy( pTempStr->buffer+pLeft->length, pRight->buffer, pRight->length );
1511 9147877 : *ppThis = pTempStr;
1512 :
1513 : RTL_LOG_STRING_NEW( *ppThis );
1514 : }
1515 :
1516 : /* must be done last, if left or right == *ppThis */
1517 14201617 : if ( pOrg )
1518 12102647 : IMPL_RTL_STRINGNAME( release )( pOrg );
1519 14201617 : }
1520 :
1521 : /* ----------------------------------------------------------------------- */
1522 :
1523 83887 : 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 83887 : IMPL_RTL_STRINGDATA* const pOrg = *ppThis;
1529 83887 : if ( pOrg->refCount == 1 && pOrg->length >= size )
1530 83889 : return;
1531 : assert( pOrg->length <= size ); // do not truncate
1532 83885 : IMPL_RTL_STRINGDATA* pTempStr = IMPL_RTL_STRINGNAME( ImplAlloc )( size );
1533 83885 : rtl_str_ImplCopy( pTempStr->buffer, pOrg->buffer, pOrg->length );
1534 : // right now the length is still the same as of the original
1535 83885 : pTempStr->length = pOrg->length;
1536 83885 : pTempStr->buffer[ pOrg->length ] = '\0';
1537 83885 : *ppThis = pTempStr;
1538 : RTL_LOG_STRING_NEW( *ppThis );
1539 :
1540 83885 : IMPL_RTL_STRINGNAME( release )( pOrg );
1541 : }
1542 :
1543 : /* ----------------------------------------------------------------------- */
1544 :
1545 2392510 : 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 2392510 : if ( nIndex >= pStr->length )
1556 : {
1557 : /* newConcat test, if pNewSubStr is 0 */
1558 2097475 : IMPL_RTL_STRINGNAME( newConcat )( ppThis, pStr, pNewSubStr );
1559 2097475 : return;
1560 : }
1561 :
1562 : /* negativ index? */
1563 295035 : if ( nIndex < 0 )
1564 : {
1565 0 : nCount -= nIndex;
1566 0 : nIndex = 0;
1567 : }
1568 :
1569 : /* not more than the String length could be deleted */
1570 295035 : if ( nCount >= pStr->length-nIndex )
1571 : {
1572 181628 : nCount = pStr->length-nIndex;
1573 :
1574 : /* Assign of NewSubStr? */
1575 181628 : if ( !nIndex && (nCount >= pStr->length) )
1576 : {
1577 85253 : if ( !pNewSubStr )
1578 0 : IMPL_RTL_STRINGNAME( new )( ppThis );
1579 : else
1580 85253 : IMPL_RTL_STRINGNAME( assign )( ppThis, pNewSubStr );
1581 85253 : return;
1582 : }
1583 : }
1584 :
1585 : /* Assign of Str? */
1586 209782 : if ( !nCount && (!pNewSubStr || !pNewSubStr->length) )
1587 : {
1588 588 : IMPL_RTL_STRINGNAME( assign )( ppThis, pStr );
1589 588 : return;
1590 : }
1591 :
1592 209194 : IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1593 : IMPL_RTL_STRCODE* pBuffer;
1594 : sal_Int32 nNewLen;
1595 :
1596 : /* Calculate length of the new string */
1597 209194 : nNewLen = pStr->length-nCount;
1598 209194 : if ( pNewSubStr )
1599 209194 : nNewLen += pNewSubStr->length;
1600 :
1601 : /* Alloc New Buffer */
1602 209194 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nNewLen );
1603 : OSL_ASSERT(*ppThis != NULL);
1604 209194 : pBuffer = (*ppThis)->buffer;
1605 209194 : if ( nIndex )
1606 : {
1607 117518 : rtl_str_ImplCopy( pBuffer, pStr->buffer, nIndex );
1608 117518 : pBuffer += nIndex;
1609 : }
1610 209194 : if ( pNewSubStr && pNewSubStr->length )
1611 : {
1612 162855 : rtl_str_ImplCopy( pBuffer, pNewSubStr->buffer, pNewSubStr->length );
1613 162855 : pBuffer += pNewSubStr->length;
1614 : }
1615 209194 : 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 209194 : if ( pOrg )
1620 0 : IMPL_RTL_STRINGNAME( release )( pOrg );
1621 : }
1622 :
1623 : /* ----------------------------------------------------------------------- */
1624 :
1625 85932719 : 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 85932719 : IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1634 85932719 : int bChanged = 0;
1635 85932719 : sal_Int32 nLen = pStr->length;
1636 85932719 : const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1637 :
1638 914271240 : while ( nLen > 0 )
1639 : {
1640 742668309 : if ( *pCharStr == cOld )
1641 : {
1642 : /* Copy String */
1643 262507 : IMPL_RTL_STRCODE* pNewCharStr = IMPL_RTL_STRINGNAME( ImplNewCopy )( ppThis, pStr, pCharStr-pStr->buffer );
1644 :
1645 : /* replace/copy rest of the string */
1646 262507 : if ( pNewCharStr )
1647 : {
1648 262507 : *pNewCharStr = cNew;
1649 262507 : pNewCharStr++;
1650 262507 : pCharStr++;
1651 262507 : nLen--;
1652 :
1653 4486039 : while ( nLen > 0 )
1654 : {
1655 3961025 : if ( *pCharStr == cOld )
1656 295902 : *pNewCharStr = cNew;
1657 : else
1658 3665123 : *pNewCharStr = *pCharStr;
1659 :
1660 3961025 : pNewCharStr++;
1661 3961025 : pCharStr++;
1662 3961025 : nLen--;
1663 : }
1664 : }
1665 :
1666 262507 : bChanged = 1;
1667 262507 : break;
1668 : }
1669 :
1670 742405802 : pCharStr++;
1671 742405802 : nLen--;
1672 : }
1673 :
1674 85932719 : if ( !bChanged )
1675 : {
1676 85670212 : *ppThis = pStr;
1677 85670212 : IMPL_RTL_ACQUIRE( pStr );
1678 : }
1679 :
1680 : RTL_LOG_STRING_NEW( *ppThis );
1681 : /* must be done last, if pStr == *ppThis */
1682 85932719 : if ( pOrg )
1683 0 : IMPL_RTL_STRINGNAME( release )( pOrg );
1684 85932719 : }
1685 :
1686 : /* ----------------------------------------------------------------------- */
1687 :
1688 5187353 : 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 5187353 : IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1695 5187353 : int bChanged = 0;
1696 5187353 : sal_Int32 nLen = pStr->length;
1697 5187353 : const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1698 :
1699 21654746 : while ( nLen > 0 )
1700 : {
1701 13924762 : if ( rtl::isAsciiUpperCase(IMPL_RTL_USTRCODE(*pCharStr)) )
1702 : {
1703 : /* Copy String */
1704 2644722 : IMPL_RTL_STRCODE* pNewCharStr = IMPL_RTL_STRINGNAME( ImplNewCopy )( ppThis, pStr, pCharStr-pStr->buffer );
1705 :
1706 : /* replace/copy rest of the string */
1707 2644722 : if ( pNewCharStr )
1708 : {
1709 2644722 : *pNewCharStr = rtl::toAsciiLowerCase(IMPL_RTL_USTRCODE(*pCharStr));
1710 2644722 : pNewCharStr++;
1711 2644722 : pCharStr++;
1712 2644722 : nLen--;
1713 :
1714 34413827 : while ( nLen > 0 )
1715 : {
1716 29124383 : *pNewCharStr = rtl::toAsciiLowerCase(IMPL_RTL_USTRCODE(*pCharStr));
1717 :
1718 29124383 : pNewCharStr++;
1719 29124383 : pCharStr++;
1720 29124383 : nLen--;
1721 : }
1722 : }
1723 :
1724 2644722 : bChanged = 1;
1725 2644722 : break;
1726 : }
1727 :
1728 11280040 : pCharStr++;
1729 11280040 : nLen--;
1730 : }
1731 :
1732 5187353 : if ( !bChanged )
1733 : {
1734 2542631 : *ppThis = pStr;
1735 2542631 : IMPL_RTL_ACQUIRE( pStr );
1736 : }
1737 :
1738 : RTL_LOG_STRING_NEW( *ppThis );
1739 : /* must be done last, if pStr == *ppThis */
1740 5187353 : if ( pOrg )
1741 0 : IMPL_RTL_STRINGNAME( release )( pOrg );
1742 5187353 : }
1743 :
1744 : /* ----------------------------------------------------------------------- */
1745 :
1746 1646568 : 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 1646568 : IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1753 1646568 : int bChanged = 0;
1754 1646568 : sal_Int32 nLen = pStr->length;
1755 1646568 : const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1756 :
1757 6910727 : while ( nLen > 0 )
1758 : {
1759 3728240 : if ( rtl::isAsciiLowerCase(IMPL_RTL_USTRCODE(*pCharStr)) )
1760 : {
1761 : /* Copy String */
1762 110649 : IMPL_RTL_STRCODE* pNewCharStr = IMPL_RTL_STRINGNAME( ImplNewCopy )( ppThis, pStr, pCharStr-pStr->buffer );
1763 :
1764 : /* replace/copy rest of the string */
1765 110649 : if ( pNewCharStr )
1766 : {
1767 110649 : *pNewCharStr = rtl::toAsciiUpperCase(IMPL_RTL_USTRCODE(*pCharStr));
1768 110649 : pNewCharStr++;
1769 110649 : pCharStr++;
1770 110649 : nLen--;
1771 :
1772 1759209 : while ( nLen > 0 )
1773 : {
1774 1537911 : *pNewCharStr = rtl::toAsciiUpperCase(IMPL_RTL_USTRCODE(*pCharStr));
1775 :
1776 1537911 : pNewCharStr++;
1777 1537911 : pCharStr++;
1778 1537911 : nLen--;
1779 : }
1780 : }
1781 :
1782 110649 : bChanged = 1;
1783 110649 : break;
1784 : }
1785 :
1786 3617591 : pCharStr++;
1787 3617591 : nLen--;
1788 : }
1789 :
1790 1646568 : if ( !bChanged )
1791 : {
1792 1535919 : *ppThis = pStr;
1793 1535919 : IMPL_RTL_ACQUIRE( pStr );
1794 : }
1795 :
1796 : RTL_LOG_STRING_NEW( *ppThis );
1797 : /* must be done last, if pStr == *ppThis */
1798 1646568 : if ( pOrg )
1799 0 : IMPL_RTL_STRINGNAME( release )( pOrg );
1800 1646568 : }
1801 :
1802 : /* ----------------------------------------------------------------------- */
1803 :
1804 278677 : 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 278677 : IMPL_RTL_STRINGDATA* pOrg = *ppThis;
1811 278677 : const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1812 278677 : sal_Int32 nPreSpaces = 0;
1813 278677 : sal_Int32 nPostSpaces = 0;
1814 278677 : sal_Int32 nLen = pStr->length;
1815 278677 : sal_Int32 nIndex = nLen-1;
1816 :
1817 1160723 : while ( (nPreSpaces < nLen) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pCharStr+nPreSpaces)) ) )
1818 603369 : nPreSpaces++;
1819 :
1820 652051 : while ( (nIndex > nPreSpaces) && rtl_ImplIsWhitespace( IMPL_RTL_USTRCODE(*(pCharStr+nIndex)) ) )
1821 : {
1822 94697 : nPostSpaces++;
1823 94697 : nIndex--;
1824 : }
1825 :
1826 278677 : if ( !nPreSpaces && !nPostSpaces )
1827 : {
1828 204100 : *ppThis = pStr;
1829 204100 : IMPL_RTL_ACQUIRE( pStr );
1830 : }
1831 : else
1832 : {
1833 74577 : nLen -= nPostSpaces+nPreSpaces;
1834 74577 : *ppThis = IMPL_RTL_STRINGNAME( ImplAlloc )( nLen );
1835 : assert(*ppThis);
1836 74577 : 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 278677 : if ( pOrg )
1842 0 : IMPL_RTL_STRINGNAME( release )( pOrg );
1843 278677 : }
1844 :
1845 : /* ----------------------------------------------------------------------- */
1846 :
1847 15017465 : 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 15017465 : const IMPL_RTL_STRCODE* pCharStr = pStr->buffer;
1857 : const IMPL_RTL_STRCODE* pCharStrStart;
1858 : const IMPL_RTL_STRCODE* pOrgCharStr;
1859 15017465 : sal_Int32 nLen = pStr->length-nIndex;
1860 15017465 : sal_Int32 nTokCount = 0;
1861 :
1862 : // Set ppThis to an empty string and return -1 if either nToken or nIndex is
1863 : // negative:
1864 15017465 : if (nIndex < 0)
1865 1412 : nToken = -1;
1866 :
1867 15017465 : pCharStr += nIndex;
1868 15017465 : pOrgCharStr = pCharStr;
1869 15017465 : pCharStrStart = pCharStr;
1870 85077800 : while ( nLen > 0 )
1871 : {
1872 62396338 : if ( *pCharStr == cTok )
1873 : {
1874 7480276 : nTokCount++;
1875 :
1876 7480276 : if ( nTokCount == nToken )
1877 64255 : pCharStrStart = pCharStr+1;
1878 : else
1879 : {
1880 7416021 : if ( nTokCount > nToken )
1881 7353468 : break;
1882 : }
1883 : }
1884 :
1885 55042870 : pCharStr++;
1886 55042870 : nLen--;
1887 : }
1888 :
1889 15017465 : if ( (nToken < 0) || (nTokCount < nToken) || (pCharStr == pCharStrStart) )
1890 : {
1891 7819823 : IMPL_RTL_STRINGNAME( new )( ppThis );
1892 7819844 : if( (nToken < 0) || (nTokCount < nToken ) )
1893 2569 : return -1;
1894 7817275 : else if( nLen > 0 )
1895 4847517 : return nIndex+(pCharStr-pOrgCharStr)+1;
1896 2969758 : else return -1;
1897 : }
1898 : else
1899 : {
1900 7197642 : IMPL_RTL_STRINGNAME( newFromStr_WithLength )( ppThis, pCharStrStart, pCharStr-pCharStrStart );
1901 7197642 : if ( nLen )
1902 2505590 : return nIndex+(pCharStr-pOrgCharStr)+1;
1903 : else
1904 4692052 : return -1;
1905 : }
1906 : }
1907 :
1908 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
