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