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