418 lines
12 KiB
C++
418 lines
12 KiB
C++
|
// © 2016 and later: Unicode, Inc. and others.
|
||
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
||
|
|
/*
|
||
|
|
*******************************************************************************
|
||
|
|
*
|
||
|
|
* Copyright (C) 1999-2014, International Business Machines
|
||
|
|
* Corporation and others. All Rights Reserved.
|
||
|
|
*
|
||
|
|
*******************************************************************************
|
||
|
|
* file name: unistr_cnv.cpp
|
||
|
|
* encoding: UTF-8
|
||
|
|
* 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
|