/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* This file incorporates work covered by the following license notice:
*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed
* with this work for additional information regarding copyright
* ownership. The ASF licenses this file to you under the Apache
* License, Version 2.0 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
*/
#include <sal/config.h>
#include <cassert>
#include <cstdlib>
#include <limits>
#include <stdexcept>
#include <string>
#include <osl/diagnose.h>
#include <osl/interlck.h>
#include <rtl/alloc.h>
#include <osl/mutex.h>
#include <rtl/tencinfo.h>
#include <string.h>
#include <sal/alloca.h>
#include <sal/log.hxx>
#include "hash.hxx"
#include "strimp.hxx"
#include <rtl/character.hxx>
#include <rtl/ustring.h>
#include <rtl/math.h>
/* ======================================================================= */
/* static data to be referenced by all empty strings
* the refCount is predefined to 1 and must never become 0 !
*/
static rtl_uString const aImplEmpty_rtl_uString =
{
sal_Int32(SAL_STRING_INTERN_FLAG|SAL_STRING_STATIC_FLAG|1), /*sal_Int32 refCount; */
0, /*sal_Int32 length; */
{ 0 } /*sal_Unicode buffer[1];*/
};
/* ======================================================================= */
/* These macros are for the "poor-man templates" included from
* the strtmpl.cxx just below, used to share code between here and
* string.cxx
*/
#define IMPL_RTL_IS_USTRING 1
#define IMPL_RTL_STRCODE sal_Unicode
#define IMPL_RTL_USTRCODE( c ) (c)
#define IMPL_RTL_STRNAME( n ) rtl_ustr_ ## n
#define IMPL_RTL_STRINGNAME( n ) rtl_uString_ ## n
#define IMPL_RTL_STRINGDATA rtl_uString
#define IMPL_RTL_EMPTYSTRING aImplEmpty_rtl_uString
static void internRelease (rtl_uString *pThis);
#if USE_SDT_PROBES
#define RTL_LOG_STRING_BITS 16
#endif
/* ======================================================================= */
/* Include String/UString template code */
#include "strtmpl.cxx"
#undef IMPL_RTL_EMPTYSTRING
#undef IMPL_RTL_IS_USTRING
#undef IMPL_RTL_STRCODE
#undef IMPL_RTL_STRINGDATA
#undef IMPL_RTL_STRINGNAME
#undef IMPL_RTL_STRNAME
#undef IMPL_RTL_USTRCODE
#undef RTL_LOG_STRING_BITS
sal_Int32 rtl_ustr_indexOfAscii_WithLength(
sal_Unicode const * str, sal_Int32 len,
char const * subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
{
assert(len >= 0);
assert(subLen >= 0);
if (subLen > 0 && subLen <= len)
{
sal_Unicode const* end = str + len;
sal_Unicode const* cursor = str;
while(cursor < end)
{
cursor = std::char_traits<sal_Unicode>::find(cursor, end - cursor, *subStr);
if(!cursor || (end - cursor < subLen))
{
/* no enough left to actually have a match */
break;
}
/* now it is worth trying a full match */
if (rtl_ustr_asciil_reverseEquals_WithLength(cursor, subStr, subLen))
{
return cursor - str;
}
cursor += 1;
}
}
return -1;
}
sal_Int32 rtl_ustr_lastIndexOfAscii_WithLength(
sal_Unicode const * str, sal_Int32 len,
char const * subStr, sal_Int32 subLen) SAL_THROW_EXTERN_C()
{
assert(len >= 0);
assert(subLen >= 0);
if (subLen > 0 && subLen <= len) {
sal_Int32 i;
for (i = len - subLen; i >= 0; --i) {
if (rtl_ustr_asciil_reverseEquals_WithLength(
str + i, subStr, subLen))
{
return i;
}
}
}
return -1;
}
sal_Int32 SAL_CALL rtl_ustr_valueOfFloat(sal_Unicode * pStr, float f)
SAL_THROW_EXTERN_C()
{
assert(pStr);
rtl_uString * pResult = nullptr;
sal_Int32 nLen;
rtl_math_doubleToUString(
&pResult, nullptr, 0, f, rtl_math_StringFormat_G,
RTL_USTR_MAX_VALUEOFFLOAT - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', nullptr,
0, true);
nLen = pResult->length;
OSL_ASSERT(nLen < RTL_USTR_MAX_VALUEOFFLOAT);
memcpy(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Unicode));
rtl_uString_release(pResult);
return nLen;
}
sal_Int32 SAL_CALL rtl_ustr_valueOfDouble(sal_Unicode * pStr, double d)
SAL_THROW_EXTERN_C()
{
assert(pStr);
rtl_uString * pResult = nullptr;
sal_Int32 nLen;
rtl_math_doubleToUString(
&pResult, nullptr, 0, d, rtl_math_StringFormat_G,
RTL_USTR_MAX_VALUEOFDOUBLE - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', nullptr,
0, true);
nLen = pResult->length;
OSL_ASSERT(nLen < RTL_USTR_MAX_VALUEOFDOUBLE);
memcpy(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Unicode));
rtl_uString_release(pResult);
return nLen;
}
namespace {
// Avoid -fsanitize=undefined warning e.g. "runtime error: value 1e+99 is
// outside the range of representable values of type 'float'":
float doubleToFloat(double x) {
return
x < -std::numeric_limits<float>::max()
? -std::numeric_limits<float>::infinity()
: x > std::numeric_limits<float>::max()
? std::numeric_limits<float>::infinity()
: static_cast<float>(x);
}
}
float SAL_CALL rtl_ustr_toFloat(sal_Unicode const * pStr) SAL_THROW_EXTERN_C()
{
assert(pStr);
return doubleToFloat(rtl_math_uStringToDouble(pStr,
pStr + rtl_ustr_getLength(pStr),
'.', 0, nullptr, nullptr));
}
double SAL_CALL rtl_ustr_toDouble(sal_Unicode const * pStr) SAL_THROW_EXTERN_C()
{
assert(pStr);
return rtl_math_uStringToDouble(pStr, pStr + rtl_ustr_getLength(pStr), '.',
0, nullptr, nullptr);
}
/* ======================================================================= */
sal_Int32 SAL_CALL rtl_ustr_ascii_compare( const sal_Unicode* pStr1,
const sal_Char* pStr2 )
SAL_THROW_EXTERN_C()
{
assert(pStr1);
assert(pStr2);
sal_Int32 nRet;
while ( ((nRet = static_cast<sal_Int32>(*pStr1)-
static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2))) == 0) &&
*pStr2 )
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_ascii_compare - Found char > 127" );
pStr1++;
pStr2++;
}
return nRet;
}
/* ----------------------------------------------------------------------- */
sal_Int32 SAL_CALL rtl_ustr_ascii_compare_WithLength( const sal_Unicode* pStr1,
sal_Int32 nStr1Len,
const sal_Char* pStr2 )
SAL_THROW_EXTERN_C()
{
assert(pStr1);
assert(nStr1Len >= 0);
assert(pStr2);
sal_Int32 nRet = 0;
while( ((nRet = (nStr1Len ? static_cast<sal_Int32>(*pStr1) : 0)-
static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2))) == 0) &&
nStr1Len && *pStr2 )
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_ascii_compare_WithLength - Found char > 127" );
pStr1++;
pStr2++;
nStr1Len--;
}
return nRet;
}
/* ----------------------------------------------------------------------- */
sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompare_WithLength( const sal_Unicode* pStr1,
sal_Int32 nStr1Len,
const sal_Char* pStr2,
sal_Int32 nShortenedLength )
SAL_THROW_EXTERN_C()
{
assert(nStr1Len >= 0);
assert(nShortenedLength >= 0);
const sal_Unicode* pStr1End = pStr1 + nStr1Len;
sal_Int32 nRet;
while ( (nShortenedLength > 0) &&
(pStr1 < pStr1End) && *pStr2 )
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_ascii_shortenedCompare_WithLength - Found char > 127" );
nRet = static_cast<sal_Int32>(*pStr1)-
static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
if ( nRet != 0 )
return nRet;
nShortenedLength--;
pStr1++;
pStr2++;
}
if ( nShortenedLength <= 0 )
return 0;
if ( *pStr2 )
{
OSL_ENSURE( pStr1 == pStr1End, "pStr1 == pStr1End failed" );
// first is a substring of the second string => less (negative value)
nRet = -1;
}
else
{
// greater or equal
nRet = pStr1End - pStr1;
}
return nRet;
}
/* ----------------------------------------------------------------------- */
sal_Int32 SAL_CALL rtl_ustr_asciil_reverseCompare_WithLength( const sal_Unicode* pStr1,
sal_Int32 nStr1Len,
const sal_Char* pStr2,
sal_Int32 nStr2Len )
SAL_THROW_EXTERN_C()
{
assert(nStr1Len >= 0 && nStr2Len >= 0);
const sal_Unicode* pStr1Run = pStr1+nStr1Len;
const sal_Char* pStr2Run = pStr2+nStr2Len;
sal_Int32 nRet;
while ( (pStr1 < pStr1Run) && (pStr2 < pStr2Run) )
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_asciil_reverseCompare_WithLength - Found char > 127" );
pStr1Run--;
pStr2Run--;
nRet = static_cast<sal_Int32>(*pStr1Run)- static_cast<sal_Int32>(*pStr2Run);
if ( nRet )
return nRet;
}
return nStr1Len - nStr2Len;
}
/* ----------------------------------------------------------------------- */
sal_Bool SAL_CALL rtl_ustr_asciil_reverseEquals_WithLength( const sal_Unicode* pStr1,
const sal_Char* pStr2,
sal_Int32 nStrLen )
SAL_THROW_EXTERN_C()
{
assert(nStrLen >= 0);
const sal_Unicode* pStr1Run = pStr1+nStrLen;
const sal_Char* pStr2Run = pStr2+nStrLen;
while ( pStr1 < pStr1Run )
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_asciil_reverseEquals_WithLength - Found char > 127" );
pStr1Run--;
pStr2Run--;
if( *pStr1Run != static_cast<sal_Unicode>(*pStr2Run) )
return false;
}
return true;
}
/* ----------------------------------------------------------------------- */
sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase( const sal_Unicode* pStr1,
const sal_Char* pStr2 )
SAL_THROW_EXTERN_C()
{
assert(pStr1);
assert(pStr2);
sal_Int32 nRet;
sal_Int32 c1;
sal_Int32 c2;
do
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_ascii_compareIgnoreAsciiCase - Found char > 127" );
/* If character between 'A' and 'Z', than convert it to lowercase */
c1 = static_cast<sal_Int32>(*pStr1);
c2 = static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
if ( (c1 >= 65) && (c1 <= 90) )
c1 += 32;
if ( (c2 >= 65) && (c2 <= 90) )
c2 += 32;
nRet = c1-c2;
if ( nRet != 0 )
return nRet;
pStr1++;
pStr2++;
}
while ( c2 );
return 0;
}
/* ----------------------------------------------------------------------- */
sal_Int32 SAL_CALL rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( const sal_Unicode* pStr1,
sal_Int32 nStr1Len,
const sal_Char* pStr2 )
SAL_THROW_EXTERN_C()
{
assert(nStr1Len >= 0);
assert(pStr2);
sal_Int32 nRet;
sal_Int32 c1;
sal_Int32 c2;
do
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength - Found char > 127" );
if ( !nStr1Len )
return *pStr2 == '\0' ? 0 : -1;
/* If character between 'A' and 'Z', than convert it to lowercase */
c1 = static_cast<sal_Int32>(*pStr1);
c2 = static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
if ( (c1 >= 65) && (c1 <= 90) )
c1 += 32;
if ( (c2 >= 65) && (c2 <= 90) )
c2 += 32;
nRet = c1-c2;
if ( nRet != 0 )
return nRet;
pStr1++;
pStr2++;
nStr1Len--;
}
while( c2 );
return 0;
}
sal_Int32 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths(
sal_Unicode const * first, sal_Int32 firstLen,
char const * second, sal_Int32 secondLen) SAL_THROW_EXTERN_C()
{
assert(firstLen >= 0 && secondLen >= 0);
sal_Int32 i;
sal_Int32 len = std::min(firstLen, secondLen);
for (i = 0; i < len; ++i) {
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*second)) > 127, "rtl.string",
"rtl_ustr_ascii_compareIgnoreAsciiCase_WithLengths - Found char > 127" );
sal_Int32 c1 = *first++;
sal_Int32 c2 = static_cast<unsigned char>(*second++);
sal_Int32 d;
if (c1 >= 65 && c1 <= 90) {
c1 += 32;
}
if (c2 >= 65 && c2 <= 90) {
c2 += 32;
}
d = c1 - c2;
if (d != 0) {
return d;
}
}
return firstLen - secondLen;
}
/* ----------------------------------------------------------------------- */
sal_Int32 SAL_CALL rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( const sal_Unicode* pStr1,
sal_Int32 nStr1Len,
const sal_Char* pStr2,
sal_Int32 nShortenedLength )
SAL_THROW_EXTERN_C()
{
assert(nStr1Len >= 0);
assert(nShortenedLength >= 0);
const sal_Unicode* pStr1End = pStr1 + nStr1Len;
sal_Int32 nRet;
sal_Int32 c1;
sal_Int32 c2;
while ( (nShortenedLength > 0) &&
(pStr1 < pStr1End) && *pStr2 )
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(*pStr2)) > 127, "rtl.string",
"rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength - Found char > 127" );
/* If character between 'A' and 'Z', than convert it to lowercase */
c1 = static_cast<sal_Int32>(*pStr1);
c2 = static_cast<sal_Int32>(static_cast<unsigned char>(*pStr2));
if ( (c1 >= 65) && (c1 <= 90) )
c1 += 32;
if ( (c2 >= 65) && (c2 <= 90) )
c2 += 32;
nRet = c1-c2;
if ( nRet != 0 )
return nRet;
nShortenedLength--;
pStr1++;
pStr2++;
}
if ( nShortenedLength <= 0 )
return 0;
if ( *pStr2 )
{
OSL_ENSURE( pStr1 == pStr1End, "pStr1 == pStr1End failed" );
// first is a substring of the second string => less (negative value)
nRet = -1;
}
else
{
// greater or equal
nRet = pStr1End - pStr1;
}
return nRet;
}
/* ----------------------------------------------------------------------- */
void SAL_CALL rtl_uString_newFromAscii( rtl_uString** ppThis,
const sal_Char* pCharStr )
SAL_THROW_EXTERN_C()
{
assert(ppThis);
sal_Int32 nLen;
if ( pCharStr )
{
const sal_Char* pTempStr = pCharStr;
while( *pTempStr )
pTempStr++;
nLen = pTempStr-pCharStr;
}
else
nLen = 0;
if ( !nLen )
{
rtl_uString_new( ppThis );
return;
}
if ( *ppThis )
rtl_uString_release( *ppThis );
*ppThis = rtl_uString_ImplAlloc( nLen );
OSL_ASSERT(*ppThis != nullptr);
if ( *ppThis )
{
sal_Unicode* pBuffer = (*ppThis)->buffer;
do
{
assert(static_cast<unsigned char>(*pCharStr) < 0x80); // ASCII range
*pBuffer = *pCharStr;
pBuffer++;
pCharStr++;
}
while ( *pCharStr );
RTL_LOG_STRING_NEW( *ppThis );
}
}
void SAL_CALL rtl_uString_newFromCodePoints(
rtl_uString ** newString, sal_uInt32 const * codePoints,
sal_Int32 codePointCount) SAL_THROW_EXTERN_C()
{
sal_Int32 n;
sal_Int32 i;
sal_Unicode * p;
assert(newString != nullptr);
assert((codePoints != nullptr || codePointCount == 0) && codePointCount >= 0);
if (codePointCount == 0) {
rtl_uString_new(newString);
return;
}
if (*newString != nullptr) {
rtl_uString_release(*newString);
}
n = codePointCount;
for (i = 0; i < codePointCount; ++i) {
OSL_ASSERT(rtl::isUnicodeCodePoint(codePoints[i]));
if (codePoints[i] >= 0x10000) {
++n;
}
}
/* Builds on the assumption that sal_Int32 uses 32 bit two's complement
representation with wrap around (the necessary number of UTF-16 code
units will be no larger than 2 * SAL_MAX_INT32, represented as
sal_Int32 -2): */
if (n < 0) {
// coverity[dead_error_begin] - assumes wrap around
*newString = nullptr;
return;
}
*newString = rtl_uString_ImplAlloc(n);
if (*newString == nullptr) {
return;
}
p = (*newString)->buffer;
for (i = 0; i < codePointCount; ++i) {
p += rtl::splitSurrogates(codePoints[i], p);
}
RTL_LOG_STRING_NEW( *newString );
}
void rtl_uString_newConcatAsciiL(
rtl_uString ** newString, rtl_uString * left, char const * right,
sal_Int32 rightLength)
{
assert(newString != nullptr);
assert(left != nullptr);
assert(right != nullptr);
assert(rightLength >= 0);
if (left->length > std::numeric_limits<sal_Int32>::max() - rightLength) {
#if !defined(__COVERITY__)
throw std::length_error("rtl_uString_newConcatAsciiL");
#else
//coverity doesn't report std::bad_alloc as an unhandled exception when
//potentially thrown from destructors but does report std::length_error
throw std::bad_alloc();
#endif
}
sal_Int32 n = left->length + rightLength;
rtl_uString_assign(newString, left);
rtl_uString_ensureCapacity(newString, n);
sal_Unicode * p = (*newString)->buffer + (*newString)->length;
for (sal_Int32 i = 0; i != rightLength; ++i) {
p[i] = static_cast<unsigned char>(right[i]);
}
(*newString)->buffer[n] = 0;
(*newString)->length = n;
}
void rtl_uString_newConcatUtf16L(
rtl_uString ** newString, rtl_uString * left, sal_Unicode const * right,
sal_Int32 rightLength)
{
assert(newString != nullptr);
assert(left != nullptr);
assert(right != nullptr);
assert(rightLength >= 0);
if (left->length > std::numeric_limits<sal_Int32>::max() - rightLength) {
#if !defined(__COVERITY__)
throw std::length_error("rtl_uString_newConcatUtf16L");
#else
//coverity doesn't report std::bad_alloc as an unhandled exception when
//potentially thrown from destructors but does report std::length_error
throw std::bad_alloc();
#endif
}
sal_Int32 n = left->length + rightLength;
rtl_uString_assign(newString, left);
rtl_uString_ensureCapacity(newString, n);
memcpy(
(*newString)->buffer + (*newString)->length, right,
rightLength * sizeof (sal_Unicode));
(*newString)->buffer[n] = 0;
(*newString)->length = n;
}
/* ======================================================================= */
static int rtl_ImplGetFastUTF8UnicodeLen( const sal_Char* pStr, sal_Int32 nLen, bool * ascii )
{
int n;
const sal_Char* pEndStr;
*ascii = true;
n = 0;
pEndStr = pStr+nLen;
while ( pStr < pEndStr )
{
unsigned char c = static_cast<unsigned char>(*pStr);
if ( !(c & 0x80) )
pStr++;
else
{
if ( (c & 0xE0) == 0xC0 )
pStr += 2;
else if ( (c & 0xF0) == 0xE0 )
pStr += 3;
else if ( (c & 0xF8) == 0xF0 )
pStr += 4;
else if ( (c & 0xFC) == 0xF8 )
pStr += 5;
else if ( (c & 0xFE) == 0xFC )
pStr += 6;
else
pStr++;
*ascii = false;
}
n++;
}
return n;
}
/* ----------------------------------------------------------------------- */
static void rtl_string2UString_status( rtl_uString** ppThis,
const sal_Char* pStr,
sal_Int32 nLen,
rtl_TextEncoding eTextEncoding,
sal_uInt32 nCvtFlags,
sal_uInt32 *pInfo )
{
OSL_ENSURE(nLen == 0 || rtl_isOctetTextEncoding(eTextEncoding),
"rtl_string2UString_status() - Wrong TextEncoding" );
if ( !nLen )
{
rtl_uString_new( ppThis );
if (pInfo != nullptr) {
*pInfo = 0;
}
}
else
{
if ( *ppThis )
rtl_uString_release( *ppThis );
/* Optimization for US-ASCII */
if ( eTextEncoding == RTL_TEXTENCODING_ASCII_US )
{
sal_Unicode* pBuffer;
*ppThis = rtl_uString_ImplAlloc( nLen );
if (*ppThis == nullptr) {
if (pInfo != nullptr) {
*pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
}
return;
}
pBuffer = (*ppThis)->buffer;
sal_Int32 nLenCopy(nLen);
const sal_Char *pStrCopy(pStr);
do
{
/* Check ASCII range */
if (static_cast<unsigned char>(*pStrCopy) > 127)
{
rtl_uString_release(*ppThis);
goto retry; // cancel loop - try again with the converter
}
*pBuffer = *pStrCopy;
pBuffer++;
pStrCopy++;
nLenCopy--;
}
while (nLenCopy);
if (pInfo != nullptr) {
*pInfo = 0;
}
RTL_LOG_STRING_NEW( *ppThis );
return;
}
retry:
{
rtl_uString* pTemp;
rtl_uString* pTemp2 = nullptr;
rtl_TextToUnicodeConverter hConverter;
sal_uInt32 nInfo;
sal_Size nSrcBytes;
sal_Size nDestChars;
sal_Size nNewLen;
/* Optimization for UTF-8 - we try to calculate the exact length */
/* For all other encoding we try the maximum - and reallocate
the buffer if needed */
if ( eTextEncoding == RTL_TEXTENCODING_UTF8 )
{
bool ascii;
nNewLen = rtl_ImplGetFastUTF8UnicodeLen( pStr, nLen, &ascii );
/* Includes the string only ASCII, then we could copy
the buffer faster */
if ( ascii )
{
sal_Unicode* pBuffer;
*ppThis = rtl_uString_ImplAlloc( nLen );
if (*ppThis == nullptr)
{
if (pInfo != nullptr) {
*pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
}
return;
}
pBuffer = (*ppThis)->buffer;
do
{
assert((static_cast<unsigned char>(*pStr)) <= 127);
*pBuffer = *pStr;
pBuffer++;
pStr++;
nLen--;
}
while ( nLen );
if (pInfo != nullptr) {
*pInfo = 0;
}
RTL_LOG_STRING_NEW( *ppThis );
return;
}
}
else
nNewLen = nLen;
nCvtFlags |= RTL_TEXTTOUNICODE_FLAGS_FLUSH;
hConverter = rtl_createTextToUnicodeConverter( eTextEncoding );
pTemp = rtl_uString_ImplAlloc( nNewLen );
if (pTemp == nullptr) {
if (pInfo != nullptr) {
*pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
}
return;
}
nDestChars = rtl_convertTextToUnicode( hConverter, nullptr,
pStr, nLen,
pTemp->buffer, nNewLen,
nCvtFlags,
&nInfo, &nSrcBytes );
/* Buffer not big enough, try again with enough space */
/* Shouldn't be the case, but if we get textencoding which
could results in more unicode characters we have this
code here. Could be the case for apple encodings */
while ( nInfo & RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL )
{
rtl_freeString( pTemp );
nNewLen += 8;
pTemp = rtl_uString_ImplAlloc( nNewLen );
if (pTemp == nullptr) {
if (pInfo != nullptr) {
*pInfo = RTL_TEXTTOUNICODE_INFO_ERROR |
RTL_TEXTTOUNICODE_INFO_DESTBUFFERTOOSMALL;
}
return;
}
nDestChars = rtl_convertTextToUnicode( hConverter, nullptr,
pStr, nLen,
pTemp->buffer, nNewLen,
nCvtFlags,
&nInfo, &nSrcBytes );
}
if (pInfo)
*pInfo = nInfo;
/* Set the buffer to the correct size or if there is too
much overhead, reallocate to the correct size */
if ( nNewLen > nDestChars+8 )
{
pTemp2 = rtl_uString_ImplAlloc( nDestChars );
}
if (pTemp2 != nullptr)
{
rtl_str_ImplCopy(pTemp2->buffer, pTemp->buffer, nDestChars);
rtl_freeString(pTemp);
pTemp = pTemp2;
}
else
{
pTemp->length = nDestChars;
pTemp->buffer[nDestChars] = 0;
}
rtl_destroyTextToUnicodeConverter( hConverter );
*ppThis = pTemp;
/* Results the conversion in an empty buffer -
create an empty string */
if ( pTemp && !nDestChars )
rtl_uString_new( ppThis );
}
}
RTL_LOG_STRING_NEW( *ppThis );
}
void SAL_CALL rtl_string2UString( rtl_uString** ppThis,
const sal_Char* pStr,
sal_Int32 nLen,
rtl_TextEncoding eTextEncoding,
sal_uInt32 nCvtFlags ) SAL_THROW_EXTERN_C()
{
assert(ppThis);
assert(nLen >= 0);
rtl_string2UString_status( ppThis, pStr, nLen, eTextEncoding,
nCvtFlags, nullptr );
}
/* ----------------------------------------------------------------------- */
enum StrLifecycle {
CANNOT_RETURN,
CAN_RETURN = 1
};
static oslMutex
getInternMutex()
{
static oslMutex pPoolGuard = osl_createMutex();
return pPoolGuard;
}
/* returns true if we found a dup in the pool */
static void rtl_ustring_intern_internal( rtl_uString ** newStr,
rtl_uString * str,
StrLifecycle can_return )
{
oslMutex pPoolMutex;
pPoolMutex = getInternMutex();
osl_acquireMutex( pPoolMutex );
*newStr = rtl_str_hash_intern (str, can_return);
osl_releaseMutex( pPoolMutex );
RTL_LOG_STRING_INTERN_NEW(*newStr, str);
if( can_return && *newStr != str )
{ /* we dupped, then found a match */
rtl_freeString( str );
}
}
void SAL_CALL rtl_uString_intern( rtl_uString ** newStr,
rtl_uString * str) SAL_THROW_EXTERN_C()
{
assert(newStr);
assert(str);
if (SAL_STRING_IS_INTERN(str))
{
IMPL_RTL_ACQUIRE( str );
*newStr = str;
}
else
{
rtl_uString *pOrg = *newStr;
*newStr = nullptr;
rtl_ustring_intern_internal( newStr, str, CANNOT_RETURN );
if (pOrg)
rtl_uString_release (pOrg);
}
}
static int rtl_canGuessUOutputLength( int len, rtl_TextEncoding eTextEncoding )
{
// FIXME: Maybe we should use a bit flag in the higher bits of the
// eTextEncoding value itself to determine the encoding type. But if we
// do, be sure to mask the value in certain places that expect the values
// to be numbered serially from 0 and up. One such place is
// Impl_getTextEncodingData().
switch ( eTextEncoding )
{
// 1 to 1 (with no zero elements)
case RTL_TEXTENCODING_IBM_437:
case RTL_TEXTENCODING_IBM_850:
case RTL_TEXTENCODING_IBM_860:
case RTL_TEXTENCODING_IBM_861:
case RTL_TEXTENCODING_IBM_863:
case RTL_TEXTENCODING_IBM_865:
return len;
break;
}
return 0;
}
void SAL_CALL rtl_uString_internConvert( rtl_uString ** newStr,
const sal_Char * str,
sal_Int32 len,
rtl_TextEncoding eTextEncoding,
sal_uInt32 convertFlags,
sal_uInt32 * pInfo )
SAL_THROW_EXTERN_C()
{
assert(newStr);
assert(len >= 0);
rtl_uString *scratch;
if (*newStr)
{
rtl_uString_release (*newStr);
*newStr = nullptr;
}
if ( len < 256 )
{ // try various optimisations
sal_Int32 ulen;
if ( eTextEncoding == RTL_TEXTENCODING_ASCII_US )
{
int i;
rtl_uString *pScratch;
pScratch = static_cast< rtl_uString * >(
alloca(sizeof (rtl_uString) + len * sizeof (sal_Unicode)));
for (i = 0; i < len; i++)
{
/* Check ASCII range */
SAL_WARN_IF( (static_cast<unsigned char>(str[i])) > 127, "rtl.string",
"rtl_ustring_internConvert() - Found char > 127 and RTL_TEXTENCODING_ASCII_US is specified" );
pScratch->buffer[i] = str[i];
}
pScratch->length = len;
rtl_ustring_intern_internal( newStr, pScratch, CANNOT_RETURN );
return;
}
if ( (ulen = rtl_canGuessUOutputLength(len, eTextEncoding)) != 0 )
{
rtl_uString *pScratch;
rtl_TextToUnicodeConverter hConverter;
sal_Size nSrcBytes;
sal_uInt32 nInfo;
pScratch = static_cast< rtl_uString * >(
alloca(
sizeof (rtl_uString) + ulen * sizeof (sal_Unicode)));
hConverter = rtl_createTextToUnicodeConverter( eTextEncoding );
rtl_convertTextToUnicode(
hConverter, nullptr, str, len, pScratch->buffer, ulen, convertFlags, &nInfo, &nSrcBytes );
rtl_destroyTextToUnicodeConverter( hConverter );
if (pInfo)
*pInfo = nInfo;
pScratch->length = ulen;
rtl_ustring_intern_internal( newStr, pScratch, CANNOT_RETURN );
return;
}
/* FIXME: we want a nice UTF-8 / alloca shortcut here */
}
scratch = nullptr;
rtl_string2UString_status( &scratch, str, len, eTextEncoding, convertFlags,
pInfo );
if (!scratch) {
return;
}
rtl_ustring_intern_internal( newStr, scratch, CAN_RETURN );
}
static void
internRelease (rtl_uString *pThis)
{
oslMutex pPoolMutex;
rtl_uString *pFree = nullptr;
if ( SAL_STRING_REFCOUNT(
osl_atomic_decrement( &(pThis->refCount) ) ) == 0)
{
RTL_LOG_STRING_INTERN_DELETE(pThis);
pPoolMutex = getInternMutex();
osl_acquireMutex( pPoolMutex );
rtl_str_hash_remove (pThis);
/* May have been separately acquired */
if ( SAL_STRING_REFCOUNT(
osl_atomic_increment( &(pThis->refCount) ) ) == 1 )
{
/* we got the last ref */
pFree = pThis;
}
else /* very unusual */
{
internRelease (pThis);
}
osl_releaseMutex( pPoolMutex );
}
if (pFree)
rtl_freeString (pFree);
}
sal_uInt32 SAL_CALL rtl_uString_iterateCodePoints(
rtl_uString const * string, sal_Int32 * indexUtf16,
sal_Int32 incrementCodePoints)
{
sal_Int32 n;
sal_Unicode cu;
sal_uInt32 cp;
assert(string != nullptr && indexUtf16 != nullptr);
n = *indexUtf16;
assert(n >= 0 && n <= string->length);
while (incrementCodePoints < 0) {
assert(n > 0);
cu = string->buffer[--n];
if (rtl::isLowSurrogate(cu) && n != 0 &&
rtl::isHighSurrogate(string->buffer[n - 1]))
{
--n;
}
++incrementCodePoints;
}
assert(n >= 0 && n < string->length);
cu = string->buffer[n];
if (rtl::isHighSurrogate(cu) && string->length - n >= 2 &&
rtl::isLowSurrogate(string->buffer[n + 1]))
{
cp = rtl::combineSurrogates(cu, string->buffer[n + 1]);
} else {
cp = cu;
}
while (incrementCodePoints > 0) {
assert(n < string->length);
cu = string->buffer[n++];
if (rtl::isHighSurrogate(cu) && n != string->length &&
rtl::isLowSurrogate(string->buffer[n]))
{
++n;
}
--incrementCodePoints;
}
assert(n >= 0 && n <= string->length);
*indexUtf16 = n;
return cp;
}
sal_Bool rtl_convertStringToUString(
rtl_uString ** target, char const * source, sal_Int32 length,
rtl_TextEncoding encoding, sal_uInt32 flags) SAL_THROW_EXTERN_C()
{
assert(target);
assert(length >= 0);
sal_uInt32 info;
rtl_string2UString_status(target, source, length, encoding, flags, &info);
return (info & RTL_TEXTTOUNICODE_INFO_ERROR) == 0;
}
void rtl_uString_newReplaceFirst(
rtl_uString ** newStr, rtl_uString * str, rtl_uString const * from,
rtl_uString const * to, sal_Int32 * index) SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(from != nullptr);
assert(to != nullptr);
sal_Int32 i = rtl_ustr_indexOfStr_WithLength(
str->buffer + *index, str->length - *index, from->buffer, from->length);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(from->length <= str->length);
if (str->length - from->length > SAL_MAX_INT32 - to->length) {
std::abort();
}
sal_Int32 n = str->length - from->length + to->length;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i, to->buffer,
to->length * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i + to->length,
str->buffer + i + from->length,
(str->length - i - from->length) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
*index = i;
}
void rtl_uString_newReplaceFirstAsciiL(
rtl_uString ** newStr, rtl_uString * str, char const * from,
sal_Int32 fromLength, rtl_uString const * to, sal_Int32 * index)
SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(fromLength >= 0);
assert(to != nullptr);
sal_Int32 i = rtl_ustr_indexOfAscii_WithLength(
str->buffer + *index, str->length - *index, from, fromLength);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(fromLength <= str->length);
if (str->length - fromLength > SAL_MAX_INT32 - to->length) {
std::abort();
}
sal_Int32 n = str->length - fromLength + to->length;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i, to->buffer,
to->length * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i + to->length,
str->buffer + i + fromLength,
(str->length - i - fromLength) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
*index = i;
}
void rtl_uString_newReplaceFirstToAsciiL(
rtl_uString ** newStr, rtl_uString * str, rtl_uString const * from,
char const * to, sal_Int32 toLength, sal_Int32 * index)
SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(from != nullptr);
assert(toLength >= 0);
sal_Int32 i = rtl_ustr_indexOfStr_WithLength(
str->buffer + *index, str->length - *index, from->buffer, from->length);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(from->length <= str->length);
if (str->length - from->length > SAL_MAX_INT32 - toLength) {
std::abort();
}
sal_Int32 n = str->length - from->length + toLength;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
for (sal_Int32 j = 0; j != toLength; ++j) {
assert(static_cast< unsigned char >(to[j]) <= 0x7F);
(*newStr)->buffer[i + j] = to[j];
}
memcpy(
(*newStr)->buffer + i + toLength,
str->buffer + i + from->length,
(str->length - i - from->length) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
*index = i;
}
void rtl_uString_newReplaceFirstAsciiLAsciiL(
rtl_uString ** newStr, rtl_uString * str, char const * from,
sal_Int32 fromLength, char const * to, sal_Int32 toLength,
sal_Int32 * index) SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(fromLength >= 0);
assert(to != nullptr);
assert(toLength >= 0);
sal_Int32 i = rtl_ustr_indexOfAscii_WithLength(
str->buffer + *index, str->length - *index, from, fromLength);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(fromLength <= str->length);
if (str->length - fromLength > SAL_MAX_INT32 - toLength) {
std::abort();
}
sal_Int32 n = str->length - fromLength + toLength;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
for (sal_Int32 j = 0; j != toLength; ++j) {
assert(static_cast< unsigned char >(to[j]) <= 0x7F);
(*newStr)->buffer[i + j] = to[j];
}
memcpy(
(*newStr)->buffer + i + toLength,
str->buffer + i + fromLength,
(str->length - i - fromLength) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
*index = i;
}
void rtl_uString_newReplaceFirstAsciiLUtf16L(
rtl_uString ** newStr, rtl_uString * str, char const * from,
sal_Int32 fromLength, sal_Unicode const * to, sal_Int32 toLength,
sal_Int32 * index) SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(fromLength >= 0);
assert(to != nullptr);
assert(toLength >= 0);
sal_Int32 i = rtl_ustr_indexOfAscii_WithLength(
str->buffer + *index, str->length - *index, from, fromLength);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(fromLength <= str->length);
if (str->length - fromLength > SAL_MAX_INT32 - toLength) {
rtl_uString_release(*newStr);
*newStr = nullptr;
} else {
sal_Int32 n = str->length - fromLength + toLength;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0 && /*TODO:*/ *newStr != nullptr) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i, to, toLength * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i + toLength,
str->buffer + i + fromLength,
(str->length - i - fromLength) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
}
*index = i;
}
void rtl_uString_newReplaceFirstUtf16LAsciiL(
rtl_uString ** newStr, rtl_uString * str, sal_Unicode const * from,
sal_Int32 fromLength, char const * to, sal_Int32 toLength,
sal_Int32 * index) SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(fromLength >= 0);
assert(to != nullptr);
assert(toLength >= 0);
sal_Int32 i = rtl_ustr_indexOfStr_WithLength(
str->buffer + *index, str->length - *index, from, fromLength);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(fromLength <= str->length);
if (str->length - fromLength > SAL_MAX_INT32 - toLength) {
rtl_uString_release(*newStr);
*newStr = nullptr;
} else {
sal_Int32 n = str->length - fromLength + toLength;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0 && /*TODO:*/ *newStr != nullptr) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
for (sal_Int32 j = 0; j != toLength; ++j) {
assert(static_cast< unsigned char >(to[j]) <= 0x7F);
(*newStr)->buffer[i + j] = to[j];
}
memcpy(
(*newStr)->buffer + i + toLength,
str->buffer + i + fromLength,
(str->length - i - fromLength) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
}
*index = i;
}
void rtl_uString_newReplaceFirstUtf16LUtf16L(
rtl_uString ** newStr, rtl_uString * str, sal_Unicode const * from,
sal_Int32 fromLength, sal_Unicode const * to, sal_Int32 toLength,
sal_Int32 * index) SAL_THROW_EXTERN_C()
{
assert(str != nullptr);
assert(index != nullptr);
assert(*index >= 0 && *index <= str->length);
assert(fromLength >= 0);
assert(to != nullptr);
assert(toLength >= 0);
sal_Int32 i = rtl_ustr_indexOfStr_WithLength(
str->buffer + *index, str->length - *index, from, fromLength);
if (i == -1) {
rtl_uString_assign(newStr, str);
} else {
assert(i <= str->length - *index);
i += *index;
assert(fromLength <= str->length);
if (str->length - fromLength > SAL_MAX_INT32 - toLength) {
rtl_uString_release(*newStr);
*newStr = nullptr;
} else {
sal_Int32 n = str->length - fromLength + toLength;
rtl_uString_acquire(str); // in case *newStr == str
rtl_uString_new_WithLength(newStr, n);
if (n != 0 && /*TODO:*/ *newStr != nullptr) {
(*newStr)->length = n;
assert(i >= 0 && i < str->length);
memcpy(
(*newStr)->buffer, str->buffer, i * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i, to, toLength * sizeof (sal_Unicode));
memcpy(
(*newStr)->buffer + i + toLength,
str->buffer + i + fromLength,
(str->length - i - fromLength) * sizeof (sal_Unicode));
}
rtl_uString_release(str);
}
}
*index = i;
}
void rtl_uString_newReplaceAll(
rtl_uString ** newStr, rtl_uString * str, rtl_uString const * from,
rtl_uString const * to) SAL_THROW_EXTERN_C()
{
rtl_uString_newReplaceAllFromIndex( newStr, str, from, to, 0 );
}
void rtl_uString_newReplaceAllFromIndex(
rtl_uString ** newStr, rtl_uString * str, rtl_uString const * from,
rtl_uString const * to, sal_Int32 fromIndex) SAL_THROW_EXTERN_C()
{
assert(to != nullptr);
assert(fromIndex >= 0 && fromIndex <= str->length);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = fromIndex;; i += to->length) {
rtl_uString_newReplaceFirst(newStr, *newStr, from, to, &i);
if (i == -1) {
break;
}
}
}
void rtl_uString_newReplaceAllAsciiL(
rtl_uString ** newStr, rtl_uString * str, char const * from,
sal_Int32 fromLength, rtl_uString const * to) SAL_THROW_EXTERN_C()
{
assert(to != nullptr);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = 0;; i += to->length) {
rtl_uString_newReplaceFirstAsciiL(
newStr, *newStr, from, fromLength, to, &i);
if (i == -1) {
break;
}
}
}
void rtl_uString_newReplaceAllToAsciiL(
rtl_uString ** newStr, rtl_uString * str, rtl_uString const * from,
char const * to, sal_Int32 toLength) SAL_THROW_EXTERN_C()
{
assert(from != nullptr);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = 0;; i += toLength) {
rtl_uString_newReplaceFirstToAsciiL(
newStr, *newStr, from, to, toLength, &i);
if (i == -1) {
break;
}
}
}
void rtl_uString_newReplaceAllAsciiLAsciiL(
rtl_uString ** newStr, rtl_uString * str, char const * from,
sal_Int32 fromLength, char const * to, sal_Int32 toLength)
SAL_THROW_EXTERN_C()
{
assert(toLength >= 0);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = 0;; i += toLength) {
rtl_uString_newReplaceFirstAsciiLAsciiL(
newStr, *newStr, from, fromLength, to, toLength, &i);
if (i == -1) {
break;
}
}
}
void rtl_uString_newReplaceAllAsciiLUtf16L(
rtl_uString ** newStr, rtl_uString * str, char const * from,
sal_Int32 fromLength, sal_Unicode const * to, sal_Int32 toLength)
SAL_THROW_EXTERN_C()
{
assert(toLength >= 0);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = 0;; i += toLength) {
rtl_uString_newReplaceFirstAsciiLUtf16L(
newStr, *newStr, from, fromLength, to, toLength, &i);
if (i == -1 || *newStr == nullptr) {
break;
}
}
}
void rtl_uString_newReplaceAllUtf16LAsciiL(
rtl_uString ** newStr, rtl_uString * str, sal_Unicode const * from,
sal_Int32 fromLength, char const * to, sal_Int32 toLength)
SAL_THROW_EXTERN_C()
{
assert(toLength >= 0);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = 0;; i += toLength) {
rtl_uString_newReplaceFirstUtf16LAsciiL(
newStr, *newStr, from, fromLength, to, toLength, &i);
if (i == -1 || *newStr == nullptr) {
break;
}
}
}
void rtl_uString_newReplaceAllUtf16LUtf16L(
rtl_uString ** newStr, rtl_uString * str, sal_Unicode const * from,
sal_Int32 fromLength, sal_Unicode const * to, sal_Int32 toLength)
SAL_THROW_EXTERN_C()
{
assert(toLength >= 0);
rtl_uString_assign(newStr, str);
for (sal_Int32 i = 0;; i += toLength) {
rtl_uString_newReplaceFirstUtf16LUtf16L(
newStr, *newStr, from, fromLength, to, toLength, &i);
if (i == -1 || *newStr == nullptr) {
break;
}
}
}
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
↑ V595 The '* newStr' pointer was utilized before it was verified against nullptr. Check lines: 1547, 1548.
↑ V595 The '* newStr' pointer was utilized before it was verified against nullptr. Check lines: 1531, 1532.
↑ V595 The '* newStr' pointer was utilized before it was verified against nullptr. Check lines: 1515, 1516.