1893 lines
48 KiB
C++
1893 lines
48 KiB
C++
/*
|
|
******************************************************************************
|
|
* Copyright (C) 1999-2003, International Business Machines Corporation and *
|
|
* others. All Rights Reserved. *
|
|
******************************************************************************
|
|
*
|
|
* File unistr.cpp
|
|
*
|
|
* Modification History:
|
|
*
|
|
* Date Name Description
|
|
* 09/25/98 stephen Creation.
|
|
* 04/20/99 stephen Overhauled per 4/16 code review.
|
|
* 07/09/99 stephen Renamed {hi,lo},{byte,word} to icu_X for HP/UX
|
|
* 11/18/99 aliu Added handleReplaceBetween() to make inherit from
|
|
* Replaceable.
|
|
* 06/25/01 grhoten Removed the dependency on iostream
|
|
******************************************************************************
|
|
*/
|
|
|
|
#include "unicode/utypes.h"
|
|
#include "unicode/putil.h"
|
|
#include "unicode/locid.h"
|
|
#include "cstring.h"
|
|
#include "cmemory.h"
|
|
#include "unicode/ustring.h"
|
|
#include "unicode/unistr.h"
|
|
#include "unicode/uchar.h"
|
|
#include "unicode/ucnv.h"
|
|
#include "unicode/ubrk.h"
|
|
#include "uhash.h"
|
|
#include "ustr_imp.h"
|
|
#include "unormimp.h"
|
|
#include "umutex.h"
|
|
|
|
#if 0
|
|
|
|
#if U_IOSTREAM_SOURCE >= 199711
|
|
#include <iostream>
|
|
using namespace std;
|
|
#elif U_IOSTREAM_SOURCE >= 198506
|
|
#include <iostream.h>
|
|
#endif
|
|
|
|
//DEBUGGING
|
|
void
|
|
print(const UnicodeString& s,
|
|
const char *name)
|
|
{
|
|
UChar c;
|
|
cout << name << ":|";
|
|
for(int i = 0; i < s.length(); ++i) {
|
|
c = s[i];
|
|
if(c>= 0x007E || c < 0x0020)
|
|
cout << "[0x" << hex << s[i] << "]";
|
|
else
|
|
cout << (char) s[i];
|
|
}
|
|
cout << '|' << endl;
|
|
}
|
|
|
|
void
|
|
print(const UChar *s,
|
|
int32_t len,
|
|
const char *name)
|
|
{
|
|
UChar c;
|
|
cout << name << ":|";
|
|
for(int i = 0; i < len; ++i) {
|
|
c = s[i];
|
|
if(c>= 0x007E || c < 0x0020)
|
|
cout << "[0x" << hex << s[i] << "]";
|
|
else
|
|
cout << (char) s[i];
|
|
}
|
|
cout << '|' << endl;
|
|
}
|
|
// END DEBUGGING
|
|
#endif
|
|
|
|
// Local function definitions for now
|
|
|
|
// need to copy areas that may overlap
|
|
static
|
|
inline void
|
|
us_arrayCopy(const UChar *src, int32_t srcStart,
|
|
UChar *dst, int32_t dstStart, int32_t count)
|
|
{
|
|
if(count>0) {
|
|
uprv_memmove(dst+dstStart, src+srcStart, (size_t)(count*sizeof(*src)));
|
|
}
|
|
}
|
|
|
|
// u_unescapeAt() callback to get a UChar from a UnicodeString
|
|
U_CDECL_BEGIN
|
|
static UChar U_CALLCONV
|
|
UnicodeString_charAt(int32_t offset, void *context) {
|
|
return ((UnicodeString*) context)->charAt(offset);
|
|
}
|
|
U_CDECL_END
|
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
/* The Replaceable virtual destructor can't be defined in the header
|
|
due to how AIX works with multiple definitions of virtual functions.
|
|
*/
|
|
Replaceable::~Replaceable() {}
|
|
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeString)
|
|
|
|
//========================================
|
|
// Reference Counting functions, put at top of file so that optimizing compilers
|
|
// have a chance to automatically inline.
|
|
//========================================
|
|
|
|
void
|
|
UnicodeString::addRef()
|
|
{ umtx_atomic_inc((int32_t *)fArray - 1);}
|
|
|
|
int32_t
|
|
UnicodeString::removeRef()
|
|
{ return umtx_atomic_dec((int32_t *)fArray - 1);}
|
|
|
|
int32_t
|
|
UnicodeString::refCount() const
|
|
{
|
|
umtx_lock(NULL);
|
|
// Note: without the lock to force a memory barrier, we might see a very
|
|
// stale value on some multi-processor systems.
|
|
int32_t count = *((int32_t *)fArray - 1);
|
|
umtx_unlock(NULL);
|
|
return count;
|
|
}
|
|
|
|
void
|
|
UnicodeString::releaseArray() {
|
|
if((fFlags & kRefCounted) && removeRef() == 0) {
|
|
uprv_free((int32_t *)fArray - 1);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//========================================
|
|
// Constructors
|
|
//========================================
|
|
UnicodeString::UnicodeString()
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{}
|
|
|
|
UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count)
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(0),
|
|
fFlags(0)
|
|
{
|
|
if(count <= 0 || (uint32_t)c > 0x10ffff) {
|
|
// just allocate and do not do anything else
|
|
allocate(capacity);
|
|
} else {
|
|
// count > 0, allocate and fill the new string with count c's
|
|
int32_t unitCount = UTF_CHAR_LENGTH(c), length = count * unitCount;
|
|
if(capacity < length) {
|
|
capacity = length;
|
|
}
|
|
if(allocate(capacity)) {
|
|
int32_t i = 0;
|
|
|
|
// fill the new string with c
|
|
if(unitCount == 1) {
|
|
// fill with length UChars
|
|
while(i < length) {
|
|
fArray[i++] = (UChar)c;
|
|
}
|
|
} else {
|
|
// get the code units for c
|
|
UChar units[UTF_MAX_CHAR_LENGTH];
|
|
UTF_APPEND_CHAR_UNSAFE(units, i, c);
|
|
|
|
// now it must be i==unitCount
|
|
i = 0;
|
|
|
|
// for Unicode, unitCount can only be 1, 2, 3, or 4
|
|
// 1 is handled above
|
|
while(i < length) {
|
|
int32_t unitIdx = 0;
|
|
while(unitIdx < unitCount) {
|
|
fArray[i++]=units[unitIdx++];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
fLength = length;
|
|
}
|
|
}
|
|
|
|
UnicodeString::UnicodeString(UChar ch)
|
|
: fLength(1),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
fStackBuffer[0] = ch;
|
|
}
|
|
|
|
UnicodeString::UnicodeString(UChar32 ch)
|
|
: fLength(1),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
int32_t i = 0;
|
|
UBool isError = FALSE;
|
|
U16_APPEND(fStackBuffer, i, US_STACKBUF_SIZE, ch, isError);
|
|
fLength = i;
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const UChar *text)
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
doReplace(0, 0, text, 0, -1);
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const UChar *text,
|
|
int32_t textLength)
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
doReplace(0, 0, text, 0, textLength);
|
|
}
|
|
|
|
UnicodeString::UnicodeString(UBool isTerminated,
|
|
const UChar *text,
|
|
int32_t textLength)
|
|
: fLength(textLength),
|
|
fCapacity(isTerminated ? textLength + 1 : textLength),
|
|
fArray((UChar *)text),
|
|
fFlags(kReadonlyAlias)
|
|
{
|
|
if(text == NULL) {
|
|
// treat as an empty string, do not alias
|
|
fLength = 0;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fArray = fStackBuffer;
|
|
fFlags = kShortString;
|
|
} else if(textLength < -1 ||
|
|
(textLength == -1 && !isTerminated) ||
|
|
(textLength >= 0 && isTerminated && text[textLength] != 0)
|
|
) {
|
|
setToBogus();
|
|
} else if(textLength == -1) {
|
|
// text is terminated, or else it would have failed the above test
|
|
fLength = u_strlen(text);
|
|
fCapacity = fLength + 1;
|
|
}
|
|
}
|
|
|
|
UnicodeString::UnicodeString(UChar *buff,
|
|
int32_t buffLength,
|
|
int32_t buffCapacity)
|
|
: fLength(buffLength),
|
|
fCapacity(buffCapacity),
|
|
fArray(buff),
|
|
fFlags(kWritableAlias)
|
|
{
|
|
if(buff == NULL) {
|
|
// treat as an empty string, do not alias
|
|
fLength = 0;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fArray = fStackBuffer;
|
|
fFlags = kShortString;
|
|
} else if(buffLength < -1 || buffCapacity < 0 || buffLength > buffCapacity) {
|
|
setToBogus();
|
|
} else if(buffLength == -1) {
|
|
// fLength = u_strlen(buff); but do not look beyond buffCapacity
|
|
const UChar *p = buff, *limit = buff + buffCapacity;
|
|
while(p != limit && *p != 0) {
|
|
++p;
|
|
}
|
|
fLength = (int32_t)(p - buff);
|
|
}
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const char *codepageData,
|
|
const char *codepage)
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
if(codepageData != 0) {
|
|
doCodepageCreate(codepageData, (int32_t)uprv_strlen(codepageData), codepage);
|
|
}
|
|
}
|
|
|
|
|
|
UnicodeString::UnicodeString(const char *codepageData,
|
|
int32_t dataLength,
|
|
const char *codepage)
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
if(codepageData != 0) {
|
|
doCodepageCreate(codepageData, dataLength, codepage);
|
|
}
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const char *src, int32_t srcLength,
|
|
UConverter *cnv,
|
|
UErrorCode &errorCode)
|
|
: fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(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();
|
|
}
|
|
}
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const UnicodeString& that)
|
|
: Replaceable(),
|
|
fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
copyFrom(that);
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const UnicodeString& that,
|
|
int32_t srcStart)
|
|
: Replaceable(),
|
|
fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
setTo(that, srcStart);
|
|
}
|
|
|
|
UnicodeString::UnicodeString(const UnicodeString& that,
|
|
int32_t srcStart,
|
|
int32_t srcLength)
|
|
: Replaceable(),
|
|
fLength(0),
|
|
fCapacity(US_STACKBUF_SIZE),
|
|
fArray(fStackBuffer),
|
|
fFlags(kShortString)
|
|
{
|
|
setTo(that, srcStart, srcLength);
|
|
}
|
|
|
|
// Replaceable base class clone() default implementation, does not clone
|
|
Replaceable *
|
|
Replaceable::clone() const {
|
|
return NULL;
|
|
}
|
|
|
|
// UnicodeString overrides clone() with a real implementation
|
|
Replaceable *
|
|
UnicodeString::clone() const {
|
|
return new UnicodeString(*this);
|
|
}
|
|
|
|
//========================================
|
|
// array allocation
|
|
//========================================
|
|
|
|
UBool
|
|
UnicodeString::allocate(int32_t capacity) {
|
|
if(capacity <= US_STACKBUF_SIZE) {
|
|
fArray = fStackBuffer;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fFlags = kShortString;
|
|
} else {
|
|
// count bytes for the refCounter and the string capacity, and
|
|
// round up to a multiple of 16; then divide by 4 and allocate int32_t's
|
|
// to be safely aligned for the refCount
|
|
int32_t words = (int32_t)(((sizeof(int32_t) + capacity * U_SIZEOF_UCHAR + 15) & ~15) >> 2);
|
|
int32_t *array = (int32_t*) uprv_malloc( sizeof(int32_t) * words );
|
|
if(array != 0) {
|
|
// set initial refCount and point behind the refCount
|
|
*array++ = 1;
|
|
|
|
// have fArray point to the first UChar
|
|
fArray = (UChar *)array;
|
|
fCapacity = (int32_t)((words - 1) * (sizeof(int32_t) / U_SIZEOF_UCHAR));
|
|
fFlags = kLongString;
|
|
} else {
|
|
fLength = 0;
|
|
fCapacity = 0;
|
|
fFlags = kIsBogus;
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//========================================
|
|
// Destructor
|
|
//========================================
|
|
UnicodeString::~UnicodeString()
|
|
{
|
|
releaseArray();
|
|
}
|
|
|
|
|
|
//========================================
|
|
// Assignment
|
|
//========================================
|
|
|
|
UnicodeString &
|
|
UnicodeString::operator=(const UnicodeString &src) {
|
|
return copyFrom(src);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::fastCopyFrom(const UnicodeString &src) {
|
|
return copyFrom(src, TRUE);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::copyFrom(const UnicodeString &src, UBool fastCopy) {
|
|
// if assigning to ourselves, do nothing
|
|
if(this == 0 || this == &src) {
|
|
return *this;
|
|
}
|
|
|
|
// is the right side bogus?
|
|
if(&src == 0 || src.isBogus()) {
|
|
setToBogus();
|
|
return *this;
|
|
}
|
|
|
|
// delete the current contents
|
|
releaseArray();
|
|
|
|
// we always copy the length
|
|
fLength = src.fLength;
|
|
if(fLength == 0) {
|
|
// empty string - use the stack buffer
|
|
fArray = fStackBuffer;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fFlags = kShortString;
|
|
return *this;
|
|
}
|
|
|
|
// fLength>0 and not an "open" src.getBuffer(minCapacity)
|
|
switch(src.fFlags) {
|
|
case kShortString:
|
|
// short string using the stack buffer, do the same
|
|
fArray = fStackBuffer;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fFlags = kShortString;
|
|
uprv_memcpy(fStackBuffer, src.fArray, fLength * U_SIZEOF_UCHAR);
|
|
break;
|
|
case kLongString:
|
|
// src uses a refCounted string buffer, use that buffer with refCount
|
|
// src is const, use a cast - we don't really change it
|
|
((UnicodeString &)src).addRef();
|
|
// copy all fields, share the reference-counted buffer
|
|
fArray = src.fArray;
|
|
fCapacity = src.fCapacity;
|
|
fFlags = src.fFlags;
|
|
break;
|
|
case kReadonlyAlias:
|
|
if(fastCopy) {
|
|
// src is a readonly alias, do the same
|
|
// -> maintain the readonly alias as such
|
|
fArray = src.fArray;
|
|
fCapacity = src.fCapacity;
|
|
fFlags = src.fFlags;
|
|
break;
|
|
}
|
|
// else if(!fastCopy) fall through to case kWritableAlias
|
|
// -> allocate a new buffer and copy the contents
|
|
case kWritableAlias:
|
|
// src is a writable alias; we make a copy of that instead
|
|
if(allocate(fLength)) {
|
|
uprv_memcpy(fArray, src.fArray, fLength * U_SIZEOF_UCHAR);
|
|
break;
|
|
}
|
|
// if there is not enough memory, then fall through to setting to bogus
|
|
default:
|
|
// if src is bogus, set ourselves to bogus
|
|
// do not call setToBogus() here because fArray and fFlags are not consistent here
|
|
fArray = 0;
|
|
fLength = 0;
|
|
fCapacity = 0;
|
|
fFlags = kIsBogus;
|
|
break;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
//========================================
|
|
// Miscellaneous operations
|
|
//========================================
|
|
|
|
UnicodeString UnicodeString::unescape() const {
|
|
UnicodeString result;
|
|
for (int32_t i=0; i<length(); ) {
|
|
UChar32 c = charAt(i++);
|
|
if (c == 0x005C /*'\\'*/) {
|
|
c = unescapeAt(i); // advances i
|
|
if (c == (UChar32)0xFFFFFFFF) {
|
|
result.remove(); // return empty string
|
|
break; // invalid escape sequence
|
|
}
|
|
}
|
|
result.append(c);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
UChar32 UnicodeString::unescapeAt(int32_t &offset) const {
|
|
return u_unescapeAt(UnicodeString_charAt, &offset, length(), (void*)this);
|
|
}
|
|
|
|
//========================================
|
|
// Read-only implementation
|
|
//========================================
|
|
int8_t
|
|
UnicodeString::doCompare( int32_t start,
|
|
int32_t length,
|
|
const UChar *srcChars,
|
|
int32_t srcStart,
|
|
int32_t srcLength) const
|
|
{
|
|
// compare illegal string values
|
|
// treat const UChar *srcChars==NULL as an empty string
|
|
if(isBogus()) {
|
|
return -1;
|
|
}
|
|
|
|
// pin indices to legal values
|
|
pinIndices(start, length);
|
|
|
|
if(srcChars == NULL) {
|
|
srcStart = srcLength = 0;
|
|
}
|
|
|
|
// get the correct pointer
|
|
const UChar *chars = getArrayStart();
|
|
|
|
chars += start;
|
|
srcChars += srcStart;
|
|
|
|
int32_t minLength;
|
|
int8_t lengthResult;
|
|
|
|
// get the srcLength if necessary
|
|
if(srcLength < 0) {
|
|
srcLength = u_strlen(srcChars + srcStart);
|
|
}
|
|
|
|
// are we comparing different lengths?
|
|
if(length != srcLength) {
|
|
if(length < srcLength) {
|
|
minLength = length;
|
|
lengthResult = -1;
|
|
} else {
|
|
minLength = srcLength;
|
|
lengthResult = 1;
|
|
}
|
|
} else {
|
|
minLength = length;
|
|
lengthResult = 0;
|
|
}
|
|
|
|
/*
|
|
* note that uprv_memcmp() returns an int but we return an int8_t;
|
|
* we need to take care not to truncate the result -
|
|
* one way to do this is to right-shift the value to
|
|
* move the sign bit into the lower 8 bits and making sure that this
|
|
* does not become 0 itself
|
|
*/
|
|
|
|
if(minLength > 0 && chars != srcChars) {
|
|
int32_t result;
|
|
|
|
# if U_IS_BIG_ENDIAN
|
|
// big-endian: byte comparison works
|
|
result = uprv_memcmp(chars, srcChars, minLength * sizeof(UChar));
|
|
if(result != 0) {
|
|
return (int8_t)(result >> 15 | 1);
|
|
}
|
|
# else
|
|
// little-endian: compare UChar units
|
|
do {
|
|
result = ((int32_t)*(chars++) - (int32_t)*(srcChars++));
|
|
if(result != 0) {
|
|
return (int8_t)(result >> 15 | 1);
|
|
}
|
|
} while(--minLength > 0);
|
|
# endif
|
|
}
|
|
return lengthResult;
|
|
}
|
|
|
|
/* String compare in code point order - doCompare() compares in code unit order. */
|
|
int8_t
|
|
UnicodeString::doCompareCodePointOrder(int32_t start,
|
|
int32_t length,
|
|
const UChar *srcChars,
|
|
int32_t srcStart,
|
|
int32_t srcLength) const
|
|
{
|
|
// compare illegal string values
|
|
// treat const UChar *srcChars==NULL as an empty string
|
|
if(isBogus()) {
|
|
return -1;
|
|
}
|
|
|
|
// pin indices to legal values
|
|
pinIndices(start, length);
|
|
|
|
if(srcChars == NULL) {
|
|
srcStart = srcLength = 0;
|
|
}
|
|
|
|
int32_t diff = uprv_strCompare(fArray + start, length, srcChars + srcStart, srcLength, FALSE, TRUE);
|
|
/* translate the 32-bit result into an 8-bit one */
|
|
if(diff!=0) {
|
|
return (int8_t)(diff >> 15 | 1);
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
int8_t
|
|
UnicodeString::doCaseCompare(int32_t start,
|
|
int32_t length,
|
|
const UChar *srcChars,
|
|
int32_t srcStart,
|
|
int32_t srcLength,
|
|
uint32_t options) const
|
|
{
|
|
// compare illegal string values
|
|
// treat const UChar *srcChars==NULL as an empty string
|
|
if(isBogus()) {
|
|
return -1;
|
|
}
|
|
|
|
// pin indices to legal values
|
|
pinIndices(start, length);
|
|
|
|
if(srcChars == NULL) {
|
|
srcStart = srcLength = 0;
|
|
}
|
|
|
|
// get the correct pointer
|
|
const UChar *chars = getArrayStart();
|
|
|
|
chars += start;
|
|
srcChars += srcStart;
|
|
|
|
if(chars != srcChars) {
|
|
UErrorCode errorCode=U_ZERO_ERROR;
|
|
int32_t result=unorm_cmpEquivFold(chars, length, srcChars, srcLength,
|
|
options|U_COMPARE_IGNORE_CASE, &errorCode);
|
|
if(result!=0) {
|
|
return (int8_t)(result >> 24 | 1);
|
|
}
|
|
} else {
|
|
// get the srcLength if necessary
|
|
if(srcLength < 0) {
|
|
srcLength = u_strlen(srcChars + srcStart);
|
|
}
|
|
if(length != srcLength) {
|
|
return (int8_t)((length - srcLength) >> 24 | 1);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::getLength() const {
|
|
return length();
|
|
}
|
|
|
|
UChar
|
|
UnicodeString::getCharAt(int32_t offset) const {
|
|
return charAt(offset);
|
|
}
|
|
|
|
UChar32
|
|
UnicodeString::getChar32At(int32_t offset) const {
|
|
return char32At(offset);
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::countChar32(int32_t start, int32_t length) const {
|
|
pinIndices(start, length);
|
|
// if(isBogus()) then fArray==0 and start==0 - u_countChar32() checks for NULL
|
|
return u_countChar32(fArray+start, length);
|
|
}
|
|
|
|
UBool
|
|
UnicodeString::hasMoreChar32Than(int32_t start, int32_t length, int32_t number) const {
|
|
pinIndices(start, length);
|
|
// if(isBogus()) then fArray==0 and start==0 - u_strHasMoreChar32Than() checks for NULL
|
|
return u_strHasMoreChar32Than(fArray+start, length, number);
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::moveIndex32(int32_t index, int32_t delta) const {
|
|
// pin index
|
|
if(index<0) {
|
|
index=0;
|
|
} else if(index>fLength) {
|
|
index=fLength;
|
|
}
|
|
|
|
if(delta>0) {
|
|
UTF_FWD_N(fArray, index, fLength, delta);
|
|
} else {
|
|
UTF_BACK_N(fArray, 0, index, -delta);
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
void
|
|
UnicodeString::doExtract(int32_t start,
|
|
int32_t length,
|
|
UChar *dst,
|
|
int32_t dstStart) const
|
|
{
|
|
// pin indices to legal values
|
|
pinIndices(start, length);
|
|
|
|
// do not copy anything if we alias dst itself
|
|
if(fArray + start != dst + dstStart) {
|
|
us_arrayCopy(getArrayStart(), start, dst, dstStart, length);
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::extract(UChar *dest, int32_t destCapacity,
|
|
UErrorCode &errorCode) const {
|
|
if(U_SUCCESS(errorCode)) {
|
|
if(isBogus() || destCapacity<0 || (destCapacity>0 && dest==0)) {
|
|
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
|
|
} else {
|
|
if(fLength>0 && fLength<=destCapacity && fArray!=dest) {
|
|
uprv_memcpy(dest, fArray, fLength*U_SIZEOF_UCHAR);
|
|
}
|
|
return u_terminateUChars(dest, destCapacity, fLength, &errorCode);
|
|
}
|
|
}
|
|
|
|
return fLength;
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::indexOf(const UChar *srcChars,
|
|
int32_t srcStart,
|
|
int32_t srcLength,
|
|
int32_t start,
|
|
int32_t length) const
|
|
{
|
|
if(isBogus() || srcChars == 0 || srcStart < 0 || srcLength == 0) {
|
|
return -1;
|
|
}
|
|
|
|
// UnicodeString does not find empty substrings
|
|
if(srcLength < 0 && srcChars[srcStart] == 0) {
|
|
return -1;
|
|
}
|
|
|
|
// get the indices within bounds
|
|
pinIndices(start, length);
|
|
|
|
// find the first occurrence of the substring
|
|
const UChar *match = u_strFindFirst(fArray + start, length, srcChars + srcStart, srcLength);
|
|
if(match == NULL) {
|
|
return -1;
|
|
} else {
|
|
return match - fArray;
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::doIndexOf(UChar c,
|
|
int32_t start,
|
|
int32_t length) const
|
|
{
|
|
// pin indices
|
|
pinIndices(start, length);
|
|
|
|
// find the first occurrence of c
|
|
const UChar *match = u_memchr(fArray + start, c, length);
|
|
if(match == NULL) {
|
|
return -1;
|
|
} else {
|
|
return match - fArray;
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::doIndexOf(UChar32 c,
|
|
int32_t start,
|
|
int32_t length) const {
|
|
// pin indices
|
|
pinIndices(start, length);
|
|
|
|
// find the first occurrence of c
|
|
const UChar *match = u_memchr32(fArray + start, c, length);
|
|
if(match == NULL) {
|
|
return -1;
|
|
} else {
|
|
return match - fArray;
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::lastIndexOf(const UChar *srcChars,
|
|
int32_t srcStart,
|
|
int32_t srcLength,
|
|
int32_t start,
|
|
int32_t length) const
|
|
{
|
|
if(isBogus() || srcChars == 0 || srcStart < 0 || srcLength == 0) {
|
|
return -1;
|
|
}
|
|
|
|
// UnicodeString does not find empty substrings
|
|
if(srcLength < 0 && srcChars[srcStart] == 0) {
|
|
return -1;
|
|
}
|
|
|
|
// get the indices within bounds
|
|
pinIndices(start, length);
|
|
|
|
// find the last occurrence of the substring
|
|
const UChar *match = u_strFindLast(fArray + start, length, srcChars + srcStart, srcLength);
|
|
if(match == NULL) {
|
|
return -1;
|
|
} else {
|
|
return match - fArray;
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::doLastIndexOf(UChar c,
|
|
int32_t start,
|
|
int32_t length) const
|
|
{
|
|
if(isBogus()) {
|
|
return -1;
|
|
}
|
|
|
|
// pin indices
|
|
pinIndices(start, length);
|
|
|
|
// find the last occurrence of c
|
|
const UChar *match = u_memrchr(fArray + start, c, length);
|
|
if(match == NULL) {
|
|
return -1;
|
|
} else {
|
|
return match - fArray;
|
|
}
|
|
}
|
|
|
|
int32_t
|
|
UnicodeString::doLastIndexOf(UChar32 c,
|
|
int32_t start,
|
|
int32_t length) const {
|
|
// pin indices
|
|
pinIndices(start, length);
|
|
|
|
// find the last occurrence of c
|
|
const UChar *match = u_memrchr32(fArray + start, c, length);
|
|
if(match == NULL) {
|
|
return -1;
|
|
} else {
|
|
return match - fArray;
|
|
}
|
|
}
|
|
|
|
//========================================
|
|
// Write implementation
|
|
//========================================
|
|
|
|
UnicodeString&
|
|
UnicodeString::findAndReplace(int32_t start,
|
|
int32_t length,
|
|
const UnicodeString& oldText,
|
|
int32_t oldStart,
|
|
int32_t oldLength,
|
|
const UnicodeString& newText,
|
|
int32_t newStart,
|
|
int32_t newLength)
|
|
{
|
|
if(isBogus() || oldText.isBogus() || newText.isBogus()) {
|
|
return *this;
|
|
}
|
|
|
|
pinIndices(start, length);
|
|
oldText.pinIndices(oldStart, oldLength);
|
|
newText.pinIndices(newStart, newLength);
|
|
|
|
if(oldLength == 0) {
|
|
return *this;
|
|
}
|
|
|
|
while(length > 0 && length >= oldLength) {
|
|
int32_t pos = indexOf(oldText, oldStart, oldLength, start, length);
|
|
if(pos < 0) {
|
|
// no more oldText's here: done
|
|
break;
|
|
} else {
|
|
// we found oldText, replace it by newText and go beyond it
|
|
replace(pos, oldLength, newText, newStart, newLength);
|
|
length -= pos + oldLength - start;
|
|
start = pos + newLength;
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
|
|
void
|
|
UnicodeString::setToBogus()
|
|
{
|
|
releaseArray();
|
|
|
|
fArray = 0;
|
|
fCapacity = fLength = 0;
|
|
fFlags = kIsBogus;
|
|
}
|
|
|
|
// turn a bogus string into an empty one
|
|
void
|
|
UnicodeString::unBogus() {
|
|
if(fFlags & kIsBogus) {
|
|
fArray = fStackBuffer;
|
|
fLength = 0;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fFlags = kShortString;
|
|
}
|
|
}
|
|
|
|
// setTo() analogous to the readonly-aliasing constructor with the same signature
|
|
UnicodeString &
|
|
UnicodeString::setTo(UBool isTerminated,
|
|
const UChar *text,
|
|
int32_t textLength)
|
|
{
|
|
if(fFlags & kOpenGetBuffer) {
|
|
// do not modify a string that has an "open" getBuffer(minCapacity)
|
|
return *this;
|
|
}
|
|
|
|
if(text == NULL) {
|
|
// treat as an empty string, do not alias
|
|
releaseArray();
|
|
fLength = 0;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fArray = fStackBuffer;
|
|
fFlags = kShortString;
|
|
return *this;
|
|
}
|
|
|
|
if( textLength < -1 ||
|
|
(textLength == -1 && !isTerminated) ||
|
|
(textLength >= 0 && isTerminated && text[textLength] != 0)
|
|
) {
|
|
setToBogus();
|
|
return *this;
|
|
}
|
|
|
|
releaseArray();
|
|
|
|
fArray = (UChar *)text;
|
|
if(textLength != -1) {
|
|
fLength = textLength;
|
|
fCapacity = isTerminated ? fLength + 1 : fLength;
|
|
} else {
|
|
// text is terminated, or else it would have failed the above test
|
|
fLength = u_strlen(text);
|
|
fCapacity = fLength + 1;
|
|
}
|
|
|
|
fFlags = kReadonlyAlias;
|
|
return *this;
|
|
}
|
|
|
|
// setTo() analogous to the writable-aliasing constructor with the same signature
|
|
UnicodeString &
|
|
UnicodeString::setTo(UChar *buffer,
|
|
int32_t buffLength,
|
|
int32_t buffCapacity) {
|
|
if(fFlags & kOpenGetBuffer) {
|
|
// do not modify a string that has an "open" getBuffer(minCapacity)
|
|
return *this;
|
|
}
|
|
|
|
if(buffer == NULL) {
|
|
// treat as an empty string, do not alias
|
|
releaseArray();
|
|
fLength = 0;
|
|
fCapacity = US_STACKBUF_SIZE;
|
|
fArray = fStackBuffer;
|
|
fFlags = kShortString;
|
|
return *this;
|
|
}
|
|
|
|
if(buffLength < -1 || buffCapacity < 0 || buffLength > buffCapacity) {
|
|
setToBogus();
|
|
return *this;
|
|
} else if(buffLength == -1) {
|
|
// buffLength = u_strlen(buff); but do not look beyond buffCapacity
|
|
const UChar *p = buffer, *limit = buffer + buffCapacity;
|
|
while(p != limit && *p != 0) {
|
|
++p;
|
|
}
|
|
buffLength = (int32_t)(p - buffer);
|
|
}
|
|
|
|
releaseArray();
|
|
|
|
fArray = buffer;
|
|
fLength = buffLength;
|
|
fCapacity = buffCapacity;
|
|
fFlags = kWritableAlias;
|
|
return *this;
|
|
}
|
|
|
|
UnicodeString&
|
|
UnicodeString::setCharAt(int32_t offset,
|
|
UChar c)
|
|
{
|
|
if(cloneArrayIfNeeded() && fLength > 0) {
|
|
if(offset < 0) {
|
|
offset = 0;
|
|
} else if(offset >= fLength) {
|
|
offset = fLength - 1;
|
|
}
|
|
|
|
fArray[offset] = c;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
/*
|
|
* Implement argument checking and buffer handling
|
|
* for string case mapping as a common function.
|
|
*/
|
|
enum {
|
|
TO_LOWER,
|
|
TO_UPPER,
|
|
TO_TITLE,
|
|
FOLD_CASE
|
|
};
|
|
|
|
UnicodeString &
|
|
UnicodeString::toLower() {
|
|
return caseMap(0, Locale::getDefault(), 0, TO_LOWER);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::toLower(const Locale &locale) {
|
|
return caseMap(0, locale, 0, TO_LOWER);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::toUpper() {
|
|
return caseMap(0, Locale::getDefault(), 0, TO_UPPER);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::toUpper(const Locale &locale) {
|
|
return caseMap(0, locale, 0, TO_UPPER);
|
|
}
|
|
|
|
#if !UCONFIG_NO_BREAK_ITERATION
|
|
|
|
UnicodeString &
|
|
UnicodeString::toTitle(BreakIterator *titleIter) {
|
|
return caseMap(titleIter, Locale::getDefault(), 0, TO_TITLE);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::toTitle(BreakIterator *titleIter, const Locale &locale) {
|
|
return caseMap(titleIter, locale, 0, TO_TITLE);
|
|
}
|
|
|
|
#endif
|
|
|
|
UnicodeString &
|
|
UnicodeString::foldCase(uint32_t options) {
|
|
return caseMap(0, Locale::getDefault(), options, FOLD_CASE);
|
|
}
|
|
|
|
UnicodeString &
|
|
UnicodeString::caseMap(BreakIterator *titleIter,
|
|
const Locale& locale,
|
|
uint32_t options,
|
|
int32_t toWhichCase) {
|
|
if(fLength <= 0) {
|
|
// nothing to do
|
|
return *this;
|
|
}
|
|
|
|
// We need to allocate a new buffer for the internal string case mapping function.
|
|
// This is very similar to how doReplace() below keeps the old array pointer
|
|
// and deletes the old array itself after it is done.
|
|
// In addition, we are forcing cloneArrayIfNeeded() to always allocate a new array.
|
|
UChar *oldArray = fArray;
|
|
int32_t oldLength = fLength;
|
|
int32_t *bufferToDelete = 0;
|
|
|
|
// Make sure that if the string is in fStackBuffer we do not overwrite it!
|
|
int32_t capacity;
|
|
if(fLength <= US_STACKBUF_SIZE) {
|
|
if(fArray == fStackBuffer) {
|
|
capacity = 2 * US_STACKBUF_SIZE; // make sure that cloneArrayIfNeeded() allocates a new buffer
|
|
} else {
|
|
capacity = US_STACKBUF_SIZE;
|
|
}
|
|
} else {
|
|
capacity = fLength + 20;
|
|
}
|
|
if(!cloneArrayIfNeeded(capacity, capacity, FALSE, &bufferToDelete, TRUE)) {
|
|
return *this;
|
|
}
|
|
|
|
UErrorCode errorCode;
|
|
|
|
#if !UCONFIG_NO_BREAK_ITERATION
|
|
// set up the titlecasing break iterator
|
|
UBreakIterator *cTitleIter = 0;
|
|
|
|
if(toWhichCase == TO_TITLE) {
|
|
errorCode = U_ZERO_ERROR;
|
|
if(titleIter != 0) {
|
|
cTitleIter = (UBreakIterator *)titleIter;
|
|
ubrk_setText(cTitleIter, oldArray, oldLength, &errorCode);
|
|
} else {
|
|
cTitleIter = ubrk_open(UBRK_WORD, locale.getName(),
|
|
oldArray, oldLength,
|
|
&errorCode);
|
|
}
|
|
if(U_FAILURE(errorCode)) {
|
|
uprv_free(bufferToDelete);
|
|
setToBogus();
|
|
return *this;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Case-map, and if the result is too long, then reallocate and repeat.
|
|
do {
|
|
errorCode = U_ZERO_ERROR;
|
|
if(toWhichCase==TO_LOWER) {
|
|
fLength = u_internalStrToLower(fArray, fCapacity,
|
|
oldArray, oldLength,
|
|
0, oldLength,
|
|
locale.getName(),
|
|
&errorCode);
|
|
} else if(toWhichCase==TO_UPPER) {
|
|
fLength = u_internalStrToUpper(fArray, fCapacity,
|
|
oldArray, oldLength,
|
|
locale.getName(),
|
|
&errorCode);
|
|
#if !UCONFIG_NO_BREAK_ITERATION
|
|
} else if(toWhichCase==TO_TITLE) {
|
|
fLength = u_internalStrToTitle(fArray, fCapacity,
|
|
oldArray, oldLength,
|
|
cTitleIter, locale.getName(),
|
|
&errorCode);
|
|
#endif
|
|
} else {
|
|
fLength = u_internalStrFoldCase(fArray, fCapacity,
|
|
oldArray, oldLength,
|
|
options,
|
|
&errorCode);
|
|
}
|
|
} while(errorCode==U_BUFFER_OVERFLOW_ERROR && cloneArrayIfNeeded(fLength, fLength, FALSE));
|
|
|
|
#if !UCONFIG_NO_BREAK_ITERATION
|
|
if(cTitleIter != 0 && titleIter == 0) {
|
|
ubrk_close(cTitleIter);
|
|
}
|
|
#endif
|
|
|
|
if (bufferToDelete) {
|
|
uprv_free(bufferToDelete);
|
|
}
|
|
if(U_FAILURE(errorCode)) {
|
|
setToBogus();
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
UnicodeString&
|
|
UnicodeString::doReplace( int32_t start,
|
|
int32_t length,
|
|
const UnicodeString& src,
|
|
int32_t srcStart,
|
|
int32_t srcLength)
|
|
{
|
|
if(!src.isBogus()) {
|
|
// pin the indices to legal values
|
|
src.pinIndices(srcStart, srcLength);
|
|
|
|
// get the characters from src
|
|
// and replace the range in ourselves with them
|
|
return doReplace(start, length, src.getArrayStart(), srcStart, srcLength);
|
|
} else {
|
|
// remove the range
|
|
return doReplace(start, length, 0, 0, 0);
|
|
}
|
|
}
|
|
|
|
UnicodeString&
|
|
UnicodeString::doReplace(int32_t start,
|
|
int32_t length,
|
|
const UChar *srcChars,
|
|
int32_t srcStart,
|
|
int32_t srcLength)
|
|
{
|
|
if(isBogus()) {
|
|
return *this;
|
|
}
|
|
|
|
if(srcChars == 0) {
|
|
srcStart = srcLength = 0;
|
|
} else if(srcLength < 0) {
|
|
// get the srcLength if necessary
|
|
srcLength = u_strlen(srcChars + srcStart);
|
|
}
|
|
|
|
int32_t *bufferToDelete = 0;
|
|
|
|
// the following may change fArray but will not copy the current contents;
|
|
// therefore we need to keep the current fArray
|
|
UChar *oldArray = fArray;
|
|
int32_t oldLength = fLength;
|
|
|
|
// pin the indices to legal values
|
|
pinIndices(start, length);
|
|
|
|
// calculate the size of the string after the replace
|
|
int32_t newSize = oldLength - length + srcLength;
|
|
|
|
// clone our array and allocate a bigger array if needed
|
|
if(!cloneArrayIfNeeded(newSize, newSize + (newSize >> 2) + kGrowSize,
|
|
FALSE, &bufferToDelete)
|
|
) {
|
|
return *this;
|
|
}
|
|
|
|
// now do the replace
|
|
|
|
if(fArray != oldArray) {
|
|
// if fArray changed, then we need to copy everything except what will change
|
|
us_arrayCopy(oldArray, 0, fArray, 0, start);
|
|
us_arrayCopy(oldArray, start + length,
|
|
fArray, start + srcLength,
|
|
oldLength - (start + length));
|
|
} else if(length != srcLength) {
|
|
// fArray did not change; copy only the portion that isn't changing, leaving a hole
|
|
us_arrayCopy(oldArray, start + length,
|
|
fArray, start + srcLength,
|
|
oldLength - (start + length));
|
|
}
|
|
|
|
// now fill in the hole with the new string
|
|
us_arrayCopy(srcChars, srcStart, getArrayStart(), start, srcLength);
|
|
|
|
fLength = newSize;
|
|
|
|
// delayed delete in case srcChars == fArray when we started, and
|
|
// to keep oldArray alive for the above operations
|
|
if (bufferToDelete) {
|
|
uprv_free(bufferToDelete);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* Replaceable API
|
|
*/
|
|
void
|
|
UnicodeString::handleReplaceBetween(int32_t start,
|
|
int32_t limit,
|
|
const UnicodeString& text) {
|
|
replaceBetween(start, limit, text);
|
|
}
|
|
|
|
/**
|
|
* Replaceable API
|
|
*/
|
|
void
|
|
UnicodeString::copy(int32_t start, int32_t limit, int32_t dest) {
|
|
if (limit <= start) {
|
|
return; // Nothing to do; avoid bogus malloc call
|
|
}
|
|
UChar* text = (UChar*) uprv_malloc( sizeof(UChar) * (limit - start) );
|
|
extractBetween(start, limit, text, 0);
|
|
insert(dest, text, 0, limit - start);
|
|
uprv_free(text);
|
|
}
|
|
|
|
/**
|
|
* Replaceable API
|
|
*
|
|
* NOTE: This is for the Replaceable class. There is no rep.cpp,
|
|
* so we implement this function here.
|
|
*/
|
|
UBool Replaceable::hasMetaData() const {
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* Replaceable API
|
|
*/
|
|
UBool UnicodeString::hasMetaData() const {
|
|
return FALSE;
|
|
}
|
|
|
|
UnicodeString&
|
|
UnicodeString::doReverse(int32_t start,
|
|
int32_t length)
|
|
{
|
|
if(fLength <= 1 || !cloneArrayIfNeeded()) {
|
|
return *this;
|
|
}
|
|
|
|
// pin the indices to legal values
|
|
pinIndices(start, length);
|
|
|
|
UChar *left = getArrayStart() + start;
|
|
UChar *right = getArrayStart() + start + length;
|
|
UChar swap;
|
|
UBool hasSupplementary = FALSE;
|
|
|
|
while(left < --right) {
|
|
hasSupplementary |= (UBool)UTF_IS_LEAD(swap = *left);
|
|
hasSupplementary |= (UBool)UTF_IS_LEAD(*left++ = *right);
|
|
*right = swap;
|
|
}
|
|
|
|
/* if there are supplementary code points in the reversed range, then re-swap their surrogates */
|
|
if(hasSupplementary) {
|
|
UChar swap2;
|
|
|
|
left = getArrayStart() + start;
|
|
right = getArrayStart() + start + length - 1; // -1 so that we can look at *(left+1) if left<right
|
|
while(left < right) {
|
|
if(UTF_IS_TRAIL(swap = *left) && UTF_IS_LEAD(swap2 = *(left + 1))) {
|
|
*left++ = swap2;
|
|
*left++ = swap;
|
|
} else {
|
|
++left;
|
|
}
|
|
}
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
UBool
|
|
UnicodeString::padLeading(int32_t targetLength,
|
|
UChar padChar)
|
|
{
|
|
if(fLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
|
|
return FALSE;
|
|
} else {
|
|
// move contents up by padding width
|
|
int32_t start = targetLength - fLength;
|
|
us_arrayCopy(fArray, 0, fArray, start, fLength);
|
|
|
|
// fill in padding character
|
|
while(--start >= 0) {
|
|
fArray[start] = padChar;
|
|
}
|
|
fLength = targetLength;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
UBool
|
|
UnicodeString::padTrailing(int32_t targetLength,
|
|
UChar padChar)
|
|
{
|
|
if(fLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
|
|
return FALSE;
|
|
} else {
|
|
// fill in padding character
|
|
int32_t length = targetLength;
|
|
while(--length >= fLength) {
|
|
fArray[length] = padChar;
|
|
}
|
|
fLength = targetLength;
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
UnicodeString&
|
|
UnicodeString::trim()
|
|
{
|
|
if(isBogus()) {
|
|
return *this;
|
|
}
|
|
|
|
UChar32 c;
|
|
int32_t i = fLength, length;
|
|
|
|
// first cut off trailing white space
|
|
for(;;) {
|
|
length = i;
|
|
if(i <= 0) {
|
|
break;
|
|
}
|
|
UTF_PREV_CHAR(fArray, 0, i, c);
|
|
if(!(c == 0x20 || u_isWhitespace(c))) {
|
|
break;
|
|
}
|
|
}
|
|
if(length < fLength) {
|
|
fLength = length;
|
|
}
|
|
|
|
// find leading white space
|
|
int32_t start;
|
|
i = 0;
|
|
for(;;) {
|
|
start = i;
|
|
if(i >= length) {
|
|
break;
|
|
}
|
|
UTF_NEXT_CHAR(fArray, i, length, c);
|
|
if(!(c == 0x20 || u_isWhitespace(c))) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// move string forward over leading white space
|
|
if(start > 0) {
|
|
doReplace(0, start, 0, 0, 0);
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
//========================================
|
|
// Hashing
|
|
//========================================
|
|
int32_t
|
|
UnicodeString::doHashCode() const
|
|
{
|
|
/* Delegate hash computation to uhash. This makes UnicodeString
|
|
* hashing consistent with UChar* hashing. */
|
|
int32_t hashCode = uhash_hashUCharsN(getArrayStart(), fLength);
|
|
if (hashCode == kInvalidHashCode) {
|
|
hashCode = kEmptyHashCode;
|
|
}
|
|
return hashCode;
|
|
}
|
|
|
|
//========================================
|
|
// Codeset conversion
|
|
//========================================
|
|
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);
|
|
|
|
// create the converter
|
|
UConverter *converter;
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
// just write the NUL if the string length is 0
|
|
if(length == 0) {
|
|
if(dstSize >= 0x80000000) {
|
|
// careful: dstSize is unsigned! (0xffffffff means "unlimited")
|
|
// make sure that the NUL-termination works (takes int32_t)
|
|
dstSize=0x7fffffff;
|
|
}
|
|
return u_terminateChars(target, dstSize, 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) {
|
|
converter = u_getDefaultConverter(&status);
|
|
} else if (*codepage == 0) {
|
|
// use the "invariant characters" conversion
|
|
int32_t destLength;
|
|
// careful: dstSize is unsigned! (0xffffffff means "unlimited")
|
|
if(dstSize >= 0x80000000) {
|
|
destLength = length;
|
|
// make sure that the NUL-termination works (takes int32_t)
|
|
dstSize=0x7fffffff;
|
|
} else if(length <= (int32_t)dstSize) {
|
|
destLength = length;
|
|
} else {
|
|
destLength = (int32_t)dstSize;
|
|
}
|
|
u_UCharsToChars(getArrayStart() + start, target, destLength);
|
|
return u_terminateChars(target, (int32_t)dstSize, length, &status);
|
|
} else {
|
|
converter = ucnv_open(codepage, &status);
|
|
}
|
|
|
|
length = doExtract(start, length, target, (int32_t)dstSize, 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(fLength<=0) {
|
|
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 length=doExtract(0, fLength, dest, destCapacity, cnv, errorCode);
|
|
|
|
// release the converter
|
|
if(isDefaultConverter) {
|
|
u_releaseDefaultConverter(cnv);
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
void
|
|
UnicodeString::extractBetween(int32_t start,
|
|
int32_t limit,
|
|
UnicodeString& target) const
|
|
{ doExtract(start, limit - start, target); }
|
|
|
|
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=fArray+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 = 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 = (codepage == 0 ?
|
|
u_getDefaultConverter(&status) :
|
|
*codepage == 0 ?
|
|
0 :
|
|
ucnv_open(codepage, &status));
|
|
|
|
// if we failed, set the appropriate flags and return
|
|
if(U_FAILURE(status)) {
|
|
setToBogus();
|
|
return;
|
|
}
|
|
|
|
// perform the conversion
|
|
if(converter == 0) {
|
|
// use the "invariant characters" conversion
|
|
if(cloneArrayIfNeeded(dataLength, dataLength, FALSE)) {
|
|
u_charsToUChars(codepageData, getArrayStart(), dataLength);
|
|
fLength = dataLength;
|
|
} else {
|
|
setToBogus();
|
|
}
|
|
return;
|
|
}
|
|
|
|
// convert using the real converter
|
|
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 *myTarget;
|
|
|
|
// estimate the size needed:
|
|
// 1.25 UChar's per source byte should cover most cases
|
|
int32_t 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
|
|
myTarget = fArray + fLength;
|
|
ucnv_toUnicode(converter, &myTarget, fArray + fCapacity,
|
|
&mySource, mySourceEnd, 0, TRUE, &status);
|
|
|
|
// update the conversion parameters
|
|
fLength = (int32_t)(myTarget - fArray);
|
|
|
|
// 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)(fLength + 2 * (mySourceEnd - mySource));
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
//========================================
|
|
// External Buffer
|
|
//========================================
|
|
|
|
UChar *
|
|
UnicodeString::getBuffer(int32_t minCapacity) {
|
|
if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) {
|
|
fFlags|=kOpenGetBuffer;
|
|
fLength=0;
|
|
return fArray;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void
|
|
UnicodeString::releaseBuffer(int32_t newLength) {
|
|
if(fFlags&kOpenGetBuffer && newLength>=-1) {
|
|
// set the new fLength
|
|
if(newLength==-1) {
|
|
// the new length is the string length, capped by fCapacity
|
|
const UChar *p=fArray, *limit=fArray+fCapacity;
|
|
while(p<limit && *p!=0) {
|
|
++p;
|
|
}
|
|
fLength=(int32_t)(p-fArray);
|
|
} else if(newLength<=fCapacity) {
|
|
fLength=newLength;
|
|
} else {
|
|
fLength=fCapacity;
|
|
}
|
|
fFlags&=~kOpenGetBuffer;
|
|
}
|
|
}
|
|
|
|
//========================================
|
|
// Miscellaneous
|
|
//========================================
|
|
UBool
|
|
UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
|
|
int32_t growCapacity,
|
|
UBool doCopyArray,
|
|
int32_t **pBufferToDelete,
|
|
UBool forceClone) {
|
|
// default parameters need to be static, therefore
|
|
// the defaults are -1 to have convenience defaults
|
|
if(newCapacity == -1) {
|
|
newCapacity = fCapacity;
|
|
}
|
|
|
|
// while a getBuffer(minCapacity) is "open",
|
|
// prevent any modifications of the string by returning FALSE here
|
|
// if the string is bogus, then only an assignment or similar can revive it
|
|
if((fFlags&(kOpenGetBuffer|kIsBogus))!=0) {
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* We need to make a copy of the array if
|
|
* the buffer is read-only, or
|
|
* the buffer is refCounted (shared), and refCount>1, or
|
|
* the buffer is too small.
|
|
* Return FALSE if memory could not be allocated.
|
|
*/
|
|
if(forceClone ||
|
|
fFlags & kBufferIsReadonly ||
|
|
fFlags & kRefCounted && refCount() > 1 ||
|
|
newCapacity > fCapacity
|
|
) {
|
|
// save old values
|
|
UChar *array = fArray;
|
|
uint16_t flags = fFlags;
|
|
|
|
// check growCapacity for default value and use of the stack buffer
|
|
if(growCapacity == -1) {
|
|
growCapacity = newCapacity;
|
|
} else if(newCapacity <= US_STACKBUF_SIZE && growCapacity > US_STACKBUF_SIZE) {
|
|
growCapacity = US_STACKBUF_SIZE;
|
|
}
|
|
|
|
// allocate a new array
|
|
if(allocate(growCapacity) ||
|
|
newCapacity < growCapacity && allocate(newCapacity)
|
|
) {
|
|
if(doCopyArray) {
|
|
// copy the contents
|
|
// do not copy more than what fits - it may be smaller than before
|
|
if(fCapacity < fLength) {
|
|
fLength = fCapacity;
|
|
}
|
|
us_arrayCopy(array, 0, fArray, 0, fLength);
|
|
} else {
|
|
fLength = 0;
|
|
}
|
|
|
|
// release the old array
|
|
if(flags & kRefCounted) {
|
|
// the array is refCounted; decrement and release if 0
|
|
int32_t *pRefCount = ((int32_t *)array - 1);
|
|
if(umtx_atomic_dec(pRefCount) == 0) {
|
|
if(pBufferToDelete == 0) {
|
|
uprv_free(pRefCount);
|
|
} else {
|
|
// the caller requested to delete it himself
|
|
*pBufferToDelete = pRefCount;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// not enough memory for growCapacity and not even for the smaller newCapacity
|
|
// reset the old values for setToBogus() to release the array
|
|
fArray = array;
|
|
fFlags = flags;
|
|
setToBogus();
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
U_NAMESPACE_END
|