| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1999-2014, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: unistr_cnv.cpp |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:2 |
| * |
| * created on: 2004aug19 |
| * created by: Markus W. Scherer |
| * |
| * Character conversion functions moved here from unistr.cpp |
| */ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_CONVERSION |
| |
| #include "unicode/putil.h" |
| #include "cstring.h" |
| #include "cmemory.h" |
| #include "unicode/ustring.h" |
| #include "unicode/unistr.h" |
| #include "unicode/ucnv.h" |
| #include "ucnv_imp.h" |
| #include "putilimp.h" |
| #include "ustr_cnv.h" |
| #include "ustr_imp.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| //======================================== |
| // Constructors |
| //======================================== |
| |
| #if !U_CHARSET_IS_UTF8 |
| |
| UnicodeString::UnicodeString(const char *codepageData) { |
| fUnion.fFields.fLengthAndFlags = kShortString; |
| if(codepageData != 0) { |
| doCodepageCreate(codepageData, (int32_t)uprv_strlen(codepageData), 0); |
| } |
| } |
| |
| UnicodeString::UnicodeString(const char *codepageData, |
| int32_t dataLength) { |
| fUnion.fFields.fLengthAndFlags = kShortString; |
| if(codepageData != 0) { |
| doCodepageCreate(codepageData, dataLength, 0); |
| } |
| } |
| |
| // else see unistr.cpp |
| #endif |
| |
| UnicodeString::UnicodeString(const char *codepageData, |
| const char *codepage) { |
| fUnion.fFields.fLengthAndFlags = kShortString; |
| if(codepageData != 0) { |
| doCodepageCreate(codepageData, (int32_t)uprv_strlen(codepageData), codepage); |
| } |
| } |
| |
| UnicodeString::UnicodeString(const char *codepageData, |
| int32_t dataLength, |
| const char *codepage) { |
| fUnion.fFields.fLengthAndFlags = kShortString; |
| if(codepageData != 0) { |
| doCodepageCreate(codepageData, dataLength, codepage); |
| } |
| } |
| |
| UnicodeString::UnicodeString(const char *src, int32_t srcLength, |
| UConverter *cnv, |
| UErrorCode &errorCode) { |
| fUnion.fFields.fLengthAndFlags = kShortString; |
| if(U_SUCCESS(errorCode)) { |
| // check arguments |
| if(src==NULL) { |
| // treat as an empty string, do nothing more |
| } else if(srcLength<-1) { |
| errorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| } else { |
| // get input length |
| if(srcLength==-1) { |
| srcLength=(int32_t)uprv_strlen(src); |
| } |
| if(srcLength>0) { |
| if(cnv!=0) { |
| // use the provided converter |
| ucnv_resetToUnicode(cnv); |
| doCodepageCreate(src, srcLength, cnv, errorCode); |
| } else { |
| // use the default converter |
| cnv=u_getDefaultConverter(&errorCode); |
| doCodepageCreate(src, srcLength, cnv, errorCode); |
| u_releaseDefaultConverter(cnv); |
| } |
| } |
| } |
| |
| if(U_FAILURE(errorCode)) { |
| setToBogus(); |
| } |
| } |
| } |
| |
| //======================================== |
| // Codeset conversion |
| //======================================== |
| |
| #if !U_CHARSET_IS_UTF8 |
| |
| int32_t |
| UnicodeString::extract(int32_t start, |
| int32_t length, |
| char *target, |
| uint32_t dstSize) const { |
| return extract(start, length, target, dstSize, 0); |
| } |
| |
| // else see unistr.cpp |
| #endif |
| |
| int32_t |
| UnicodeString::extract(int32_t start, |
| int32_t length, |
| char *target, |
| uint32_t dstSize, |
| const char *codepage) const |
| { |
| // if the arguments are illegal, then do nothing |
| if(/*dstSize < 0 || */(dstSize > 0 && target == 0)) { |
| return 0; |
| } |
| |
| // pin the indices to legal values |
| pinIndices(start, length); |
| |
| // We need to cast dstSize to int32_t for all subsequent code. |
| // I don't know why the API was defined with uint32_t but we are stuck with it. |
| // Also, dstSize==0xffffffff means "unlimited" but if we use target+dstSize |
| // as a limit in some functions, it may wrap around and yield a pointer |
| // that compares less-than target. |
| int32_t capacity; |
| if(dstSize < 0x7fffffff) { |
| // Assume that the capacity is real and a limit pointer won't wrap around. |
| capacity = (int32_t)dstSize; |
| } else { |
| // Pin the capacity so that a limit pointer does not wrap around. |
| char *targetLimit = (char *)U_MAX_PTR(target); |
| // U_MAX_PTR(target) returns a targetLimit that is at most 0x7fffffff |
| // greater than target and does not wrap around the top of the address space. |
| capacity = (int32_t)(targetLimit - target); |
| } |
| |
| // create the converter |
| UConverter *converter; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| // just write the NUL if the string length is 0 |
| if(length == 0) { |
| return u_terminateChars(target, capacity, 0, &status); |
| } |
| |
| // if the codepage is the default, use our cache |
| // if it is an empty string, then use the "invariant character" conversion |
| if (codepage == 0) { |
| const char *defaultName = ucnv_getDefaultName(); |
| if(UCNV_FAST_IS_UTF8(defaultName)) { |
| return toUTF8(start, length, target, capacity); |
| } |
| converter = u_getDefaultConverter(&status); |
| } else if (*codepage == 0) { |
| // use the "invariant characters" conversion |
| int32_t destLength; |
| if(length <= capacity) { |
| destLength = length; |
| } else { |
| destLength = capacity; |
| } |
| u_UCharsToChars(getArrayStart() + start, target, destLength); |
| return u_terminateChars(target, capacity, length, &status); |
| } else { |
| converter = ucnv_open(codepage, &status); |
| } |
| |
| length = doExtract(start, length, target, capacity, converter, status); |
| |
| // close the converter |
| if (codepage == 0) { |
| u_releaseDefaultConverter(converter); |
| } else { |
| ucnv_close(converter); |
| } |
| |
| return length; |
| } |
| |
| int32_t |
| UnicodeString::extract(char *dest, int32_t destCapacity, |
| UConverter *cnv, |
| UErrorCode &errorCode) const |
| { |
| if(U_FAILURE(errorCode)) { |
| return 0; |
| } |
| |
| if(isBogus() || destCapacity<0 || (destCapacity>0 && dest==0)) { |
| errorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| // nothing to do? |
| if(isEmpty()) { |
| return u_terminateChars(dest, destCapacity, 0, &errorCode); |
| } |
| |
| // get the converter |
| UBool isDefaultConverter; |
| if(cnv==0) { |
| isDefaultConverter=TRUE; |
| cnv=u_getDefaultConverter(&errorCode); |
| if(U_FAILURE(errorCode)) { |
| return 0; |
| } |
| } else { |
| isDefaultConverter=FALSE; |
| ucnv_resetFromUnicode(cnv); |
| } |
| |
| // convert |
| int32_t len=doExtract(0, length(), dest, destCapacity, cnv, errorCode); |
| |
| // release the converter |
| if(isDefaultConverter) { |
| u_releaseDefaultConverter(cnv); |
| } |
| |
| return len; |
| } |
| |
| int32_t |
| UnicodeString::doExtract(int32_t start, int32_t length, |
| char *dest, int32_t destCapacity, |
| UConverter *cnv, |
| UErrorCode &errorCode) const |
| { |
| if(U_FAILURE(errorCode)) { |
| if(destCapacity!=0) { |
| *dest=0; |
| } |
| return 0; |
| } |
| |
| const UChar *src=getArrayStart()+start, *srcLimit=src+length; |
| char *originalDest=dest; |
| const char *destLimit; |
| |
| if(destCapacity==0) { |
| destLimit=dest=0; |
| } else if(destCapacity==-1) { |
| // Pin the limit to U_MAX_PTR if the "magic" destCapacity is used. |
| destLimit=(char*)U_MAX_PTR(dest); |
| // for NUL-termination, translate into highest int32_t |
| destCapacity=0x7fffffff; |
| } else { |
| destLimit=dest+destCapacity; |
| } |
| |
| // perform the conversion |
| ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, &errorCode); |
| length=(int32_t)(dest-originalDest); |
| |
| // if an overflow occurs, then get the preflighting length |
| if(errorCode==U_BUFFER_OVERFLOW_ERROR) { |
| char buffer[1024]; |
| |
| destLimit=buffer+sizeof(buffer); |
| do { |
| dest=buffer; |
| errorCode=U_ZERO_ERROR; |
| ucnv_fromUnicode(cnv, &dest, destLimit, &src, srcLimit, 0, TRUE, &errorCode); |
| length+=(int32_t)(dest-buffer); |
| } while(errorCode==U_BUFFER_OVERFLOW_ERROR); |
| } |
| |
| return u_terminateChars(originalDest, destCapacity, length, &errorCode); |
| } |
| |
| void |
| UnicodeString::doCodepageCreate(const char *codepageData, |
| int32_t dataLength, |
| const char *codepage) |
| { |
| // if there's nothing to convert, do nothing |
| if(codepageData == 0 || dataLength == 0 || dataLength < -1) { |
| return; |
| } |
| if(dataLength == -1) { |
| dataLength = (int32_t)uprv_strlen(codepageData); |
| } |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| // create the converter |
| // if the codepage is the default, use our cache |
| // if it is an empty string, then use the "invariant character" conversion |
| UConverter *converter; |
| if (codepage == 0) { |
| const char *defaultName = ucnv_getDefaultName(); |
| if(UCNV_FAST_IS_UTF8(defaultName)) { |
| setToUTF8(StringPiece(codepageData, dataLength)); |
| return; |
| } |
| converter = u_getDefaultConverter(&status); |
| } else if(*codepage == 0) { |
| // use the "invariant characters" conversion |
| if(cloneArrayIfNeeded(dataLength, dataLength, FALSE)) { |
| u_charsToUChars(codepageData, getArrayStart(), dataLength); |
| setLength(dataLength); |
| } else { |
| setToBogus(); |
| } |
| return; |
| } else { |
| converter = ucnv_open(codepage, &status); |
| } |
| |
| // if we failed, set the appropriate flags and return |
| if(U_FAILURE(status)) { |
| setToBogus(); |
| return; |
| } |
| |
| // perform the conversion |
| doCodepageCreate(codepageData, dataLength, converter, status); |
| if(U_FAILURE(status)) { |
| setToBogus(); |
| } |
| |
| // close the converter |
| if(codepage == 0) { |
| u_releaseDefaultConverter(converter); |
| } else { |
| ucnv_close(converter); |
| } |
| } |
| |
| void |
| UnicodeString::doCodepageCreate(const char *codepageData, |
| int32_t dataLength, |
| UConverter *converter, |
| UErrorCode &status) |
| { |
| if(U_FAILURE(status)) { |
| return; |
| } |
| |
| // set up the conversion parameters |
| const char *mySource = codepageData; |
| const char *mySourceEnd = mySource + dataLength; |
| UChar *array, *myTarget; |
| |
| // estimate the size needed: |
| int32_t arraySize; |
| if(dataLength <= US_STACKBUF_SIZE) { |
| // try to use the stack buffer |
| arraySize = US_STACKBUF_SIZE; |
| } else { |
| // 1.25 UChar's per source byte should cover most cases |
| arraySize = dataLength + (dataLength >> 2); |
| } |
| |
| // we do not care about the current contents |
| UBool doCopyArray = FALSE; |
| for(;;) { |
| if(!cloneArrayIfNeeded(arraySize, arraySize, doCopyArray)) { |
| setToBogus(); |
| break; |
| } |
| |
| // perform the conversion |
| array = getArrayStart(); |
| myTarget = array + length(); |
| ucnv_toUnicode(converter, &myTarget, array + getCapacity(), |
| &mySource, mySourceEnd, 0, TRUE, &status); |
| |
| // update the conversion parameters |
| setLength((int32_t)(myTarget - array)); |
| |
| // allocate more space and copy data, if needed |
| if(status == U_BUFFER_OVERFLOW_ERROR) { |
| // reset the error code |
| status = U_ZERO_ERROR; |
| |
| // keep the previous conversion results |
| doCopyArray = TRUE; |
| |
| // estimate the new size needed, larger than before |
| // try 2 UChar's per remaining source byte |
| arraySize = (int32_t)(length() + 2 * (mySourceEnd - mySource)); |
| } else { |
| break; |
| } |
| } |
| } |
| |
| U_NAMESPACE_END |
| |
| #endif |
