?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Bump version to 24.04.3.4
[LibreOffice.git] / sal / rtl / string.cxx
blob95f51ad288d0948941c6106546d50a0fb4d10e14
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 #include <sal/config.h>
21
22 #include <cassert>
23 #include <cstdlib>
24
25 #include <osl/diagnose.h>
26 #include <rtl/tencinfo.h>
27
28 #include "strimp.hxx"
29 #include <rtl/character.hxx>
30 #include <rtl/string.h>
31
32 #include <rtl/math.h>
33
34 #if defined _WIN32
35 // Temporary check to verify that the #pragma pack around rtl_String is indeed cargo cult and can
36 // safely be removed:
37 static_assert(alignof (rtl_String) == 4);
38 static_assert(sizeof (rtl_String) == 12);
39 #endif
40
41 /* ======================================================================= */
42
43 #if USE_SDT_PROBES
44 #define RTL_LOG_STRING_BITS 8
45 #endif
46
47 #include "strtmpl.hxx"
48
49 /* ======================================================================= */
50
51 sal_Int32 SAL_CALL rtl_str_valueOfFloat(char * pStr, float f)
52 SAL_THROW_EXTERN_C()
53 {
54 return rtl::str::valueOfFP<RTL_STR_MAX_VALUEOFFLOAT>(pStr, f);
55 }
56
57 sal_Int32 SAL_CALL rtl_str_valueOfDouble(char * pStr, double d)
58 SAL_THROW_EXTERN_C()
59 {
60 return rtl::str::valueOfFP<RTL_STR_MAX_VALUEOFDOUBLE>(pStr, d);
61 }
62
63 float SAL_CALL rtl_str_toFloat(char const * pStr) SAL_THROW_EXTERN_C()
64 {
65 assert(pStr);
66 return static_cast<float>(rtl_math_stringToDouble(pStr, pStr + rtl_str_getLength(pStr),
67 '.', 0, nullptr, nullptr));
68 }
69
70 double SAL_CALL rtl_str_toDouble(char const * pStr) SAL_THROW_EXTERN_C()
71 {
72 assert(pStr);
73 return rtl_math_stringToDouble(pStr, pStr + rtl_str_getLength(pStr), '.', 0,
74 nullptr, nullptr);
75 }
76
77 /* ======================================================================= */
78
79 static int rtl_ImplGetFastUTF8ByteLen( const sal_Unicode* pStr, sal_Int32 nLen )
80 {
81 int n;
82 sal_Unicode c;
83 sal_uInt32 nUCS4Char;
84 const sal_Unicode* pEndStr;
85
86 n = 0;
87 pEndStr = pStr+nLen;
88 while ( pStr < pEndStr )
89 {
90 c = *pStr;
91
92 if ( c < 0x80 )
93 n++;
94 else if ( c < 0x800 )
95 n += 2;
96 else
97 {
98 if ( !rtl::isHighSurrogate(c) )
99 n += 3;
100 else
101 {
102 nUCS4Char = c;
103
104 if ( pStr+1 < pEndStr )
105 {
106 c = *(pStr+1);
107 if ( rtl::isLowSurrogate(c) )
108 {
109 nUCS4Char = rtl::combineSurrogates(nUCS4Char, c);
110 pStr++;
111 }
112 }
113
114 if ( nUCS4Char < 0x10000 )
115 n += 3;
116 else if ( nUCS4Char < 0x200000 )
117 n += 4;
118 else if ( nUCS4Char < 0x4000000 )
119 n += 5;
120 else
121 n += 6;
122 }
123 }
124
125 pStr++;
126 }
127
128 return n;
129 }
130
131 /* ----------------------------------------------------------------------- */
132
133 static bool rtl_impl_convertUStringToString(rtl_String ** pTarget,
134 sal_Unicode const * pSource,
135 sal_Int32 nLength,
136 rtl_TextEncoding nEncoding,
137 sal_uInt32 nFlags,
138 bool bCheckErrors)
139 {
140 assert(pTarget != nullptr);
141 assert(pSource != nullptr || nLength == 0);
142 assert(nLength >= 0);
143 OSL_ASSERT(nLength == 0 || rtl_isOctetTextEncoding(nEncoding));
144
145 if ( !nLength )
146 rtl_string_new( pTarget );
147 else
148 {
149 rtl_String* pTemp;
150 rtl_UnicodeToTextConverter hConverter;
151 sal_uInt32 nInfo;
152 sal_Size nSrcChars;
153 sal_Size nDestBytes;
154 sal_Size nNewLen;
155 sal_Size nNotConvertedChars;
156 sal_Size nMaxCharLen;
157
158 /* Optimization for UTF-8 - we try to calculate the exact length */
159 /* For all other encoding we try a good estimation */
160 if ( nEncoding == RTL_TEXTENCODING_UTF8 )
161 {
162 nNewLen = rtl_ImplGetFastUTF8ByteLen( pSource, nLength );
163 /* Includes the string only ASCII, then we could copy
164 the buffer faster */
165 if ( nNewLen == static_cast<sal_Size>(nLength) )
166 {
167 char* pBuffer;
168 if ( *pTarget )
169 rtl_string_release( *pTarget );
170 *pTarget = rtl_string_ImplAlloc( nLength );
171 OSL_ASSERT(*pTarget != nullptr);
172 pBuffer = (*pTarget)->buffer;
173 do
174 {
175 /* Check ASCII range */
176 OSL_ENSURE( *pSource <= 127,
177 "rtl_uString2String() - UTF8 test is encoding is wrong" );
178
179 *pBuffer = static_cast<char>(static_cast<unsigned char>(*pSource));
180 pBuffer++;
181 pSource++;
182 nLength--;
183 }
184 while ( nLength );
185 return true;
186 }
187
188 nMaxCharLen = 4;
189 }
190 else
191 {
192 rtl_TextEncodingInfo aTextEncInfo;
193 aTextEncInfo.StructSize = sizeof( aTextEncInfo );
194 if ( !rtl_getTextEncodingInfo( nEncoding, &aTextEncInfo ) )
195 {
196 aTextEncInfo.AverageCharSize = 1;
197 aTextEncInfo.MaximumCharSize = 8;
198 }
199
200 nNewLen = nLength * static_cast<sal_Size>(aTextEncInfo.AverageCharSize);
201 nMaxCharLen = aTextEncInfo.MaximumCharSize;
202 }
203
204 nFlags |= RTL_UNICODETOTEXT_FLAGS_FLUSH;
205 hConverter = rtl_createUnicodeToTextConverter( nEncoding );
206
207 for (;;)
208 {
209 pTemp = rtl_string_ImplAlloc( nNewLen );
210 OSL_ASSERT(pTemp != nullptr);
211 nDestBytes = rtl_convertUnicodeToText( hConverter, nullptr,
212 pSource, nLength,
213 pTemp->buffer, nNewLen,
214 nFlags,
215 &nInfo, &nSrcChars );
216 if (bCheckErrors && (nInfo & RTL_UNICODETOTEXT_INFO_ERROR) != 0)
217 {
218 rtl_freeString(pTemp);
219 rtl_destroyUnicodeToTextConverter(hConverter);
220 return false;
221 }
222
223 if ((nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL) == 0)
224 break;
225
226 /* Buffer not big enough, try again with enough space */
227 rtl_freeString( pTemp );
228
229 /* Try with the max. count of characters with
230 additional overhead for replacing functionality */
231 nNotConvertedChars = nLength-nSrcChars;
232 nNewLen = nDestBytes+(nNotConvertedChars*nMaxCharLen)+nNotConvertedChars+4;
233 }
234
235 /* Set the buffer to the correct size or is there to
236 much overhead, reallocate to the correct size */
237 if ( nNewLen > nDestBytes+8 )
238 {
239 rtl_String* pTemp2 = rtl_string_ImplAlloc( nDestBytes );
240 OSL_ASSERT(pTemp2 != nullptr);
241 rtl::str::Copy(pTemp2->buffer, pTemp->buffer, nDestBytes);
242 rtl_freeString( pTemp );
243 pTemp = pTemp2;
244 }
245 else
246 {
247 pTemp->length = nDestBytes;
248 pTemp->buffer[nDestBytes] = 0;
249 }
250
251 rtl_destroyUnicodeToTextConverter( hConverter );
252 if ( *pTarget )
253 rtl_string_release( *pTarget );
254 *pTarget = pTemp;
255
256 /* Results the conversion in an empty buffer -
257 create an empty string */
258 if ( pTemp && !nDestBytes )
259 rtl_string_new( pTarget );
260 }
261 return true;
262 }
263
264 void SAL_CALL rtl_uString2String( rtl_String** ppThis,
265 const sal_Unicode* pUStr,
266 sal_Int32 nULen,
267 rtl_TextEncoding eTextEncoding,
268 sal_uInt32 nCvtFlags )
269 SAL_THROW_EXTERN_C()
270 {
271 rtl_impl_convertUStringToString(ppThis, pUStr, nULen, eTextEncoding,
272 nCvtFlags, false);
273 }
274
275 sal_Bool SAL_CALL rtl_convertUStringToString(rtl_String ** pTarget,
276 sal_Unicode const * pSource,
277 sal_Int32 nLength,
278 rtl_TextEncoding nEncoding,
279 sal_uInt32 nFlags)
280 SAL_THROW_EXTERN_C()
281 {
282 return rtl_impl_convertUStringToString(pTarget, pSource, nLength, nEncoding,
283 nFlags, true);
284 }
285
286 void rtl_string_newReplaceFirst(
287 rtl_String ** newStr, rtl_String * str, char const * from,
288 sal_Int32 fromLength, char const * to, sal_Int32 toLength,
289 sal_Int32 * index) SAL_THROW_EXTERN_C()
290 {
291 assert(str != nullptr);
292 assert(index != nullptr);
293 assert(*index >= 0 && *index <= str->length);
294 assert(fromLength >= 0);
295 assert(toLength >= 0);
296 sal_Int32 i = rtl_str_indexOfStr_WithLength(
297 str->buffer + *index, str->length - *index, from, fromLength);
298 if (i == -1) {
299 rtl_string_assign(newStr, str);
300 } else {
301 assert(i <= str->length - *index);
302 i += *index;
303 assert(fromLength <= str->length);
304 if (str->length - fromLength > SAL_MAX_INT32 - toLength) {
305 std::abort();
306 }
307 rtl::str::newReplaceStrAt(newStr, str, i, fromLength, to, toLength);
308 }
309 *index = i;
310 }
311
312 void rtl_string_newReplaceAll(
313 rtl_String ** newStr, rtl_String * str, char const * from,
314 sal_Int32 fromLength, char const * to, sal_Int32 toLength)
315 SAL_THROW_EXTERN_C()
316 {
317 rtl::str::newReplaceAllFromIndex(newStr, str, from, fromLength, to, toLength, 0);
318 }
319
320 sal_Int32 SAL_CALL rtl_str_getLength(const char* pStr) SAL_THROW_EXTERN_C()
321 {
322 return rtl::str::getLength(pStr);
323 }
324
325 sal_Int32 SAL_CALL rtl_str_compare(const char* pStr1, const char* pStr2) SAL_THROW_EXTERN_C()
326 {
327 return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
328 rtl::str::CompareNormal(), rtl::str::noShortening);
329 }
330
331 sal_Int32 SAL_CALL rtl_str_compare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
332 const char* pStr2, sal_Int32 nStr2Len)
333 SAL_THROW_EXTERN_C()
334 {
335 return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
336 rtl::str::with_length(pStr2, nStr2Len),
337 rtl::str::CompareNormal(), rtl::str::noShortening);
338 }
339
340 sal_Int32 SAL_CALL rtl_str_shortenedCompare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
341 const char* pStr2, sal_Int32 nStr2Len,
342 sal_Int32 nShortenedLength)
343 SAL_THROW_EXTERN_C()
344 {
345 return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
346 rtl::str::with_length(pStr2, nStr2Len),
347 rtl::str::CompareNormal(), nShortenedLength);
348 }
349
350 sal_Int32 SAL_CALL rtl_str_reverseCompare_WithLength(const char* pStr1, sal_Int32 nStr1Len,
351 const char* pStr2, sal_Int32 nStr2Len)
352 SAL_THROW_EXTERN_C()
353 {
354 return rtl::str::reverseCompare_WithLengths(pStr1, nStr1Len, pStr2, nStr2Len,
355 rtl::str::CompareNormal());
356 }
357
358 sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase(const char* pStr1, const char* pStr2)
359 SAL_THROW_EXTERN_C()
360 {
361 return rtl::str::compare(rtl::str::null_terminated(pStr1), rtl::str::null_terminated(pStr2),
362 rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
363 }
364
365 sal_Int32 SAL_CALL rtl_str_compareIgnoreAsciiCase_WithLength(const char* pStr1, sal_Int32 nStr1Len,
366 const char* pStr2, sal_Int32 nStr2Len)
367 SAL_THROW_EXTERN_C()
368 {
369 return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
370 rtl::str::with_length(pStr2, nStr2Len),
371 rtl::str::CompareIgnoreAsciiCase(), rtl::str::noShortening);
372 }
373
374 sal_Int32 SAL_CALL rtl_str_shortenedCompareIgnoreAsciiCase_WithLength(
375 const char* pStr1, sal_Int32 nStr1Len, const char* pStr2, sal_Int32 nStr2Len,
376 sal_Int32 nShortenedLength) SAL_THROW_EXTERN_C()
377 {
378 return rtl::str::compare(rtl::str::with_length(pStr1, nStr1Len),
379 rtl::str::with_length(pStr2, nStr2Len),
380 rtl::str::CompareIgnoreAsciiCase(), nShortenedLength);
381 }
382
383 sal_Int32 SAL_CALL rtl_str_hashCode(const char* pStr) SAL_THROW_EXTERN_C()
384 {
385 return rtl::str::hashCode(pStr);
386 }
387
388 sal_Int32 SAL_CALL rtl_str_hashCode_WithLength(const char* pStr, sal_Int32 nLen)
389 SAL_THROW_EXTERN_C()
390 {
391 return rtl::str::hashCode_WithLength(pStr, nLen);
392 }
393
394 sal_Int32 SAL_CALL rtl_str_indexOfChar(const char* pStr, char c) SAL_THROW_EXTERN_C()
395 {
396 return rtl::str::indexOfChar(pStr, c);
397 }
398
399 sal_Int32 SAL_CALL rtl_str_indexOfChar_WithLength(const char* pStr, sal_Int32 nLen, char c)
400 SAL_THROW_EXTERN_C()
401 {
402 return rtl::str::indexOfChar_WithLength(pStr, nLen, c);
403 }
404
405 sal_Int32 SAL_CALL rtl_str_lastIndexOfChar(const char* pStr, char c) SAL_THROW_EXTERN_C()
406 {
407 return rtl::str::lastIndexOfChar(pStr, c);
408 }
409
410 sal_Int32 SAL_CALL rtl_str_lastIndexOfChar_WithLength(const char* pStr, sal_Int32 nLen, char c)
411 SAL_THROW_EXTERN_C()
412 {
413 return rtl::str::lastIndexOfChar_WithLength(pStr, nLen, c);
414 }
415
416 sal_Int32 SAL_CALL rtl_str_indexOfStr(const char* pStr, const char* pSubStr) SAL_THROW_EXTERN_C()
417 {
418 return rtl::str::indexOfStr(pStr, pSubStr);
419 }
420
421 sal_Int32 SAL_CALL rtl_str_indexOfStr_WithLength(const char* pStr, sal_Int32 nStrLen,
422 const char* pSubStr, sal_Int32 nSubLen)
423 SAL_THROW_EXTERN_C()
424 {
425 return rtl::str::indexOfStr_WithLength(pStr, nStrLen, pSubStr, nSubLen);
426 }
427
428 sal_Int32 SAL_CALL rtl_str_lastIndexOfStr(const char* pStr, const char* pSubStr)
429 SAL_THROW_EXTERN_C()
430 {
431 return rtl::str::lastIndexOfStr(pStr, pSubStr);
432 }
433
434 sal_Int32 SAL_CALL rtl_str_lastIndexOfStr_WithLength(const char* pStr, sal_Int32 nStrLen,
435 const char* pSubStr, sal_Int32 nSubLen)
436 SAL_THROW_EXTERN_C()
437 {
438 return rtl::str::lastIndexOfStr_WithLength(pStr, nStrLen, pSubStr, nSubLen);
439 }
440
441 void SAL_CALL rtl_str_replaceChar(char* pStr, char cOld, char cNew) SAL_THROW_EXTERN_C()
442 {
443 return rtl::str::replaceChars(rtl::str::null_terminated(pStr), rtl::str::FromTo(cOld, cNew));
444 }
445
446 void SAL_CALL rtl_str_replaceChar_WithLength(char* pStr, sal_Int32 nLen, char cOld, char cNew)
447 SAL_THROW_EXTERN_C()
448 {
449 return rtl::str::replaceChars(rtl::str::with_length(pStr, nLen), rtl::str::FromTo(cOld, cNew));
450 }
451
452 void SAL_CALL rtl_str_toAsciiLowerCase(char* pStr) SAL_THROW_EXTERN_C()
453 {
454 return rtl::str::replaceChars(rtl::str::null_terminated(pStr), rtl::str::toAsciiLower);
455 }
456
457 void SAL_CALL rtl_str_toAsciiLowerCase_WithLength(char* pStr, sal_Int32 nLen) SAL_THROW_EXTERN_C()
458 {
459 return rtl::str::replaceChars(rtl::str::with_length(pStr, nLen), rtl::str::toAsciiLower);
460 }
461
462 void SAL_CALL rtl_str_toAsciiUpperCase(char* pStr) SAL_THROW_EXTERN_C()
463 {
464 return rtl::str::replaceChars(rtl::str::null_terminated(pStr), rtl::str::toAsciiUpper);
465 }
466
467 void SAL_CALL rtl_str_toAsciiUpperCase_WithLength(char* pStr, sal_Int32 nLen) SAL_THROW_EXTERN_C()
468 {
469 return rtl::str::replaceChars(rtl::str::with_length(pStr, nLen), rtl::str::toAsciiUpper);
470 }
471
472 sal_Int32 SAL_CALL rtl_str_trim(char* pStr) SAL_THROW_EXTERN_C() { return rtl::str::trim(pStr); }
473
474 sal_Int32 SAL_CALL rtl_str_trim_WithLength(char* pStr, sal_Int32 nLen) SAL_THROW_EXTERN_C()
475 {
476 return rtl::str::trim_WithLength(pStr, nLen);
477 }
478
479 sal_Int32 SAL_CALL rtl_str_valueOfBoolean(char* pStr, sal_Bool b) SAL_THROW_EXTERN_C()
480 {
481 return rtl::str::valueOfBoolean(pStr, b);
482 }
483
484 sal_Int32 SAL_CALL rtl_str_valueOfChar(char* pStr, char c) SAL_THROW_EXTERN_C()
485 {
486 return rtl::str::valueOfChar(pStr, c);
487 }
488
489 sal_Int32 SAL_CALL rtl_str_valueOfInt32(char* pStr, sal_Int32 n, sal_Int16 nRadix)
490 SAL_THROW_EXTERN_C()
491 {
492 return rtl::str::valueOfInt<RTL_STR_MAX_VALUEOFINT32>(pStr, n, nRadix);
493 }
494
495 sal_Int32 SAL_CALL rtl_str_valueOfInt64(char* pStr, sal_Int64 n, sal_Int16 nRadix)
496 SAL_THROW_EXTERN_C()
497 {
498 return rtl::str::valueOfInt<RTL_STR_MAX_VALUEOFINT64>(pStr, n, nRadix);
499 }
500
501 sal_Int32 SAL_CALL rtl_str_valueOfUInt64(char* pStr, sal_uInt64 n, sal_Int16 nRadix)
502 SAL_THROW_EXTERN_C()
503 {
504 return rtl::str::valueOfInt<RTL_STR_MAX_VALUEOFUINT64>(pStr, n, nRadix);
505 }
506
507 sal_Bool SAL_CALL rtl_str_toBoolean(const char* pStr) SAL_THROW_EXTERN_C()
508 {
509 return rtl::str::toBoolean(pStr);
510 }
511
512 sal_Int32 SAL_CALL rtl_str_toInt32(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
513 {
514 return rtl::str::toInt<sal_Int32>(rtl::str::null_terminated(pStr), nRadix);
515 }
516
517 sal_Int64 SAL_CALL rtl_str_toInt64(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
518 {
519 return rtl::str::toInt<sal_Int64>(rtl::str::null_terminated(pStr), nRadix);
520 }
521
522 sal_Int64 SAL_CALL rtl_str_toInt64_WithLength(const char* pStr, sal_Int16 nRadix,
523 sal_Int32 nStrLength) SAL_THROW_EXTERN_C()
524 {
525 return rtl::str::toInt<sal_Int64>(rtl::str::with_length(pStr, nStrLength), nRadix);
526 }
527
528 sal_uInt32 SAL_CALL rtl_str_toUInt32(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
529 {
530 return rtl::str::toInt<sal_uInt32>(rtl::str::null_terminated(pStr), nRadix);
531 }
532
533 sal_uInt64 SAL_CALL rtl_str_toUInt64(const char* pStr, sal_Int16 nRadix) SAL_THROW_EXTERN_C()
534 {
535 return rtl::str::toInt<sal_uInt64>(rtl::str::null_terminated(pStr), nRadix);
536 }
537
538 rtl_String* rtl_string_ImplAlloc(sal_Int32 nLen) { return rtl::str::Alloc<rtl_String>(nLen); }
539
540 void SAL_CALL rtl_string_acquire(rtl_String* pThis) SAL_THROW_EXTERN_C()
541 {
542 return rtl::str::acquire(pThis);
543 }
544
545 void SAL_CALL rtl_string_release(rtl_String* pThis) SAL_THROW_EXTERN_C()
546 {
547 return rtl::str::release(pThis);
548 }
549
550 void SAL_CALL rtl_string_new(rtl_String** ppThis) SAL_THROW_EXTERN_C()
551 {
552 return rtl::str::new_(ppThis);
553 }
554
555 rtl_String* SAL_CALL rtl_string_alloc(sal_Int32 nLen) SAL_THROW_EXTERN_C()
556 {
557 assert(nLen >= 0);
558 return rtl::str::Alloc<rtl_String>(nLen);
559 }
560
561 void SAL_CALL rtl_string_new_WithLength(rtl_String** ppThis, sal_Int32 nLen) SAL_THROW_EXTERN_C()
562 {
563 rtl::str::new_WithLength(ppThis, nLen);
564 }
565
566 void SAL_CALL rtl_string_newFromString(rtl_String** ppThis, const rtl_String* pStr)
567 SAL_THROW_EXTERN_C()
568 {
569 rtl::str::newFromString(ppThis, pStr);
570 }
571
572 void SAL_CALL rtl_string_newFromStr(rtl_String** ppThis, const char* pCharStr) SAL_THROW_EXTERN_C()
573 {
574 rtl::str::newFromStr(ppThis, pCharStr);
575 }
576
577 void SAL_CALL rtl_string_newFromStr_WithLength(rtl_String** ppThis, const char* pCharStr,
578 sal_Int32 nLen) SAL_THROW_EXTERN_C()
579 {
580 rtl::str::newFromStr_WithLength(ppThis, pCharStr, nLen);
581 }
582
583 void SAL_CALL rtl_string_newFromSubString(rtl_String** ppThis, const rtl_String* pFrom,
584 sal_Int32 beginIndex, sal_Int32 count)
585 SAL_THROW_EXTERN_C()
586 {
587 rtl::str::newFromSubString(ppThis, pFrom, beginIndex, count);
588 }
589
590 // Used when creating from string literals.
591 void SAL_CALL rtl_string_newFromLiteral(rtl_String** ppThis, const char* pCharStr, sal_Int32 nLen,
592 sal_Int32 allocExtra) SAL_THROW_EXTERN_C()
593 {
594 rtl::str::newFromStr_WithLength(ppThis, pCharStr, nLen, allocExtra);
595 }
596
597 void SAL_CALL rtl_string_assign(rtl_String** ppThis, rtl_String* pStr) SAL_THROW_EXTERN_C()
598 {
599 rtl::str::assign(ppThis, pStr);
600 }
601
602 sal_Int32 SAL_CALL rtl_string_getLength(const rtl_String* pThis) SAL_THROW_EXTERN_C()
603 {
604 return rtl::str::getLength(pThis);
605 }
606
607 char* SAL_CALL rtl_string_getStr(rtl_String* pThis) SAL_THROW_EXTERN_C()
608 {
609 return rtl::str::getStr(pThis);
610 }
611
612 void SAL_CALL rtl_string_newConcat(rtl_String** ppThis, rtl_String* pLeft, rtl_String* pRight)
613 SAL_THROW_EXTERN_C()
614 {
615 rtl::str::newConcat(ppThis, pLeft, pRight);
616 }
617
618 void SAL_CALL rtl_string_ensureCapacity(rtl_String** ppThis, sal_Int32 size) SAL_THROW_EXTERN_C()
619 {
620 rtl::str::ensureCapacity(ppThis, size);
621 }
622
623 void SAL_CALL rtl_string_newReplaceStrAt(rtl_String** ppThis, rtl_String* pStr, sal_Int32 nIndex,
624 sal_Int32 nCount, rtl_String* pNewSubStr)
625 SAL_THROW_EXTERN_C()
626 {
627 rtl::str::newReplaceStrAt(ppThis, pStr, nIndex, nCount, pNewSubStr);
628 }
629
630 void SAL_CALL rtl_string_newReplaceStrAt_WithLength(rtl_String** ppThis, rtl_String* pStr, sal_Int32 nIndex,
631 sal_Int32 nCount, char const * subStr, sal_Int32 substrLen)
632 SAL_THROW_EXTERN_C()
633 {
634 rtl::str::newReplaceStrAt(ppThis, pStr, nIndex, nCount, subStr, substrLen);
635 }
636
637 void SAL_CALL rtl_string_newReplace(rtl_String** ppThis, rtl_String* pStr, char cOld, char cNew)
638 SAL_THROW_EXTERN_C()
639 {
640 rtl::str::newReplaceChars(ppThis, pStr, rtl::str::FromTo(cOld, cNew));
641 }
642
643 void SAL_CALL rtl_string_newToAsciiLowerCase(rtl_String** ppThis, rtl_String* pStr)
644 SAL_THROW_EXTERN_C()
645 {
646 rtl::str::newReplaceChars(ppThis, pStr, rtl::str::toAsciiLower);
647 }
648
649 void SAL_CALL rtl_string_newToAsciiUpperCase(rtl_String** ppThis, rtl_String* pStr)
650 SAL_THROW_EXTERN_C()
651 {
652 rtl::str::newReplaceChars(ppThis, pStr, rtl::str::toAsciiUpper);
653 }
654
655 void SAL_CALL rtl_string_newTrim(rtl_String** ppThis, rtl_String* pStr) SAL_THROW_EXTERN_C()
656 {
657 rtl::str::newTrim(ppThis, pStr);
658 }
659
660 sal_Int32 SAL_CALL rtl_string_getToken(rtl_String** ppThis, rtl_String* pStr, sal_Int32 nToken,
661 char cTok, sal_Int32 nIndex) SAL_THROW_EXTERN_C()
662 {
663 return rtl::str::getToken(ppThis, pStr, nToken, cTok, nIndex);
664 }
665
666 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE