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