/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ #if defined(_MSC_VER) && (_MSC_VER >= 1400) #pragma warning(disable:4738) // storing 32-bit float result in memory, possible loss of performance #endif #include #include #include #include #include #include "strimp.h" #include "surrogates.h" #include #include "rtl/math.h" #include "rtl/tencinfo.h" /* ======================================================================= */ /* static data to be referenced by all empty strings * the refCount is predefined to 1 and must never become 0 ! */ static rtl_String const aImplEmpty_rtl_String = { SAL_STRING_STATIC_FLAG|1, /* sal_Int32 refCount; */ 0, /* sal_Int32 length; */ { 0 } /* sal_Char buffer[1]; */ }; /* ======================================================================= */ #define IMPL_RTL_STRCODE sal_Char #define IMPL_RTL_USTRCODE( c ) ((unsigned char)c) #define IMPL_RTL_STRNAME( n ) rtl_str_ ## n #define IMPL_RTL_STRINGNAME( n ) rtl_string_ ## n #define IMPL_RTL_STRINGDATA rtl_String #define IMPL_RTL_EMPTYSTRING aImplEmpty_rtl_String /* ======================================================================= */ /* Include String/UString template code */ #include "strtmpl.c" sal_Int32 SAL_CALL rtl_str_valueOfFloat(sal_Char * pStr, float f) { rtl_String * pResult = NULL; sal_Int32 nLen; rtl_math_doubleToString( &pResult, 0, 0, f, rtl_math_StringFormat_G, RTL_STR_MAX_VALUEOFFLOAT - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', 0, 0, sal_True); nLen = pResult->length; OSL_ASSERT(nLen < RTL_STR_MAX_VALUEOFFLOAT); rtl_copyMemory(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Char)); rtl_string_release(pResult); return nLen; } sal_Int32 SAL_CALL rtl_str_valueOfDouble(sal_Char * pStr, double d) { rtl_String * pResult = NULL; sal_Int32 nLen; rtl_math_doubleToString( &pResult, 0, 0, d, rtl_math_StringFormat_G, RTL_STR_MAX_VALUEOFDOUBLE - RTL_CONSTASCII_LENGTH("-x.E-xxx"), '.', 0, 0, sal_True); nLen = pResult->length; OSL_ASSERT(nLen < RTL_STR_MAX_VALUEOFDOUBLE); rtl_copyMemory(pStr, pResult->buffer, (nLen + 1) * sizeof(sal_Char)); rtl_string_release(pResult); return nLen; } float SAL_CALL rtl_str_toFloat(sal_Char const * pStr) { return (float) rtl_math_stringToDouble(pStr, pStr + rtl_str_getLength(pStr), '.', 0, 0, 0); } double SAL_CALL rtl_str_toDouble(sal_Char const * pStr) { return rtl_math_stringToDouble(pStr, pStr + rtl_str_getLength(pStr), '.', 0, 0, 0); } /* ======================================================================= */ static int rtl_ImplGetFastUTF8ByteLen( const sal_Unicode* pStr, sal_Int32 nLen ) { int n; sal_Unicode c; sal_uInt32 nUCS4Char; const sal_Unicode* pEndStr; n = 0; pEndStr = pStr+nLen; while ( pStr < pEndStr ) { c = *pStr; if ( c < 0x80 ) n++; else if ( c < 0x800 ) n += 2; else { if ( !SAL_RTL_IS_HIGH_SURROGATE(c) ) n += 3; else { nUCS4Char = c; if ( pStr+1 < pEndStr ) { c = *(pStr+1); if ( SAL_RTL_IS_LOW_SURROGATE(c) ) { nUCS4Char = SAL_RTL_COMBINE_SURROGATES(nUCS4Char, c); pStr++; } } if ( nUCS4Char < 0x10000 ) n += 3; else if ( nUCS4Char < 0x200000 ) n += 4; else if ( nUCS4Char < 0x4000000 ) n += 5; else n += 6; } } pStr++; } return n; } /* ----------------------------------------------------------------------- */ sal_Bool SAL_CALL rtl_impl_convertUStringToString(rtl_String ** pTarget, sal_Unicode const * pSource, sal_Int32 nLength, rtl_TextEncoding nEncoding, sal_uInt32 nFlags, sal_Bool bCheckErrors) { OSL_ASSERT(pTarget != NULL && (pSource != NULL || nLength == 0) && nLength >= 0 && rtl_isOctetTextEncoding(nEncoding)); if ( !nLength ) rtl_string_new( pTarget ); else { rtl_String* pTemp; rtl_UnicodeToTextConverter hConverter; sal_uInt32 nInfo; sal_Size nSrcChars; sal_Size nDestBytes; sal_Size nNewLen; sal_Size nNotConvertedChars; sal_Size nMaxCharLen; /* Optimization for UTF-8 - we try to calculate the exact length */ /* For all other encoding we try an good estimation */ if ( nEncoding == RTL_TEXTENCODING_UTF8 ) { nNewLen = rtl_ImplGetFastUTF8ByteLen( pSource, nLength ); /* Includes the string only ASCII, then we could copy the buffer faster */ if ( nNewLen == (sal_Size)nLength ) { IMPL_RTL_STRCODE* pBuffer; if ( *pTarget ) IMPL_RTL_STRINGNAME( release )( *pTarget ); *pTarget = IMPL_RTL_STRINGNAME( ImplAlloc )( nLength ); OSL_ASSERT(*pTarget != NULL); pBuffer = (*pTarget)->buffer; do { /* Check ASCII range */ OSL_ENSURE( *pSource <= 127, "rtl_uString2String() - UTF8 test is encoding is wrong" ); *pBuffer = (IMPL_RTL_STRCODE)(unsigned char)*pSource; pBuffer++; pSource++; nLength--; } while ( nLength ); return sal_True; } nMaxCharLen = 4; } else { rtl_TextEncodingInfo aTextEncInfo; aTextEncInfo.StructSize = sizeof( aTextEncInfo ); if ( !rtl_getTextEncodingInfo( nEncoding, &aTextEncInfo ) ) { aTextEncInfo.AverageCharSize = 1; aTextEncInfo.MaximumCharSize = 8; } nNewLen = nLength*aTextEncInfo.AverageCharSize; nMaxCharLen = aTextEncInfo.MaximumCharSize; } nFlags |= RTL_UNICODETOTEXT_FLAGS_FLUSH; hConverter = rtl_createUnicodeToTextConverter( nEncoding ); for (;;) { pTemp = IMPL_RTL_STRINGNAME( ImplAlloc )( nNewLen ); OSL_ASSERT(pTemp != NULL); nDestBytes = rtl_convertUnicodeToText( hConverter, 0, pSource, nLength, pTemp->buffer, nNewLen, nFlags, &nInfo, &nSrcChars ); if (bCheckErrors && (nInfo & RTL_UNICODETOTEXT_INFO_ERROR) != 0) { rtl_freeMemory(pTemp); rtl_destroyUnicodeToTextConverter(hConverter); return sal_False; } if ((nInfo & RTL_UNICODETOTEXT_INFO_DESTBUFFERTOSMALL) == 0) break; /* Buffer not big enough, try again with enough space */ rtl_freeMemory( pTemp ); /* Try with the max. count of characters with additional overhead for replacing functionality */ nNotConvertedChars = nLength-nSrcChars; nNewLen = nDestBytes+(nNotConvertedChars*nMaxCharLen)+nNotConvertedChars+4; } /* Set the buffer to the correct size or is there to much overhead, reallocate to the correct size */ if ( nNewLen > nDestBytes+8 ) { rtl_String* pTemp2 = IMPL_RTL_STRINGNAME( ImplAlloc )( nDestBytes ); OSL_ASSERT(pTemp2 != NULL); rtl_str_ImplCopy( pTemp2->buffer, pTemp->buffer, nDestBytes ); rtl_freeMemory( pTemp ); pTemp = pTemp2; } else { pTemp->length = nDestBytes; pTemp->buffer[nDestBytes] = 0; } rtl_destroyUnicodeToTextConverter( hConverter ); if ( *pTarget ) IMPL_RTL_STRINGNAME( release )( *pTarget ); *pTarget = pTemp; /* Results the conversion in an empty buffer - create an empty string */ if ( pTemp && !nDestBytes ) rtl_string_new( pTarget ); } return sal_True; } void SAL_CALL rtl_uString2String( rtl_String** ppThis, const sal_Unicode* pUStr, sal_Int32 nULen, rtl_TextEncoding eTextEncoding, sal_uInt32 nCvtFlags ) { rtl_impl_convertUStringToString(ppThis, pUStr, nULen, eTextEncoding, nCvtFlags, sal_False); } sal_Bool SAL_CALL rtl_convertUStringToString(rtl_String ** pTarget, sal_Unicode const * pSource, sal_Int32 nLength, rtl_TextEncoding nEncoding, sal_uInt32 nFlags) { return rtl_impl_convertUStringToString(pTarget, pSource, nLength, nEncoding, nFlags, sal_True); }