?  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 / strtmpl.hxx
blob8c63f1081f9ccda9755b5d5ab111ed693158063b
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 #pragma once
21
22 #include <algorithm>
23 #include <cassert>
24 #include <cmath>
25 #include <cstddef>
26 #include <cstdlib>
27 #include <cstring>
28 #include <cwchar>
29 #include <limits>
30 #include <new>
31 #include <string_view>
32 #include <type_traits>
33 #include <utility>
34
35 #include "strimp.hxx"
36
37 #include <o3tl/safeint.hxx>
38 #include <o3tl/string_view.hxx>
39 #include <osl/diagnose.h>
40 #include <sal/log.hxx>
41 #include <rtl/character.hxx>
42 #include <rtl/math.h>
43 #include <rtl/string.h>
44 #include <rtl/ustring.h>
45
46 #include <dragonbox/dragonbox.h>
47
48 void internRelease(rtl_uString*);
49
50 namespace rtl::str
51 {
52 template <typename C> auto UChar(C c) { return std::make_unsigned_t<C>(c); }
53
54 // Wrappers around null-terminated/known-length strings, that allow to generalize algorithms
55 // without overhead (e.g., without need to get length of null-terminated strings).
56
57 template <typename C> struct null_terminated
58 {
59 C* p;
60 null_terminated(C* pStr)
61 : p(pStr)
62 {
63 assert(pStr);
64 }
65 auto begin() const { return p; }
66 struct EndDetector
67 {
68 friend bool operator==(EndDetector, C* iter) { return *iter == 0; }
69 friend bool operator==(C* iter, EndDetector) { return *iter == 0; }
70 friend bool operator!=(EndDetector, C* iter) { return *iter != 0; }
71 friend bool operator!=(C* iter, EndDetector) { return *iter != 0; }
72 };
73 static auto end() { return EndDetector{}; }
74 };
75
76 template <typename C> struct with_length
77 {
78 C* p;
79 sal_Int32 len;
80 with_length(C* pStr, sal_Int32 nLength)
81 : p(pStr)
82 , len(nLength)
83 {
84 assert(len >= 0);
85 }
86 auto begin() const { return p; }
87 auto end() const { return p + len; }
88 };
89
90 template <bool (&fApplicable)(sal_uInt32), sal_uInt32 (&fReplace)(sal_uInt32)> struct CaseReplace
91 {
92 static auto Applicable() { return [](auto c) { return fApplicable(UChar(c)); }; }
93 template <typename C> static C Replace(C c) { return fReplace(UChar(c)); }
94 };
95 constexpr CaseReplace<rtl::isAsciiUpperCase, rtl::toAsciiLowerCase> toAsciiLower;
96 constexpr CaseReplace<rtl::isAsciiLowerCase, rtl::toAsciiUpperCase> toAsciiUpper;
97
98 template <typename C> struct FromTo
99 {
100 C from;
101 C to;
102 FromTo(C cFrom, C cTo) : from(cFrom), to(cTo) {}
103 auto Applicable() const { return [this](C c) { return c == from; }; }
104 C Replace(C c) const { return c == from ? to : c; }
105 };
106
107 template <typename C> void Copy(C* _pDest, const C* _pSrc, sal_Int32 _nCount)
108 {
109 // take advantage of builtin optimisations
110 std::copy(_pSrc, _pSrc + _nCount, _pDest);
111 }
112
113 template <typename C> void CopyBackward(C* _pDest, const C* _pSrc, sal_Int32 _nCount)
114 {
115 // take advantage of builtin optimisations
116 std::copy_backward(_pSrc, _pSrc + _nCount, _pDest + _nCount);
117 }
118
119 inline void Copy(sal_Unicode* _pDest, const char* _pSrc, sal_Int32 _nCount)
120 {
121 std::transform(_pSrc, _pSrc + _nCount, _pDest,
122 [](char c)
123 {
124 assert(rtl::isAscii(static_cast<unsigned char>(c)));
125 SAL_WARN_IF(c == '\0', "rtl.string", "Found embedded \\0 ASCII character");
126 return static_cast<unsigned char>(c);
127 });
128 }
129
130 inline sal_Int16 implGetDigit(sal_Unicode ch, sal_Int16 nRadix)
131 {
132 sal_Int16 n = -1;
133 if ((ch >= '0') && (ch <= '9'))
134 n = ch - '0';
135 else if ((ch >= 'a') && (ch <= 'z'))
136 n = ch - 'a' + 10;
137 else if ((ch >= 'A') && (ch <= 'Z'))
138 n = ch - 'A' + 10;
139 return (n < nRadix) ? n : -1;
140 }
141
142 /* ======================================================================= */
143 /* C-String functions which could be used without the String-Class */
144 /* ======================================================================= */
145
146 template <typename T> sal_Int32 getLength( const T* pStr )
147 {
148 assert(pStr);
149 if constexpr (std::is_class_v<T>)
150 {
151 return pStr->length;
152 }
153 else
154 {
155 // take advantage of builtin optimisations
156 return std::char_traits<T>::length(pStr);
157 }
158 }
159
160 /* ----------------------------------------------------------------------- */
161
162 template <typename C> void warnIfCharAndNotAscii(C c)
163 {
164 if constexpr (sizeof(c) == sizeof(char))
165 SAL_WARN_IF(!rtl::isAscii(static_cast<unsigned char>(c)), "rtl.string",
166 "Found non-ASCII char");
167 }
168
169 template <typename C1, typename C2> void warnIfOneIsCharAndNotAscii(C1 c1, C2 c2)
170 {
171 if constexpr (sizeof(c1) != sizeof(c2))
172 {
173 warnIfCharAndNotAscii(c1);
174 warnIfCharAndNotAscii(c2);
175 }
176 }
177
178 struct CompareNormal
179 {
180 template <typename C1, typename C2> static sal_Int32 compare(C1 c1, C2 c2)
181 {
182 warnIfOneIsCharAndNotAscii(c1, c2);
183 return static_cast<sal_Int32>(UChar(c1))
184 - static_cast<sal_Int32>(UChar(c2));
185 }
186 };
187
188 struct CompareIgnoreAsciiCase
189 {
190 template <typename C1, typename C2> static sal_Int32 compare(C1 c1, C2 c2)
191 {
192 warnIfOneIsCharAndNotAscii(c1, c2);
193 return rtl::compareIgnoreAsciiCase(UChar(c1), UChar(c2));
194 }
195 };
196
197 /* ----------------------------------------------------------------------- */
198
199 struct NoShortening
200 {
201 constexpr bool operator>=(int) { return true; } // for assert
202 constexpr bool operator==(int) { return false; } // for loop break check
203 constexpr void operator--() {} // for decrement in loop
204 } constexpr noShortening;
205
206 template <class S1, class S2, class Compare, typename Shorten_t>
207 sal_Int32 compare(S1 s1, S2 s2, Compare, Shorten_t shortenedLength)
208 {
209 static_assert(std::is_same_v<Shorten_t, NoShortening> || std::is_same_v<Shorten_t, sal_Int32>);
210 assert(shortenedLength >= 0);
211 auto pStr1 = s1.begin();
212 const auto end1 = s1.end();
213 auto pStr2 = s2.begin();
214 const auto end2 = s2.end();
215 for (;;)
216 {
217 if (shortenedLength == 0)
218 return 0;
219 if (pStr2 == end2)
220 return pStr1 == end1 ? 0 : 1;
221 if (pStr1 == end1)
222 return -1;
223 if (const sal_Int32 nRet = Compare::compare(*pStr1, *pStr2))
224 return nRet;
225 --shortenedLength;
226 ++pStr1;
227 ++pStr2;
228 }
229 }
230
231 // take advantage of builtin optimisations
232 template <typename C> requires (sizeof(C) == sizeof(wchar_t))
233 sal_Int32 compare(null_terminated<C> s1, null_terminated<C> s2, CompareNormal, NoShortening)
234 {
235 return wcscmp(reinterpret_cast<wchar_t const*>(s1.p), reinterpret_cast<wchar_t const*>(s2.p));
236 }
237 template <typename C> requires (sizeof(C) == sizeof(char))
238 sal_Int32 compare(null_terminated<C> s1, null_terminated<C> s2, CompareNormal, NoShortening)
239 {
240 return strcmp(reinterpret_cast<char const*>(s1.p), reinterpret_cast<char const*>(s2.p));
241 }
242 template <typename C>
243 sal_Int32 compare(with_length<C> s1, with_length<C> s2, CompareNormal, NoShortening)
244 {
245 std::basic_string_view sv1(s1.p, s1.len);
246 return sv1.compare(std::basic_string_view(s2.p, s2.len));
247 }
248 template <typename C1, typename C2, class Compare>
249 sal_Int32 compare(with_length<C1> s1, with_length<C2> s2, Compare cf, sal_Int32 nShortenedLength)
250 {
251 assert(nShortenedLength >= 0);
252 s1.len = std::min(s1.len, nShortenedLength);
253 s2.len = std::min(s2.len, nShortenedLength);
254 return compare(s1, s2, cf, noShortening);
255 }
256
257 /* ----------------------------------------------------------------------- */
258
259 template <typename C1, typename C2, class Compare>
260 sal_Int32 reverseCompare_WithLengths(const C1* pStr1, sal_Int32 nStr1Len,
261 const C2* pStr2, sal_Int32 nStr2Len, Compare)
262 {
263 assert(pStr1 || nStr1Len == 0);
264 assert(nStr1Len >= 0);
265 assert(pStr2 || nStr2Len == 0);
266 assert(nStr2Len >= 0);
267 const C1* pStr1Run = pStr1+nStr1Len;
268 const C2* pStr2Run = pStr2+nStr2Len;
269 while ((pStr1 < pStr1Run) && (pStr2 < pStr2Run))
270 {
271 pStr1Run--;
272 pStr2Run--;
273 if (const sal_Int32 nRet = Compare::compare(*pStr1Run, *pStr2Run))
274 return nRet;
275 }
276
277 return nStr1Len - nStr2Len;
278 }
279
280 /* ----------------------------------------------------------------------- */
281
282 template <typename C> sal_Int32 hashCode_WithLength(const C* pStr, sal_Int32 nLen)
283 {
284 assert(nLen >= 0);
285 sal_uInt32 h = static_cast<sal_uInt32>(nLen);
286 while ( nLen > 0 )
287 {
288 h = (h*37U) + UChar( *pStr );
289 pStr++;
290 nLen--;
291 }
292 return static_cast<sal_Int32>(h);
293 }
294
295 /* ----------------------------------------------------------------------- */
296
297 template <typename C> sal_Int32 hashCode(const C* pStr)
298 {
299 return hashCode_WithLength( pStr, getLength( pStr ) );
300 }
301
302 /* ----------------------------------------------------------------------- */
303
304 template <typename C> sal_Int32 indexOfChar(const C* pStr, C c)
305 {
306 assert(pStr);
307 if (!c)
308 return -1; // Unifies behavior of strchr/wcschr and unoptimized algorithm wrt '\0'
309
310 if constexpr (sizeof(C) == sizeof(char))
311 {
312 // take advantage of builtin optimisations
313 const C* p = strchr(pStr, c);
314 return p ? p - pStr : -1;
315 }
316 else if constexpr (sizeof(C) == sizeof(wchar_t))
317 {
318 // take advantage of builtin optimisations
319 wchar_t const * p = wcschr(reinterpret_cast<wchar_t const *>(pStr), static_cast<wchar_t>(c));
320 return p ? p - reinterpret_cast<wchar_t const *>(pStr) : -1;
321 }
322 else
323 {
324 const C* pTempStr = pStr;
325 while ( *pTempStr )
326 {
327 if ( *pTempStr == c )
328 return pTempStr-pStr;
329
330 pTempStr++;
331 }
332
333 return -1;
334 }
335 }
336
337 /* ----------------------------------------------------------------------- */
338
339 template <typename C> sal_Int32 indexOfChar_WithLength(const C* pStr, sal_Int32 nLen, C c)
340 {
341 // assert(nLen >= 0);
342 if (nLen <= 0)
343 return -1;
344 // take advantage of builtin optimisations
345 std::basic_string_view v(pStr, nLen);
346 auto idx = v.find(c);
347 return idx == v.npos ? -1 : idx;
348 }
349
350 /* ----------------------------------------------------------------------- */
351
352 template <typename C> sal_Int32 lastIndexOfChar_WithLength(const C* pStr, sal_Int32 nLen, C c)
353 {
354 assert(nLen >= 0);
355 // take advantage of builtin optimisations
356 std::basic_string_view v(pStr, nLen);
357 auto idx = v.rfind(c);
358 return idx == v.npos ? -1 : idx;
359 }
360
361 /* ----------------------------------------------------------------------- */
362
363 template <typename C> sal_Int32 lastIndexOfChar(const C* pStr, C c)
364 {
365 assert(pStr);
366 if (!c)
367 return -1; // Unifies behavior of strrchr/wcsrchr and lastIndexOfChar_WithLength wrt '\0'
368
369 if constexpr (sizeof(C) == sizeof(char))
370 {
371 // take advantage of builtin optimisations
372 const C* p = strrchr(pStr, c);
373 return p ? p - pStr : -1;
374 }
375 else if constexpr (sizeof(C) == sizeof(wchar_t))
376 {
377 // take advantage of builtin optimisations
378 wchar_t const * p = wcsrchr(reinterpret_cast<wchar_t const *>(pStr), static_cast<wchar_t>(c));
379 return p ? p - reinterpret_cast<wchar_t const *>(pStr) : -1;
380 }
381 else
382 {
383 return lastIndexOfChar_WithLength( pStr, getLength( pStr ), c );
384 }
385 }
386
387 /* ----------------------------------------------------------------------- */
388
389 template <typename C>
390 sal_Int32 indexOfStr_WithLength(const C* pStr, sal_Int32 nStrLen,
391 const C* pSubStr, sal_Int32 nSubLen)
392 {
393 assert(nStrLen >= 0);
394 assert(nSubLen >= 0);
395 /* an empty SubString is always not findable */
396 if ( nSubLen == 0 )
397 return -1;
398 // take advantage of builtin optimisations
399 std::basic_string_view v(pStr, nStrLen);
400 auto idx = nSubLen == 1 ? v.find(*pSubStr) : v.find(pSubStr, 0, nSubLen);
401 return idx == v.npos ? -1 : idx;
402 }
403
404 inline sal_Int32 indexOfStr_WithLength(const sal_Unicode* pStr, sal_Int32 nStrLen,
405 const char* pSubStr, sal_Int32 nSubLen)
406 {
407 assert(nStrLen >= 0);
408 assert(nSubLen >= 0);
409 if (nSubLen > 0 && nSubLen <= nStrLen)
410 {
411 sal_Unicode const* end = pStr + nStrLen;
412 sal_Unicode const* cursor = pStr;
413
414 while (cursor < end)
415 {
416 cursor = std::char_traits<sal_Unicode>::find(cursor, end - cursor, *pSubStr);
417 if (!cursor || (end - cursor < nSubLen))
418 {
419 /* no enough left to actually have a match */
420 break;
421 }
422 /* now it is worth trying a full match */
423 if (nSubLen == 1 || rtl_ustr_asciil_reverseEquals_WithLength(cursor, pSubStr, nSubLen))
424 {
425 return cursor - pStr;
426 }
427 cursor += 1;
428 }
429 }
430 return -1;
431 }
432
433 /* ----------------------------------------------------------------------- */
434
435 template <typename C> sal_Int32 indexOfStr(const C* pStr, const C* pSubStr)
436 {
437 assert(pStr);
438 assert(pSubStr);
439 /* an empty SubString is always not findable */
440 if (*pSubStr == 0)
441 return -1;
442 if constexpr (sizeof(C) == sizeof(char))
443 {
444 // take advantage of builtin optimisations
445 const C* p = strstr(pStr, pSubStr);
446 return p ? p - pStr : -1;
447 }
448 else if constexpr (sizeof(C) == sizeof(wchar_t))
449 {
450 // take advantage of builtin optimisations
451 wchar_t const * p = wcsstr(reinterpret_cast<wchar_t const *>(pStr), reinterpret_cast<wchar_t const *>(pSubStr));
452 return p ? p - reinterpret_cast<wchar_t const *>(pStr) : -1;
453 }
454 else
455 {
456 return indexOfStr_WithLength( pStr, getLength( pStr ),
457 pSubStr, getLength( pSubStr ) );
458 }
459 }
460
461 /* ----------------------------------------------------------------------- */
462
463 template <typename C>
464 sal_Int32 lastIndexOfStr_WithLength(const C* pStr, sal_Int32 nStrLen,
465 const C* pSubStr, sal_Int32 nSubLen)
466 {
467 assert(nStrLen >= 0);
468 assert(nSubLen >= 0);
469 /* an empty SubString is always not findable */
470 if ( nSubLen == 0 )
471 return -1;
472 // take advantage of builtin optimisations
473 std::basic_string_view v(pStr, nStrLen);
474 std::basic_string_view needle(pSubStr, nSubLen);
475 auto idx = v.rfind(needle);
476 return idx == v.npos ? -1 : idx;
477 }
478
479 /* ----------------------------------------------------------------------- */
480
481 template <typename C> sal_Int32 lastIndexOfStr(const C* pStr, const C* pSubStr)
482 {
483 return lastIndexOfStr_WithLength(pStr, getLength(pStr), pSubStr, getLength(pSubStr));
484 }
485
486 /* ----------------------------------------------------------------------- */
487
488 template <class S, class Replacer> void replaceChars(S str, Replacer replacer)
489 {
490 for (auto& rChar : str)
491 rChar = replacer.Replace(rChar);
492 }
493
494 /* ----------------------------------------------------------------------- */
495
496 template <typename C> sal_Int32 trim_WithLength(C* pStr, sal_Int32 nLen)
497 {
498 const auto view = o3tl::trim(std::basic_string_view(pStr, nLen));
499
500 if (static_cast<sal_Int32>(view.size()) != nLen)
501 {
502 nLen = static_cast<sal_Int32>(view.size());
503 if (view.data() != pStr)
504 Copy(pStr, view.data(), nLen);
505 *(pStr+nLen) = 0;
506 }
507
508 return nLen;
509 }
510
511 /* ----------------------------------------------------------------------- */
512
513 template <typename C> sal_Int32 trim(C* pStr) { return trim_WithLength(pStr, getLength(pStr)); }
514
515 /* ----------------------------------------------------------------------- */
516
517 template <typename C> sal_Int32 valueOfBoolean(C* pStr, sal_Bool b)
518 {
519 assert(pStr);
520 if ( b )
521 {
522 *pStr = 't';
523 pStr++;
524 *pStr = 'r';
525 pStr++;
526 *pStr = 'u';
527 pStr++;
528 *pStr = 'e';
529 pStr++;
530 *pStr = 0;
531 return 4;
532 }
533 else
534 {
535 *pStr = 'f';
536 pStr++;
537 *pStr = 'a';
538 pStr++;
539 *pStr = 'l';
540 pStr++;
541 *pStr = 's';
542 pStr++;
543 *pStr = 'e';
544 pStr++;
545 *pStr = 0;
546 return 5;
547 }
548 }
549
550 /* ----------------------------------------------------------------------- */
551
552 template <typename C> sal_Int32 valueOfChar(C* pStr, C c)
553 {
554 assert(pStr);
555 *pStr++ = c;
556 *pStr = 0;
557 return 1;
558 }
559
560 /* ----------------------------------------------------------------------- */
561
562 template <sal_Int32 maxLen, typename C, typename T>
563 sal_Int32 valueOfInt(C* pStr, T n, sal_Int16 nRadix)
564 {
565 assert(pStr);
566 assert( nRadix >= RTL_STR_MIN_RADIX && nRadix <= RTL_STR_MAX_RADIX );
567 const auto* const pStart = pStr;
568 char aBuf[maxLen];
569 char* pBuf = aBuf;
570 using uT = std::make_unsigned_t<T>;
571 uT nValue;
572
573 /* Radix must be valid */
574 if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
575 nRadix = 10;
576
577 if constexpr (std::is_signed_v<T>)
578 {
579 /* is value negative */
580 if ( n < 0 )
581 {
582 *pStr = '-';
583 pStr++;
584 nValue = n == std::numeric_limits<T>::min() ? static_cast<uT>(n) : -n;
585 }
586 else
587 nValue = n;
588 }
589 else
590 nValue = n;
591
592 /* create a recursive buffer with all values, except the last one */
593 do
594 {
595 char nDigit = static_cast<char>(nValue % nRadix);
596 nValue /= nRadix;
597 if ( nDigit > 9 )
598 *pBuf = (nDigit-10) + 'a';
599 else
600 *pBuf = (nDigit + '0' );
601 pBuf++;
602 }
603 while ( nValue > 0 );
604
605 /* copy the values in the right direction into the destination buffer */
606 pStr = std::reverse_copy(aBuf, pBuf, pStr);
607 *pStr = 0;
608
609 return pStr - pStart;
610 }
611
612 /* ----------------------------------------------------------------------- */
613
614 template <typename C> sal_Bool toBoolean(const C* pStr)
615 {
616 assert(pStr);
617 if ( *pStr == '1' )
618 return true;
619
620 if ( (*pStr == 'T') || (*pStr == 't') )
621 {
622 pStr++;
623 if ( (*pStr == 'R') || (*pStr == 'r') )
624 {
625 pStr++;
626 if ( (*pStr == 'U') || (*pStr == 'u') )
627 {
628 pStr++;
629 if ( (*pStr == 'E') || (*pStr == 'e') )
630 return true;
631 }
632 }
633 }
634
635 return false;
636 }
637
638 /* ----------------------------------------------------------------------- */
639
640 template <typename T, class Iter> inline bool HandleSignChar(Iter& iter)
641 {
642 if constexpr (std::numeric_limits<T>::is_signed)
643 {
644 if (*iter == '-')
645 {
646 ++iter;
647 return true;
648 }
649 }
650 if (*iter == '+')
651 ++iter;
652 return false;
653 }
654
655 template <typename T> std::pair<T, sal_Int16> DivMod(sal_Int16 nRadix, [[maybe_unused]] bool bNeg)
656 {
657 if constexpr (std::numeric_limits<T>::is_signed)
658 if (bNeg)
659 return { -(std::numeric_limits<T>::min() / nRadix),
660 -(std::numeric_limits<T>::min() % nRadix) };
661 return { std::numeric_limits<T>::max() / nRadix, std::numeric_limits<T>::max() % nRadix };
662 }
663
664 template <typename T, class S> T toInt(S str, sal_Int16 nRadix)
665 {
666 assert( nRadix >= RTL_STR_MIN_RADIX && nRadix <= RTL_STR_MAX_RADIX );
667
668 if ( (nRadix < RTL_STR_MIN_RADIX) || (nRadix > RTL_STR_MAX_RADIX) )
669 nRadix = 10;
670
671 auto pStr = str.begin();
672 const auto end = str.end();
673
674 /* Skip whitespaces */
675 while (pStr != end && o3tl::internal::implIsWhitespace(UChar(*pStr)))
676 pStr++;
677 if (pStr == end)
678 return 0;
679
680 const bool bNeg = HandleSignChar<T>(pStr);
681 const auto& [nDiv, nMod] = DivMod<T>(nRadix, bNeg);
682 assert(nDiv > 0);
683
684 std::make_unsigned_t<T> n = 0;
685 while (pStr != end)
686 {
687 sal_Int16 nDigit = implGetDigit(UChar(*pStr), nRadix);
688 if ( nDigit < 0 )
689 break;
690 if (static_cast<std::make_unsigned_t<T>>(nMod < nDigit ? nDiv - 1 : nDiv) < n)
691 return 0;
692
693 n *= nRadix;
694 n += nDigit;
695
696 pStr++;
697 }
698
699 if constexpr (std::numeric_limits<T>::is_signed)
700 if (bNeg)
701 return n == static_cast<std::make_unsigned_t<T>>(std::numeric_limits<T>::min())
702 ? std::numeric_limits<T>::min()
703 : -static_cast<T>(n);
704 return static_cast<T>(n);
705 }
706
707 /* ======================================================================= */
708 /* Internal String-Class help functions */
709 /* ======================================================================= */
710
711 template <class rtl_tString> using Char_T = std::remove_extent_t<decltype(rtl_tString::buffer)>;
712
713 template <typename rtl_tString> rtl_tString* Alloc(sal_Int32 nLen)
714 {
715 constexpr auto fix = offsetof(rtl_tString, buffer) + sizeof rtl_tString::buffer;
716 rtl_tString * pData
717 = (o3tl::make_unsigned(nLen)
718 <= ((std::numeric_limits<std::size_t>::max() - fix)
719 / sizeof (Char_T<rtl_tString>)))
720 ? static_cast<rtl_tString *>(rtl_allocateString(
721 fix + nLen * sizeof (Char_T<rtl_tString>)))
722 : nullptr;
723 if (pData != nullptr) {
724 pData->refCount = 1;
725 pData->length = nLen;
726 pData->buffer[nLen] = 0;
727 }
728 return pData;
729 }
730
731 /* ======================================================================= */
732 /* String-Class functions */
733 /* ======================================================================= */
734
735 template <typename rtl_tString> void acquire(rtl_tString* pThis)
736 {
737 if (!SAL_STRING_IS_STATIC (pThis))
738 osl_atomic_increment( &((pThis)->refCount) );
739 }
740
741 /* ----------------------------------------------------------------------- */
742
743 template <typename rtl_tString> void release(rtl_tString* pThis)
744 {
745 if (SAL_UNLIKELY(SAL_STRING_IS_STATIC (pThis)))
746 return;
747
748 /* OString doesn't have an 'intern' */
749 if constexpr (sizeof(Char_T<rtl_tString>) == sizeof(sal_Unicode))
750 {
751 if (SAL_STRING_IS_INTERN (pThis))
752 {
753 internRelease (pThis);
754 return;
755 }
756 }
757
758 if ( !osl_atomic_decrement( &(pThis->refCount) ) )
759 {
760 RTL_LOG_STRING_DELETE( pThis );
761 rtl_freeString( pThis );
762 }
763 }
764
765 /* ----------------------------------------------------------------------- */
766
767 /* static data to be referenced by all empty strings
768 * the refCount is predefined to 1 and must never become 0 !
769 */
770 template <typename rtl_tString> struct EmptyStringImpl
771 {
772 static rtl_tString data;
773 };
774
775 template <>
776 inline rtl_uString EmptyStringImpl<rtl_uString>::data = {
777 sal_Int32(SAL_STRING_INTERN_FLAG | SAL_STRING_STATIC_FLAG | 1), /* sal_Int32 refCount; */
778 0, /* sal_Int32 length; */
779 { 0 } /* sal_Unicode buffer[1]; */
780 };
781
782 template <>
783 inline rtl_String EmptyStringImpl<rtl_String>::data = {
784 SAL_STRING_STATIC_FLAG | 1, /* sal_Int32 refCount; */
785 0, /* sal_Int32 length; */
786 { 0 } /* char buffer[1]; */
787 };
788
789 template <typename rtl_tString> void new_(rtl_tString** ppThis)
790 {
791 assert(ppThis);
792 if ( *ppThis)
793 release( *ppThis );
794
795 *ppThis = &EmptyStringImpl<rtl_tString>::data;
796 }
797
798 /* ----------------------------------------------------------------------- */
799
800 template <typename rtl_tString> void new_WithLength(rtl_tString** ppThis, sal_Int32 nLen)
801 {
802 assert(ppThis);
803 assert(nLen >= 0);
804 if ( nLen <= 0 )
805 new_( ppThis );
806 else
807 {
808 if ( *ppThis)
809 release( *ppThis );
810
811 *ppThis = Alloc<rtl_tString>( nLen );
812 assert(*ppThis != nullptr);
813 (*ppThis)->length = 0;
814 (*ppThis)->buffer[0] = 0;
815 }
816 }
817
818 /* ----------------------------------------------------------------------- */
819
820 template <typename rtl_tString, typename C>
821 void newFromStr_WithLength(rtl_tString** ppThis, const C* pCharStr, sal_Int32 nLen,
822 sal_Int32 allocExtra = 0)
823 {
824 assert(ppThis);
825 assert(nLen >= 0);
826 assert(pCharStr || nLen == 0);
827 assert(allocExtra >= 0);
828
829 if (nLen + allocExtra == 0)
830 return new_(ppThis);
831
832 rtl_tString* pOrg = *ppThis;
833 *ppThis = Alloc<rtl_tString>(nLen + allocExtra);
834 assert(*ppThis != nullptr);
835 if (nLen > 0)
836 Copy((*ppThis)->buffer, pCharStr, nLen);
837 if (allocExtra > 0)
838 {
839 (*ppThis)->length = nLen;
840 (*ppThis)->buffer[nLen] = 0;
841 }
842
843 RTL_LOG_STRING_NEW(*ppThis);
844
845 /* must be done last, if pCharStr belongs to *ppThis */
846 if (pOrg)
847 release(pOrg);
848 }
849
850 template <typename rtl_tString> void newFromString(rtl_tString** ppThis, const rtl_tString* pStr)
851 {
852 assert(pStr);
853
854 newFromStr_WithLength(ppThis, pStr->buffer, pStr->length);
855 }
856
857 /* ----------------------------------------------------------------------- */
858
859 template <typename rtl_tString>
860 void newFromStr(rtl_tString** ppThis, const Char_T<rtl_tString>* pCharStr)
861 {
862 newFromStr_WithLength(ppThis, pCharStr, getLength(pCharStr));
863 }
864
865 /* ----------------------------------------------------------------------- */
866
867 template <typename rtl_tString> void assign(rtl_tString** ppThis, rtl_tString* pStr)
868 {
869 assert(ppThis);
870 /* must be done at first, if pStr == *ppThis */
871 acquire( pStr );
872
873 if ( *ppThis )
874 release( *ppThis );
875
876 *ppThis = pStr;
877 }
878
879 /* ----------------------------------------------------------------------- */
880
881 template <typename rtl_tString>
882 void newFromSubString(rtl_tString** ppThis, const rtl_tString* pFrom, sal_Int32 beginIndex,
883 sal_Int32 count)
884 {
885 assert(ppThis);
886 if ( beginIndex == 0 && count == pFrom->length )
887 return assign(ppThis, const_cast<rtl_tString*>(pFrom));
888 if ( count < 0 || beginIndex < 0 || beginIndex + count > pFrom->length )
889 {
890 assert(false); // fail fast at least in debug builds
891 return newFromStr_WithLength(ppThis, "!!br0ken!!", 10);
892 }
893
894 newFromStr_WithLength( ppThis, pFrom->buffer + beginIndex, count );
895 }
896
897 /* ----------------------------------------------------------------------- */
898
899 template <typename rtl_tString> auto* getStr(rtl_tString* pThis)
900 {
901 assert(pThis);
902 return pThis->buffer;
903 }
904
905 /* ----------------------------------------------------------------------- */
906
907 enum ThrowPolicy { NoThrow, Throw };
908
909 template <ThrowPolicy throwPolicy, typename rtl_tString, typename C1, typename C2>
910 void newConcat(rtl_tString** ppThis, const C1* pLeft, sal_Int32 nLeftLength,
911 const C2* pRight, sal_Int32 nRightLength)
912 {
913 assert(ppThis);
914 assert(nLeftLength >= 0);
915 assert(pLeft || nLeftLength == 0);
916 assert(nRightLength >= 0);
917 assert(pRight || nRightLength == 0);
918 rtl_tString* pOrg = *ppThis;
919
920 if (nLeftLength > std::numeric_limits<sal_Int32>::max() - nRightLength)
921 {
922 if constexpr (throwPolicy == NoThrow)
923 *ppThis = nullptr;
924 else
925 {
926 #if !defined(__COVERITY__)
927 throw std::length_error("newConcat");
928 #else
929 //coverity doesn't report std::bad_alloc as an unhandled exception when
930 //potentially thrown from destructors but does report std::length_error
931 throw std::bad_alloc();
932 #endif
933 }
934 }
935 else
936 {
937 auto* pTempStr = Alloc<rtl_tString>(nLeftLength + nRightLength);
938 OSL_ASSERT(pTempStr != nullptr);
939 *ppThis = pTempStr;
940 if (*ppThis != nullptr) {
941 if (nLeftLength)
942 Copy( pTempStr->buffer, pLeft, nLeftLength );
943 if (nRightLength)
944 Copy( pTempStr->buffer+nLeftLength, pRight, nRightLength );
945
946 RTL_LOG_STRING_NEW( *ppThis );
947 }
948 }
949
950 /* must be done last, if left or right == *ppThis */
951 if ( pOrg )
952 release( pOrg );
953 }
954
955 template <typename rtl_tString, typename C>
956 void newConcat(rtl_tString** ppThis, rtl_tString* pLeft, const C* pRight, sal_Int32 nRightLength)
957 {
958 assert(pLeft != nullptr);
959 if (nRightLength == 0)
960 assign(ppThis, pLeft);
961 else
962 newConcat<Throw>(ppThis, pLeft->buffer, pLeft->length, pRight, nRightLength);
963 }
964
965 template <typename rtl_tString>
966 void newConcat(rtl_tString** ppThis, rtl_tString* pLeft, rtl_tString* pRight)
967 {
968 /* Test for 0-Pointer - if not, change newReplaceStrAt! */
969 if ( !pRight || !pRight->length )
970 {
971 assert(pLeft != nullptr);
972 assign(ppThis, pLeft);
973 }
974 else if ( !pLeft || !pLeft->length )
975 assign(ppThis, pRight);
976 else
977 newConcat<NoThrow>(ppThis, pLeft->buffer, pLeft->length, pRight->buffer, pRight->length);
978 }
979
980 /* ----------------------------------------------------------------------- */
981
982 template <typename rtl_tString> void ensureCapacity(rtl_tString** ppThis, sal_Int32 size)
983 {
984 assert(ppThis);
985 rtl_tString* const pOrg = *ppThis;
986 if ( pOrg->refCount == 1 && pOrg->length >= size )
987 return;
988 assert( pOrg->length <= size ); // do not truncate
989 auto* pTempStr = Alloc<rtl_tString>( size );
990 Copy( pTempStr->buffer, pOrg->buffer, pOrg->length );
991 // right now the length is still the same as of the original
992 pTempStr->length = pOrg->length;
993 pTempStr->buffer[ pOrg->length ] = '\0';
994 *ppThis = pTempStr;
995 RTL_LOG_STRING_NEW( *ppThis );
996
997 release( pOrg );
998 }
999
1000 /* ----------------------------------------------------------------------- */
1001
1002 template <typename rtl_tString, typename C>
1003 void newReplaceStrAt(rtl_tString** ppThis, rtl_tString* pStr, sal_Int32 nIndex, sal_Int32 nCount,
1004 const C* pNewSubStr, sal_Int32 nNewSubStrLen)
1005 {
1006 assert(ppThis);
1007 assert(nIndex >= 0 && nIndex <= pStr->length);
1008 assert(nCount >= 0);
1009 assert(nCount <= pStr->length - nIndex);
1010 assert(pNewSubStr != nullptr || nNewSubStrLen == 0);
1011 assert(nNewSubStrLen >= 0);
1012 /* Append? */
1013 if ( nIndex >= pStr->length )
1014 return newConcat(ppThis, pStr, pNewSubStr, nNewSubStrLen);
1015
1016 /* not more than the String length could be deleted */
1017 if ( nCount >= pStr->length-nIndex )
1018 {
1019 /* Assign of NewSubStr? */
1020 if (nIndex == 0)
1021 return newFromStr_WithLength( ppThis, pNewSubStr, nNewSubStrLen );
1022
1023 nCount = pStr->length - nIndex;
1024 }
1025
1026 /* Assign of Str? */
1027 if ( !nCount && !nNewSubStrLen )
1028 return assign(ppThis, pStr);
1029
1030 rtl_tString* pOrg = *ppThis;
1031
1032 /* Alloc New Buffer */
1033 *ppThis = Alloc<rtl_tString>(pStr->length - nCount + nNewSubStrLen);
1034 assert(*ppThis != nullptr);
1035 auto* pBuffer = (*ppThis)->buffer;
1036 if ( nIndex )
1037 {
1038 Copy( pBuffer, pStr->buffer, nIndex );
1039 pBuffer += nIndex;
1040 }
1041 if ( nNewSubStrLen )
1042 {
1043 Copy( pBuffer, pNewSubStr, nNewSubStrLen );
1044 pBuffer += nNewSubStrLen;
1045 }
1046 Copy( pBuffer, pStr->buffer+nIndex+nCount, pStr->length-nIndex-nCount );
1047
1048 RTL_LOG_STRING_NEW( *ppThis );
1049 /* must be done last, if pStr or pNewSubStr == *ppThis */
1050 if ( pOrg )
1051 release( pOrg );
1052 }
1053
1054 /* ----------------------------------------------------------------------- */
1055
1056 template <typename rtl_tString>
1057 void newReplaceStrAt(rtl_tString** ppThis, rtl_tString* pStr, sal_Int32 nIndex, sal_Int32 nCount,
1058 rtl_tString* pNewSubStr)
1059 {
1060 assert(ppThis);
1061 assert(nIndex >= 0 && nIndex <= pStr->length);
1062 assert(nCount >= 0);
1063 assert(nCount <= pStr->length - nIndex);
1064 /* Append? */
1065 if (nIndex >= pStr->length)
1066 {
1067 /* newConcat test, if pNewSubStr is 0 */
1068 newConcat(ppThis, pStr, pNewSubStr);
1069 return;
1070 }
1071
1072 /* not more than the String length could be deleted */
1073 if (nCount >= pStr->length-nIndex)
1074 {
1075 /* Assign of NewSubStr? */
1076 if (nIndex == 0)
1077 {
1078 if (!pNewSubStr)
1079 return new_(ppThis);
1080 else
1081 return assign(ppThis, pNewSubStr);
1082 }
1083 nCount = pStr->length - nIndex;
1084 }
1085
1086 /* Assign of Str? */
1087 if (!nCount && (!pNewSubStr || !pNewSubStr->length))
1088 {
1089 assign(ppThis, pStr);
1090 return;
1091 }
1092
1093 const auto* pNewSubStrBuf = pNewSubStr ? pNewSubStr->buffer : nullptr;
1094 const sal_Int32 nNewSubStrLength = pNewSubStr ? pNewSubStr->length : 0;
1095 newReplaceStrAt(ppThis, pStr, nIndex, nCount, pNewSubStrBuf, nNewSubStrLength);
1096 }
1097
1098 /* ----------------------------------------------------------------------- */
1099
1100 template <typename rtl_tString, class Replacer>
1101 void newReplaceChars(rtl_tString** ppThis, rtl_tString* pStr, Replacer replacer)
1102 {
1103 assert(ppThis);
1104 assert(pStr);
1105
1106 const auto pEnd = pStr->buffer + pStr->length;
1107 auto pCharStr = std::find_if(pStr->buffer, pEnd, replacer.Applicable());
1108 if (pCharStr != pEnd)
1109 {
1110 rtl_tString* pOrg = *ppThis;
1111 *ppThis = Alloc<rtl_tString>(pStr->length);
1112 assert(*ppThis != nullptr);
1113 auto* pNewCharStr = (*ppThis)->buffer;
1114 /* Copy String */
1115 const sal_Int32 nCount = pCharStr - pStr->buffer;
1116 Copy(pNewCharStr, pStr->buffer, nCount);
1117 pNewCharStr += nCount;
1118 /* replace/copy rest of the string */
1119 do
1120 {
1121 *pNewCharStr = replacer.Replace(*pCharStr);
1122 pNewCharStr++;
1123 pCharStr++;
1124 } while (pCharStr != pEnd);
1125
1126 RTL_LOG_STRING_NEW(*ppThis);
1127 /* must be done last, if pStr == *ppThis */
1128 if (pOrg)
1129 release(pOrg);
1130 }
1131 else
1132 assign(ppThis, pStr);
1133 }
1134
1135 /* ----------------------------------------------------------------------- */
1136
1137 template <typename rtl_tString> void newTrim(rtl_tString** ppThis, rtl_tString* pStr)
1138 {
1139 assert(pStr);
1140 const auto view = o3tl::trim(std::basic_string_view(pStr->buffer, pStr->length));
1141
1142 if (static_cast<sal_Int32>(view.size()) == pStr->length)
1143 assign(ppThis, pStr);
1144 else
1145 newFromStr_WithLength(ppThis, view.data(), view.size());
1146 }
1147
1148 /* ----------------------------------------------------------------------- */
1149
1150 template <typename rtl_tString>
1151 sal_Int32 getToken(rtl_tString** ppThis, rtl_tString* pStr, sal_Int32 nToken,
1152 Char_T<rtl_tString> cTok, sal_Int32 nIndex)
1153 {
1154 assert(ppThis);
1155 assert(pStr);
1156 assert(nIndex <= pStr->length);
1157
1158 // Set ppThis to an empty string and return -1 if either nToken or nIndex is
1159 // negative:
1160 if (nIndex >= 0 && nToken >= 0)
1161 {
1162 const auto* pOrgCharStr = pStr->buffer;
1163 const auto* pCharStr = pOrgCharStr + nIndex;
1164 sal_Int32 nLen = pStr->length - nIndex;
1165 sal_Int32 nTokCount = 0;
1166 const auto* pCharStrStart = pCharStr;
1167 while (nLen > 0)
1168 {
1169 if (*pCharStr == cTok)
1170 {
1171 nTokCount++;
1172
1173 if (nTokCount > nToken)
1174 break;
1175 if (nTokCount == nToken)
1176 pCharStrStart = pCharStr + 1;
1177 }
1178
1179 pCharStr++;
1180 nLen--;
1181 }
1182 if (nTokCount >= nToken)
1183 {
1184 newFromStr_WithLength(ppThis, pCharStrStart, pCharStr - pCharStrStart);
1185 if (nLen > 0)
1186 return pCharStr - pOrgCharStr + 1;
1187 else
1188 return -1;
1189 }
1190 }
1191
1192 new_(ppThis);
1193 return -1;
1194 }
1195
1196 /* ======================================================================= */
1197 /* String buffer help functions */
1198 /* ======================================================================= */
1199
1200 template <class rtl_tString>
1201 void stringbuffer_newFromStr_WithLength(rtl_tString** ppThis,
1202 const Char_T<rtl_tString>* pStr, sal_Int32 count)
1203 {
1204 assert(ppThis);
1205 assert(count >= 0);
1206 if (!pStr)
1207 count = 0; // Because old code didn't care about count when !pStr
1208
1209 newFromStr_WithLength(ppThis, pStr, count, 16);
1210 }
1211
1212 template <class rtl_tString>
1213 sal_Int32 stringbuffer_newFromStringBuffer(rtl_tString** ppThis, sal_Int32 capacity,
1214 rtl_tString* pStr)
1215 {
1216 assert(capacity >= 0);
1217 assert(pStr);
1218
1219 if (capacity < pStr->length)
1220 capacity = pStr->length;
1221
1222 newFromStr_WithLength(ppThis, pStr->buffer, pStr->length, capacity - pStr->length);
1223 return capacity;
1224 }
1225
1226 template <class rtl_tString>
1227 void stringbuffer_ensureCapacity(rtl_tString** ppThis, sal_Int32* capacity,
1228 sal_Int32 minimumCapacity)
1229 {
1230 assert(ppThis);
1231 assert(capacity && *capacity >= 0);
1232 // assert(minimumCapacity >= 0); // It was commented out in rtl_stringbuffer_ensureCapacity
1233 if (minimumCapacity <= *capacity)
1234 return;
1235
1236 const auto nLength = (*ppThis)->length;
1237 *capacity = (nLength + 1) * 2;
1238 if (minimumCapacity > *capacity)
1239 *capacity = minimumCapacity;
1240
1241 newFromStr_WithLength(ppThis, (*ppThis)->buffer, nLength, *capacity - nLength);
1242 }
1243
1244 template <class rtl_tString, typename C>
1245 void stringbuffer_insert(rtl_tString** ppThis, sal_Int32* capacity, sal_Int32 offset,
1246 const C* pStr, sal_Int32 len)
1247 {
1248 assert(ppThis);
1249 assert(capacity && *capacity >= 0);
1250 assert(offset >= 0 && offset <= (*ppThis)->length);
1251 assert(len >= 0);
1252 if (len == 0)
1253 return;
1254 if (len > std::numeric_limits<sal_Int32>::max() - (*ppThis)->length) {
1255 throw std::bad_alloc();
1256 }
1257
1258 stringbuffer_ensureCapacity(ppThis, capacity, (*ppThis)->length + len);
1259
1260 sal_Int32 nOldLen = (*ppThis)->length;
1261 auto* pBuf = (*ppThis)->buffer;
1262
1263 /* copy the tail */
1264 const sal_Int32 n = nOldLen - offset;
1265 if (n > 0)
1266 CopyBackward(pBuf + offset + len, pBuf + offset, n);
1267
1268 /* insert the new characters */
1269 if (pStr != nullptr)
1270 Copy(pBuf + offset, pStr, len);
1271
1272 (*ppThis)->length = nOldLen + len;
1273 pBuf[nOldLen + len] = 0;
1274 }
1275
1276 template <class rtl_tString>
1277 void stringbuffer_remove(rtl_tString** ppThis, sal_Int32 start, sal_Int32 len)
1278 {
1279 assert(ppThis);
1280 assert(start >= 0 && start <= (*ppThis)->length);
1281 assert(len >= 0);
1282
1283 if (len > (*ppThis)->length - start)
1284 len = (*ppThis)->length - start;
1285
1286 //remove nothing
1287 if (!len)
1288 return;
1289
1290 auto* pBuf = (*ppThis)->buffer;
1291 const sal_Int32 nTailLen = (*ppThis)->length - (start + len);
1292
1293 if (nTailLen)
1294 {
1295 /* move the tail */
1296 Copy(pBuf + start, pBuf + start + len, nTailLen);
1297 }
1298
1299 (*ppThis)->length -= len;
1300 pBuf[(*ppThis)->length] = 0;
1301 }
1302
1303 template <class S, typename CharTypeFrom, typename CharTypeTo>
1304 void newReplaceAllFromIndex(S** s, S* s1, CharTypeFrom const* from, sal_Int32 fromLength,
1305 CharTypeTo const* to, sal_Int32 toLength, sal_Int32 fromIndex)
1306 {
1307 assert(s != nullptr);
1308 assert(s1 != nullptr);
1309 assert(fromLength >= 0);
1310 assert(from != nullptr || fromLength == 0);
1311 assert(toLength >= 0);
1312 assert(to != nullptr || toLength == 0);
1313 assert(fromIndex >= 0 && fromIndex <= s1->length);
1314 sal_Int32 i = indexOfStr_WithLength(s1->buffer + fromIndex, s1->length - fromIndex,
1315 from, fromLength);
1316 if (i >= 0)
1317 {
1318 if (s1->length - fromLength > SAL_MAX_INT32 - toLength)
1319 std::abort();
1320 i += fromIndex;
1321 sal_Int32 nCapacity = s1->length + (toLength - fromLength);
1322 if (fromLength < toLength)
1323 {
1324 // Pre-allocate up to 16 replacements more
1325 const sal_Int32 nMaxMoreFinds = (s1->length - i - fromLength) / fromLength;
1326 const sal_Int32 nIncrease = toLength - fromLength;
1327 const sal_Int32 nMoreReplacements = std::min(
1328 { nMaxMoreFinds, (SAL_MAX_INT32 - nCapacity) / nIncrease, sal_Int32(16) });
1329 nCapacity += nMoreReplacements * nIncrease;
1330 }
1331 const auto pOld = *s;
1332 *s = Alloc<S>(nCapacity);
1333 (*s)->length = 0;
1334 fromIndex = 0;
1335 do
1336 {
1337 stringbuffer_insert(s, &nCapacity, (*s)->length, s1->buffer + fromIndex, i);
1338 stringbuffer_insert(s, &nCapacity, (*s)->length, to, toLength);
1339 fromIndex += i + fromLength;
1340 i = indexOfStr_WithLength(s1->buffer + fromIndex, s1->length - fromIndex,
1341 from, fromLength);
1342 } while (i >= 0);
1343 // the rest
1344 stringbuffer_insert(s, &nCapacity, (*s)->length,
1345 s1->buffer + fromIndex, s1->length - fromIndex);
1346 if (pOld)
1347 release(pOld); // Must be last in case *s == s1
1348 }
1349 else
1350 assign(s, s1);
1351
1352 RTL_LOG_STRING_NEW(*s);
1353 }
1354
1355 template <class rtl_tString, typename C1, typename C2>
1356 void newReplaceFirst(rtl_tString** s, rtl_tString* s1, C1 const* from, sal_Int32 fromLength,
1357 C2 const* to, sal_Int32 toLength, sal_Int32& fromIndex)
1358 {
1359 assert(s != nullptr);
1360 assert(s1 != nullptr);
1361 assert(fromLength >= 0);
1362 assert(from != nullptr || fromLength == 0);
1363 assert(toLength >= 0);
1364 assert(to != nullptr || toLength == 0);
1365 assert(fromIndex >= 0 && fromIndex <= s1->length);
1366 sal_Int32 i = indexOfStr_WithLength(s1->buffer + fromIndex, s1->length - fromIndex,
1367 from, fromLength);
1368 if (i >= 0)
1369 {
1370 if (s1->length - fromLength > SAL_MAX_INT32 - toLength)
1371 std::abort();
1372 i += fromIndex;
1373 newReplaceStrAt(s, s1, i, fromLength, to, toLength);
1374 }
1375 else
1376 assign(s, s1);
1377
1378 fromIndex = i;
1379 }
1380
1381 // doubleToString implementation
1382
1383 static inline constexpr sal_uInt64 eX[] = { 10ull,
1384 100ull,
1385 1000ull,
1386 10000ull,
1387 100000ull,
1388 1000000ull,
1389 10000000ull,
1390 100000000ull,
1391 1000000000ull,
1392 10000000000ull,
1393 100000000000ull,
1394 1000000000000ull,
1395 10000000000000ull,
1396 100000000000000ull,
1397 1000000000000000ull,
1398 10000000000000000ull,
1399 100000000000000000ull,
1400 1000000000000000000ull,
1401 10000000000000000000ull };
1402
1403 template <typename rtl_tString>
1404 void doubleToString(rtl_tString** pResult, sal_Int32* pResultCapacity, sal_Int32 nResultOffset,
1405 double fValue, rtl_math_StringFormat eFormat, sal_Int32 nDecPlaces,
1406 Char_T<rtl_tString> cDecSeparator, sal_Int32 const* pGroups,
1407 Char_T<rtl_tString> cGroupSeparator, bool bEraseTrailingDecZeros)
1408 {
1409 auto decimalDigits = [](sal_uInt64 n) {
1410 return std::distance(std::begin(eX), std::upper_bound(std::begin(eX), std::end(eX), n)) + 1;
1411 };
1412
1413 auto roundToPow10 = [](sal_uInt64 n, int e) {
1414 assert(e > 0 && o3tl::make_unsigned(e) <= std::size(eX));
1415 const sal_uInt64 d = eX[e - 1];
1416 return (n + d / 2) / d * d;
1417 };
1418
1419 auto append = [](rtl_tString** s, sal_Int32* pCapacity, sal_Int32 rOffset, auto sv)
1420 {
1421 if (!pCapacity)
1422 newFromStr_WithLength(s, sv.data(), sv.size());
1423 else
1424 stringbuffer_insert(s, pCapacity, rOffset, sv.data(), sv.size());
1425 };
1426
1427 if (std::isnan(fValue))
1428 {
1429 // #i112652# XMLSchema-2
1430 constexpr std::string_view nan{ "NaN" };
1431 return append(pResult, pResultCapacity, nResultOffset, nan);
1432 }
1433
1434 // sign adjustment, instead of testing for fValue<0.0 this will also fetch -0.0
1435 bool bSign = std::signbit(fValue);
1436
1437 if (std::isinf(fValue))
1438 {
1439 // #i112652# XMLSchema-2
1440 std::string_view inf = bSign ? std::string_view("-INF") : std::string_view("INF");
1441 return append(pResult, pResultCapacity, nResultOffset, inf);
1442 }
1443
1444 if (bSign)
1445 fValue = -fValue;
1446
1447 decltype(jkj::dragonbox::to_decimal(fValue, jkj::dragonbox::policy::sign::ignore,
1448 jkj::dragonbox::policy::trailing_zero::ignore)) aParts{};
1449 if (fValue) // to_decimal is documented to only handle non-zero finite numbers
1450 aParts = jkj::dragonbox::to_decimal(fValue, jkj::dragonbox::policy::sign::ignore,
1451 jkj::dragonbox::policy::trailing_zero::ignore);
1452
1453 int nOrigDigits = decimalDigits(aParts.significand);
1454 int nExp = nOrigDigits + aParts.exponent - 1;
1455 int nRoundDigits = 15;
1456
1457 // Unfortunately the old rounding below writes 1.79769313486232e+308 for
1458 // DBL_MAX and 4 subsequent nextafter(...,0).
1459 static const double fB1 = std::nextafter(std::numeric_limits<double>::max(), 0);
1460 static const double fB2 = std::nextafter(fB1, 0);
1461 static const double fB3 = std::nextafter(fB2, 0);
1462 static const double fB4 = std::nextafter(fB3, 0);
1463 if ((fValue >= fB4) && eFormat != rtl_math_StringFormat_F)
1464 {
1465 // 1.7976931348623157e+308 instead of rounded 1.79769313486232e+308
1466 // that can't be converted back as out of range. For rounded values if
1467 // they exceed range they should not be written to exchange strings or
1468 // file formats.
1469
1470 eFormat = rtl_math_StringFormat_E;
1471 nDecPlaces = std::clamp<sal_Int32>(nDecPlaces, 0, 16);
1472 nRoundDigits = 17;
1473 }
1474
1475 // Use integer representation for integer values that fit into the
1476 // mantissa (1.((2^53)-1)) with a precision of 1 for highest accuracy.
1477 if ((eFormat == rtl_math_StringFormat_Automatic || eFormat == rtl_math_StringFormat_F)
1478 && aParts.exponent >= 0 && fValue < 0x1p53)
1479 {
1480 eFormat = rtl_math_StringFormat_F;
1481 if (nDecPlaces == rtl_math_DecimalPlaces_Max)
1482 nDecPlaces = 0;
1483 else
1484 nDecPlaces = std::clamp<sal_Int32>(nDecPlaces, -15, 15);
1485
1486 if (bEraseTrailingDecZeros && nDecPlaces > 0)
1487 nDecPlaces = 0;
1488
1489 nRoundDigits = nOrigDigits; // no rounding
1490 }
1491
1492 switch (eFormat)
1493 {
1494 case rtl_math_StringFormat_Automatic:
1495 // E or F depending on exponent magnitude
1496 if (nExp <= -15 || nExp >= 15)
1497 {
1498 if (nDecPlaces == rtl_math_DecimalPlaces_Max)
1499 nDecPlaces = 14;
1500 eFormat = rtl_math_StringFormat_E;
1501 }
1502 else
1503 {
1504 if (nDecPlaces == rtl_math_DecimalPlaces_Max)
1505 nDecPlaces = (nExp < 14) ? 15 - nExp - 1 : 15;
1506 eFormat = rtl_math_StringFormat_F;
1507 }
1508 break;
1509
1510 case rtl_math_StringFormat_G:
1511 case rtl_math_StringFormat_G1:
1512 case rtl_math_StringFormat_G2:
1513 // G-Point, similar to sprintf %G
1514 if (nDecPlaces == rtl_math_DecimalPlaces_DefaultSignificance)
1515 nDecPlaces = 6;
1516
1517 if (nExp < -4 || nExp >= nDecPlaces)
1518 {
1519 nDecPlaces = std::max<sal_Int32>(1, nDecPlaces - 1);
1520
1521 if (eFormat == rtl_math_StringFormat_G)
1522 eFormat = rtl_math_StringFormat_E;
1523 else if (eFormat == rtl_math_StringFormat_G2)
1524 eFormat = rtl_math_StringFormat_E2;
1525 else if (eFormat == rtl_math_StringFormat_G1)
1526 eFormat = rtl_math_StringFormat_E1;
1527 }
1528 else
1529 {
1530 if (nOrigDigits <= nDecPlaces && aParts.exponent >= 0 && fValue < 0x1p53)
1531 {
1532 // Use integer representation with highest accuracy.
1533 nRoundDigits = nOrigDigits; // no rounding
1534 }
1535 nDecPlaces = std::max<sal_Int32>(0, nDecPlaces - nExp - 1);
1536 eFormat = rtl_math_StringFormat_F;
1537 }
1538 break;
1539
1540 default:
1541 break;
1542 }
1543
1544 // Too large values for nDecPlaces make no sense; it might also be
1545 // rtl_math_DecimalPlaces_Max was passed with rtl_math_StringFormat_F or
1546 // others, but we don't want to allocate/deallocate 2GB just to fill it
1547 // with trailing '0' characters..
1548 nDecPlaces = std::clamp<sal_Int32>(nDecPlaces, -309, 309);
1549
1550 sal_Int32 nDigits = nDecPlaces + 1;
1551
1552 if (eFormat == rtl_math_StringFormat_F)
1553 nDigits += nExp;
1554
1555 // Round the number
1556 nRoundDigits = std::min<int>(nDigits, nRoundDigits);
1557 if (nDigits >= 0 && nOrigDigits > nRoundDigits)
1558 {
1559 aParts.significand = roundToPow10(aParts.significand, nOrigDigits - nRoundDigits);
1560 assert(aParts.significand <= eX[nOrigDigits - 1]);
1561 if (aParts.significand == eX[nOrigDigits - 1]) // up-rounding to the next decade
1562 {
1563 nOrigDigits++;
1564 nExp++;
1565
1566 if (eFormat == rtl_math_StringFormat_F)
1567 nDigits++;
1568 }
1569 }
1570
1571 sal_Int32 nBuf
1572 = (nDigits <= 0 ? std::max<sal_Int32>(nDecPlaces, std::abs(nExp)) : nDigits + nDecPlaces)
1573 + 10 + (pGroups ? std::abs(nDigits) * 2 : 0);
1574 // max(nDigits) = max(nDecPlaces) + 1 + max(nExp) + 1 = 309 + 1 + 308 + 1 = 619
1575 // max(nBuf) = max(nDigits) + max(nDecPlaces) + 10 + max(nDigits) * 2 = 619 * 3 + 309 + 10 = 2176
1576 assert(nBuf <= 2176);
1577 auto* const pBuf = static_cast<Char_T<rtl_tString>*>(alloca(nBuf * sizeof(Char_T<rtl_tString>)));
1578 auto* p = pBuf;
1579 if (bSign)
1580 *p++ = '-';
1581
1582 bool bHasDec = false;
1583
1584 int nDecPos;
1585 // Check for F format and number < 1
1586 if (eFormat == rtl_math_StringFormat_F)
1587 {
1588 if (nExp < 0)
1589 {
1590 *p++ = '0';
1591 if (nDecPlaces > 0)
1592 {
1593 *p++ = cDecSeparator;
1594 bHasDec = true;
1595 }
1596
1597 sal_Int32 i = (nDigits <= 0 ? nDecPlaces : -nExp - 1);
1598
1599 while ((i--) > 0)
1600 *p++ = '0';
1601
1602 nDecPos = 0;
1603 }
1604 else
1605 nDecPos = nExp + 1;
1606 }
1607 else
1608 nDecPos = 1;
1609
1610 int nGrouping = 0, nGroupSelector = 0, nGroupExceed = 0;
1611 if (nDecPos > 1 && pGroups && pGroups[0] && cGroupSeparator)
1612 {
1613 while (nGrouping + pGroups[nGroupSelector] < nDecPos)
1614 {
1615 nGrouping += pGroups[nGroupSelector];
1616 if (pGroups[nGroupSelector + 1])
1617 {
1618 if (nGrouping + pGroups[nGroupSelector + 1] >= nDecPos)
1619 break; // while
1620
1621 ++nGroupSelector;
1622 }
1623 else if (!nGroupExceed)
1624 nGroupExceed = nGrouping;
1625 }
1626 }
1627
1628 // print the number
1629 if (nDigits > 0)
1630 {
1631 for (int nCurExp = nOrigDigits - 1;;)
1632 {
1633 int nDigit;
1634 if (aParts.significand > 0 && nCurExp > 0)
1635 {
1636 --nCurExp;
1637 nDigit = aParts.significand / eX[nCurExp];
1638 aParts.significand %= eX[nCurExp];
1639 }
1640 else
1641 {
1642 nDigit = aParts.significand;
1643 aParts.significand = 0;
1644 }
1645 assert(nDigit >= 0 && nDigit < 10);
1646 *p++ = nDigit + '0';
1647
1648 if (!--nDigits)
1649 break; // for
1650
1651 if (nDecPos)
1652 {
1653 if (!--nDecPos)
1654 {
1655 *p++ = cDecSeparator;
1656 bHasDec = true;
1657 }
1658 else if (nDecPos == nGrouping)
1659 {
1660 *p++ = cGroupSeparator;
1661 nGrouping -= pGroups[nGroupSelector];
1662
1663 if (nGroupSelector && nGrouping < nGroupExceed)
1664 --nGroupSelector;
1665 }
1666 }
1667 }
1668 }
1669
1670 if (!bHasDec && eFormat == rtl_math_StringFormat_F)
1671 { // nDecPlaces < 0 did round the value
1672 while (--nDecPos > 0)
1673 { // fill before decimal point
1674 if (nDecPos == nGrouping)
1675 {
1676 *p++ = cGroupSeparator;
1677 nGrouping -= pGroups[nGroupSelector];
1678
1679 if (nGroupSelector && nGrouping < nGroupExceed)
1680 --nGroupSelector;
1681 }
1682
1683 *p++ = '0';
1684 }
1685 }
1686
1687 if (bEraseTrailingDecZeros && bHasDec)
1688 {
1689 while (*(p - 1) == '0')
1690 p--;
1691
1692 if (*(p - 1) == cDecSeparator)
1693 p--;
1694 }
1695
1696 // Print the exponent ('E', followed by '+' or '-', followed by exactly
1697 // three digits for rtl_math_StringFormat_E). The code in
1698 // rtl_[u]str_valueOf{Float|Double} relies on this format.
1699 if (eFormat == rtl_math_StringFormat_E || eFormat == rtl_math_StringFormat_E2
1700 || eFormat == rtl_math_StringFormat_E1)
1701 {
1702 if (p == pBuf)
1703 *p++ = '1';
1704 // maybe no nDigits if nDecPlaces < 0
1705
1706 *p++ = 'E';
1707 if (nExp < 0)
1708 {
1709 nExp = -nExp;
1710 *p++ = '-';
1711 }
1712 else
1713 *p++ = '+';
1714
1715 if (eFormat == rtl_math_StringFormat_E || nExp >= 100)
1716 *p++ = nExp / 100 + '0';
1717
1718 nExp %= 100;
1719
1720 if (eFormat == rtl_math_StringFormat_E || eFormat == rtl_math_StringFormat_E2 || nExp >= 10)
1721 *p++ = nExp / 10 + '0';
1722
1723 *p++ = nExp % 10 + '0';
1724 }
1725
1726 append(pResult, pResultCapacity, nResultOffset, std::basic_string_view(pBuf, p - pBuf));
1727 }
1728
1729 template <sal_Int32 maxLen, typename C, typename T> sal_Int32 SAL_CALL valueOfFP(C* pStr, T f)
1730 {
1731 assert(pStr);
1732 rtl_String* pResult = nullptr;
1733 doubleToString(&pResult, nullptr, 0, f, rtl_math_StringFormat_G,
1734 maxLen - std::size("-x.E-xxx") + 1, '.', nullptr, 0, true);
1735 const sal_Int32 nLen = pResult->length;
1736 assert(nLen < maxLen);
1737 Copy(pStr, pResult->buffer, nLen + 1);
1738 release(pResult);
1739 return nLen;
1740 }
1741
1742 }
1743
1744 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE