| /************************************************************** |
| * |
| * 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 <rtl/memory.h> |
| #include <osl/interlck.h> |
| #include <rtl/alloc.h> |
| #include <osl/diagnose.h> |
| #include <rtl/tencinfo.h> |
| |
| #include "strimp.h" |
| #include "surrogates.h" |
| #include <rtl/string.h> |
| |
| #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); |
| } |
