organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 14:05:32 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 8

ICU-7496 add internal char * string class for C++ implementation code

Browse source 
X-SVN-Rev: 28082
This commit is contained in:
Markus Scherer 2010-05-20 21:16:44 +00:00
parent 1d8a683b96
commit fd376b34c0
21 changed files with 352 additions and 311 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
icu4c/source/common/Makefile.in
View file

@ -71,7 +71,8 @@ CPPFLAGS += "-DDEFAULT_ICU_PLUGINS=\"$(libdir)/icu\" "
# $(LIBICUDT) is either stub data or the real DLL common data.
LIBS = $(LIBICUDT) $(DEFAULT_LIBS)
OBJECTS = errorcode.o putil.o umath.o utypes.o uinvchar.o umutex.o ucln_cmn.o uinit.o uobject.o cmemory.o \
OBJECTS = errorcode.o putil.o umath.o utypes.o uinvchar.o umutex.o ucln_cmn.o \
uinit.o uobject.o cmemory.o charstr.o \
udata.o ucmndata.o udatamem.o umapfile.o udataswp.o ucol_swp.o utrace.o \
uhash.o uhash_us.o uenum.o ustrenum.o uvector.o ustack.o uvectr32.o uvectr64.o \
ucnv.o ucnv_bld.o ucnv_cnv.o ucnv_io.o ucnv_cb.o ucnv_err.o ucnvlat1.o \

130
icu4c/source/common/charstr.cpp Normal file
View file

@ -0,0 +1,130 @@
/*
*******************************************************************************
* Copyright (C) 2010, International Business Machines
* Corporation and others. All Rights Reserved.
*******************************************************************************
* file name: charstr.cpp
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 2010may19
* created by: Markus W. Scherer
*/
#include "unicode/utypes.h"
#include "charstr.h"
#include "cmemory.h"
#include "cstring.h"
U_NAMESPACE_BEGIN
CharString &CharString::copyFrom(const CharString &s, UErrorCode &errorCode) {
if(U_SUCCESS(errorCode) && this!=&s && ensureCapacity(s.len+1, 0, errorCode)) {
len=s.len;
uprv_memcpy(buffer.getAlias(), s.buffer.getAlias(), len+1);
}
return *this;
}
CharString &CharString::truncate(int32_t newLength) {
if(newLength<0) {
newLength=0;
}
if(newLength<len) {
buffer[len=newLength]=0;
}
return *this;
}
CharString &CharString::append(char c, UErrorCode &errorCode) {
if(ensureCapacity(len+2, 0, errorCode)) {
buffer[len++]=c;
buffer[len]=0;
}
return *this;
}
CharString &CharString::append(const char *s, int32_t sLength, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return *this;
}
if(sLength<-1 || (s==NULL && sLength!=0)) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return *this;
}
if(sLength<0) {
sLength=uprv_strlen(s);
}
if(sLength>0) {
if(s==(buffer.getAlias()+len)) {
// The caller wrote into the getAppendBuffer().
if(sLength>=(buffer.getCapacity()-len)) {
// The caller wrote too much.
errorCode=U_INTERNAL_PROGRAM_ERROR;
} else {
buffer[len+=sLength]=0;
}
} else if(buffer.getAlias()<=s && s<(buffer.getAlias()+len) &&
sLength>=(buffer.getCapacity()-len)
) {
// (Part of) this string is appended to itself which requires reallocation,
// so we have to make a copy of the substring and append that.
return append(CharString(s, sLength, errorCode), errorCode);
} else if(ensureCapacity(len+sLength+1, 0, errorCode)) {
uprv_memcpy(buffer.getAlias()+len, s, sLength);
buffer[len+=sLength]=0;
}
}
return *this;
}
char *CharString::getAppendBuffer(int32_t minCapacity,
int32_t desiredCapacityHint,
int32_t &resultCapacity,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
resultCapacity=0;
return NULL;
}
int32_t appendCapacity=buffer.getCapacity()-len-1; // -1 for NUL
if(appendCapacity>=minCapacity) {
resultCapacity=appendCapacity;
return buffer.getAlias()+len;
}
if(ensureCapacity(len+minCapacity+1, len+desiredCapacityHint+1, errorCode)) {
resultCapacity=buffer.getCapacity()-len-1;
return buffer.getAlias()+len;
}
resultCapacity=0;
return NULL;
}
CharString &CharString::appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode) {
if(ensureCapacity(len+s.length()+1, 0, errorCode)) {
len+=s.extract(0, 0x7fffffff, buffer.getAlias()+len, buffer.getCapacity()-len, US_INV);
}
return *this;
}
UBool CharString::ensureCapacity(int32_t capacity,
int32_t desiredCapacityHint,
UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return FALSE;
}
if(capacity>buffer.getCapacity()) {
if(desiredCapacityHint==0) {
desiredCapacityHint=capacity+buffer.getCapacity();
}
if( (desiredCapacityHint<=capacity || buffer.resize(desiredCapacityHint, len+1)==NULL) &&
buffer.resize(capacity, len+1)==NULL
) {
errorCode=U_MEMORY_ALLOCATION_ERROR;
return FALSE;
}
}
return TRUE;
}
U_NAMESPACE_END

139
icu4c/source/common/charstr.h
View file

@ -1,10 +1,11 @@
/*
**********************************************************************
* Copyright (c) 2001-2004, International Business Machines
* Copyright (c) 2001-2010, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Date Name Description
* 11/19/2001 aliu Creation.
* 05/19/2010 markus Rewritten from scratch
**********************************************************************
*/
@ -12,76 +13,104 @@
#define CHARSTRING_H
#include "unicode/utypes.h"
#include "unicode/uobject.h"
#include "unicode/unistr.h"
#include "unicode/uobject.h"
#include "cmemory.h"
//--------------------------------------------------------------------
// class CharString
//
// This is a tiny wrapper class that is used internally to make a
// UnicodeString look like a const char*. It can be allocated on the
// stack. It only creates a heap buffer if it needs to.
//--------------------------------------------------------------------
U_NAMESPACE_BEGIN
/**
* ICU-internal char * string class.
* This class does not assume or enforce any particular character encoding.
* Raw bytes can be stored. The string object owns its characters.
* A terminating NUL is stored, but the class does not prevent embedded NUL characters.
*
* This class wants to be convenient but is also deliberately minimalist.
* Please do not add methods if they only add minor convenience.
* For example:
* cs.data()[5]='a'; // no need for setCharAt(5, 'a')
*/
class U_COMMON_API CharString : public UMemory {
public:
CharString() : len(0) { buffer[0]=0; }
CharString(const StringPiece &s, UErrorCode &errorCode) : len(0) {
buffer[0]=0;
append(s, errorCode);
}
CharString(const CharString &s, UErrorCode &errorCode) : len(0) {
buffer[0]=0;
append(s, errorCode);
}
CharString(const char *s, int32_t sLength, UErrorCode &errorCode) : len(0) {
buffer[0]=0;
append(s, sLength, errorCode);
}
~CharString() {}
#if !UCONFIG_NO_CONVERSION
// Constructor
// @param str The unicode string to be converted to char *
// @param codepage The char * code page. "" for invariant conversion.
// NULL for default code page.
// inline CharString(const UnicodeString& str, const char *codepage);
#endif
/**
* Replaces this string's contents with the other string's contents.
* CharString does not support the standard copy constructor nor
* the assignment operator, to make copies explicit and to
* use a UErrorCode where memory allocations might be needed.
*/
CharString &copyFrom(const CharString &other, UErrorCode &errorCode);
inline CharString(const UnicodeString& str);
inline ~CharString();
inline operator const char*() const { return ptr; }
UBool isEmpty() { return len==0; }
const int32_t length() const { return len; }
char operator[] (int32_t index) const { return buffer[index]; }
StringPiece toStringPiece() const { return StringPiece(buffer.getAlias(), len); }
const char *data() const { return buffer.getAlias(); }
char *data() { return buffer.getAlias(); }
CharString &clear() { len=0; return *this; }
CharString &truncate(int32_t newLength);
CharString &append(char c, UErrorCode &errorCode);
CharString &append(const StringPiece &s, UErrorCode &errorCode) {
return append(s.data(), s.length(), errorCode);
}
CharString &append(const CharString &s, UErrorCode &errorCode) {
return append(s.data(), s.length(), errorCode);
}
CharString &append(const char *s, int32_t sLength, UErrorCode &status);
/**
* Returns a writable buffer for appending and writes the buffer's capacity to
* resultCapacity. Guarantees resultCapacity>=minCapacity if U_SUCCESS().
* There will additionally be space for a terminating NUL right at resultCapacity.
* (This function is similar to ByteSink.GetAppendBuffer().)
*
* The returned buffer is only valid until the next write operation
* on this string.
*
* After writing at most resultCapacity bytes, call append() with the
* pointer returned from this function and the number of bytes written.
*
* @param minCapacity required minimum capacity of the returned buffer;
* must be non-negative
* @param desiredCapacityHint desired capacity of the returned buffer;
* must be non-negative
* @param resultCapacity will be set to the capacity of the returned buffer
* @param errorCode in/out error code
* @return a buffer with resultCapacity>=min_capacity
*/
char *getAppendBuffer(int32_t minCapacity,
int32_t desiredCapacityHint,
int32_t &resultCapacity,
UErrorCode &errorCode);
CharString &appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode);
private:
char buf[128];
char* ptr;
MaybeStackArray<char, 40> buffer;
int32_t len;
UBool ensureCapacity(int32_t capacity, int32_t desiredCapacityHint, UErrorCode &errorCode);
CharString(const CharString &other); // forbid copying of this class
CharString &operator=(const CharString &other); // forbid copying of this class
};
#if !UCONFIG_NO_CONVERSION
// PLEASE DON'T USE THIS FUNCTION.
// We don't want the static dependency on conversion or the performance hit that comes from a codepage conversion.
/*
inline CharString::CharString(const UnicodeString& str, const char *codepage) {
int32_t len;
ptr = buf;
len = str.extract(0, 0x7FFFFFFF, buf ,sizeof(buf)-1, codepage);
if (len >= (int32_t)(sizeof(buf)-1)) {
ptr = (char *)uprv_malloc(len+1);
str.extract(0, 0x7FFFFFFF, ptr, len+1, codepage);
}
}*/
#endif
inline CharString::CharString(const UnicodeString& str) {
int32_t len;
ptr = buf;
len = str.extract(0, 0x7FFFFFFF, buf, (int32_t)(sizeof(buf)-1), US_INV);
if (len >= (int32_t)(sizeof(buf)-1)) {
ptr = (char *)uprv_malloc(len+1);
str.extract(0, 0x7FFFFFFF, ptr, len+1, US_INV);
}
}
inline CharString::~CharString() {
if (ptr != buf) {
uprv_free(ptr);
}
}
U_NAMESPACE_END
#endif

4
icu4c/source/common/common.vcproj
View file

@ -3943,6 +3943,10 @@
/>
</FileConfiguration>
</File>
<File
RelativePath=".\charstr.cpp"
>
</File>
<File
RelativePath=".\charstr.h"
>

12
icu4c/source/common/locutil.cpp
View file

@ -1,9 +1,7 @@
/**
*******************************************************************************
* Copyright (C) 2002-2006, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*
* Copyright (C) 2002-2010, International Business Machines Corporation and
* others. All Rights Reserved.
*******************************************************************************
*/
#include "unicode/utypes.h"
@ -227,9 +225,9 @@ LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID)
if (htp == NULL) {
htp = new Hashtable(status);
if (htp && U_SUCCESS(status)) {
CharString cbundleID(bundleID);
const char* path = (const char*) cbundleID;
if (*path == 0) path = NULL; // empty string => NULL
CharString cbundleID;
cbundleID.appendInvariantChars(bundleID, status);
const char* path = cbundleID.isEmpty() ? NULL : cbundleID.data();
UEnumeration *uenum = ures_openAvailableLocales(path, &status);
for (;;) {
const UChar* id = uenum_unext(uenum, NULL, &status);

30
icu4c/source/common/uniset_props.cpp
View file

@ -1051,15 +1051,17 @@ UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
) {
FAIL(ec);
}
CharString pname(prop);
CharString vname(value);
CharString pname, vname;
pname.appendInvariantChars(prop, ec);
vname.appendInvariantChars(value, ec);
if (U_FAILURE(ec)) return *this;
UProperty p;
int32_t v;
UBool mustNotBeEmpty = FALSE, invert = FALSE;
if (value.length() > 0) {
p = u_getPropertyEnum(pname);
p = u_getPropertyEnum(pname.data());
if (p == UCHAR_INVALID_CODE) FAIL(ec);
// Treat gc as gcm
@ -1070,14 +1072,14 @@ UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) ||
(p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) ||
(p >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) {
v = u_getPropertyValueEnum(p, vname);
v = u_getPropertyValueEnum(p, vname.data());
if (v == UCHAR_INVALID_CODE) {
// Handle numeric CCC
if (p == UCHAR_CANONICAL_COMBINING_CLASS ||
p == UCHAR_TRAIL_CANONICAL_COMBINING_CLASS ||
p == UCHAR_LEAD_CANONICAL_COMBINING_CLASS) {
char* end;
double value = uprv_strtod(vname, &end);
double value = uprv_strtod(vname.data(), &end);
v = (int32_t) value;
if (v != value || v < 0 || *end != 0) {
// non-integral or negative value, or trailing junk
@ -1098,7 +1100,7 @@ UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
case UCHAR_NUMERIC_VALUE:
{
char* end;
double value = uprv_strtod(vname, &end);
double value = uprv_strtod(vname.data(), &end);
if (*end != 0) {
FAIL(ec);
}
@ -1112,7 +1114,7 @@ UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
// Must munge name, since u_charFromName() does not do
// 'loose' matching.
char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength
if (!mungeCharName(buf, vname, sizeof(buf))) FAIL(ec);
if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec);
UCharNameChoice choice = (p == UCHAR_NAME) ?
U_EXTENDED_CHAR_NAME : U_UNICODE_10_CHAR_NAME;
UChar32 ch = u_charFromName(choice, buf, &ec);
@ -1130,7 +1132,7 @@ UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
// Must munge name, since u_versionFromString() does not do
// 'loose' matching.
char buf[128];
if (!mungeCharName(buf, vname, sizeof(buf))) FAIL(ec);
if (!mungeCharName(buf, vname.data(), sizeof(buf))) FAIL(ec);
UVersionInfo version;
u_versionFromString(version, buf);
applyFilter(versionFilter, &version, UPROPS_SRC_PROPSVEC, ec);
@ -1149,21 +1151,21 @@ UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
// value is empty. Interpret as General Category, Script, or
// Binary property.
p = UCHAR_GENERAL_CATEGORY_MASK;
v = u_getPropertyValueEnum(p, pname);
v = u_getPropertyValueEnum(p, pname.data());
if (v == UCHAR_INVALID_CODE) {
p = UCHAR_SCRIPT;
v = u_getPropertyValueEnum(p, pname);
v = u_getPropertyValueEnum(p, pname.data());
if (v == UCHAR_INVALID_CODE) {
p = u_getPropertyEnum(pname);
p = u_getPropertyEnum(pname.data());
if (p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) {
v = 1;
} else if (0 == uprv_comparePropertyNames(ANY, pname)) {
} else if (0 == uprv_comparePropertyNames(ANY, pname.data())) {
set(MIN_VALUE, MAX_VALUE);
return *this;
} else if (0 == uprv_comparePropertyNames(ASCII, pname)) {
} else if (0 == uprv_comparePropertyNames(ASCII, pname.data())) {
set(0, 0x7F);
return *this;
} else if (0 == uprv_comparePropertyNames(ASSIGNED, pname)) {
} else if (0 == uprv_comparePropertyNames(ASSIGNED, pname.data())) {
// [:Assigned:]=[:^Cn:]
p = UCHAR_GENERAL_CATEGORY_MASK;
v = U_GC_CN_MASK;

2
icu4c/source/i18n/Makefile.in
View file

@ -84,7 +84,7 @@ zonemeta.o zstrfmt.o plurrule.o plurfmt.o selfmt.o dtitvfmt.o dtitvinf.o \
tmunit.o tmutamt.o tmutfmt.o colldata.o bmsearch.o bms.o currpinf.o \
uspoof.o uspoof_impl.o uspoof_build.o uspoof_conf.o uspoof_wsconf.o \
ztrans.o zrule.o vzone.o fphdlimp.o fpositer.o locdspnm.o \
decNumber.o decContext.o decnumstr.o
decNumber.o decContext.o
## Header files to install
HEADERS = $(srcdir)/unicode/*.h

10
icu4c/source/i18n/decimfmt.cpp
View file

@ -53,6 +53,7 @@
#include "unicode/currpinf.h"
#include "unicode/plurrule.h"
#include "ucurrimp.h"
#include "charstr.h"
#include "cmemory.h"
#include "util.h"
#include "digitlst.h"
@ -62,7 +63,6 @@
#include "putilimp.h"
#include <math.h>
#include "hash.h"
#include "decnumstr.h"
U_NAMESPACE_BEGIN
@ -1798,7 +1798,7 @@ UBool DecimalFormat::subparse(const UnicodeString& text,
// will be acceptable to the decNumber library, then at the end passes that string
// off for conversion to a decNumber.
UErrorCode err = U_ZERO_ERROR;
DecimalNumberString parsedNum;
CharString parsedNum;
digits.setToZero();
int32_t position = parsePosition.getIndex();
@ -1901,7 +1901,7 @@ UBool DecimalFormat::subparse(const UnicodeString& text,
sawDigit = TRUE;
// output a regular non-zero digit.
++digitCount;
parsedNum.append(digit + '0', err);
parsedNum.append((char)(digit + '0'), err);
position += U16_LENGTH(ch);
}
else if (groupingLen > 0 && !text.compare(position, groupingLen, *grouping) && isGroupingUsed())
@ -2033,14 +2033,14 @@ UBool DecimalFormat::subparse(const UnicodeString& text,
parsePosition.setIndex(position);
parsedNum[0] = (posMatch >= 0) ? '+' : '-';
parsedNum.data()[0] = (posMatch >= 0) ? '+' : '-';
if(parsePosition.getIndex() == oldStart)
{
parsePosition.setErrorIndex(position);
return FALSE;
}
digits.set(parsedNum, err);
digits.set(parsedNum.toStringPiece(), err);
if (U_FAILURE(err)) {
parsePosition.setErrorIndex(position);

100
icu4c/source/i18n/decnumstr.cpp
View file

@ -1,100 +0,0 @@
/*
******************************************************************************
*
* Copyright (C) 2010, International Business Machines
* Corporation and others. All Rights Reserved.
*
******************************************************************************
*
* File decnumstr.cpp
*
*/
#include "unicode/utypes.h"
#include "decnumstr.h"
#include "cmemory.h"
#include "uassert.h"
U_NAMESPACE_BEGIN
DecimalNumberString::DecimalNumberString() {
fLength = 0;
fText[0] = 0;
}
DecimalNumberString::~DecimalNumberString() {
}
DecimalNumberString::DecimalNumberString(const StringPiece &source, UErrorCode &status) {
fLength = 0;
fText[0] = 0;
append(source, status);
}
DecimalNumberString & DecimalNumberString::append(char c, UErrorCode &status) {
if (ensureCapacity(fLength + 2, status) == FALSE) {
return *this;
}
fText[fLength++] = c;
fText[fLength] = 0;
return *this;
}
DecimalNumberString &DecimalNumberString::append(const StringPiece &str, UErrorCode &status) {
int32_t sLength = str.length();
if (ensureCapacity(fLength + sLength + 1, status) == FALSE) {
return *this;
}
uprv_memcpy(&fText[fLength], str.data(), sLength);
fLength += sLength;
fText[fLength] = 0;
return *this;
}
char & DecimalNumberString::operator [] (int32_t index) {
U_ASSERT(index>=0 && index<fLength);
return fText[index];
}
const char & DecimalNumberString::operator [] (int32_t index) const {
U_ASSERT(index>=0 && index<fLength);
return fText[index];
}
int32_t DecimalNumberString::length() const {
return fLength;
}
void DecimalNumberString::setLength(int32_t length, UErrorCode &status) {
if (ensureCapacity(length+1, status) == FALSE) {
return;
}
if (length > fLength) {
uprv_memset(&fText[fLength], length - fLength, 0);
}
fLength = length;
fText[fLength] = 0;
}
DecimalNumberString::operator StringPiece() const {
return StringPiece(fText, fLength);
}
UBool DecimalNumberString::ensureCapacity(int32_t neededSize, UErrorCode &status) {
if (U_FAILURE(status)) {
return FALSE;
}
if (fText.getCapacity() < neededSize) {
char *newBuf = fText.resize(neededSize, fText.getCapacity());
if (newBuf == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return FALSE;
}
U_ASSERT(fText.getCapacity() >= neededSize);
U_ASSERT(fText.getAlias() == newBuf);
}
return TRUE;
}
U_NAMESPACE_END

54
icu4c/source/i18n/decnumstr.h
View file

@ -1,54 +0,0 @@
/*
******************************************************************************
*
* Copyright (C) 2010, International Business Machines
* Corporation and others. All Rights Reserved.
*
******************************************************************************
*
* File decnumstr.h
*
* A simple eight bit char string class.
* Used by decimal number formatting to hold the string form of numbers.
*
* For internal ICU use only. Not public API.
*
* TODO: ICU should have a light-weight general purpose (char *) string class
* available for internal use; this would eliminate the
* need for this class.
*/
#ifndef DECNUMSTR_H
#define DECNUMSTR_H
#include "unicode/utypes.h"
#include "unicode/stringpiece.h"
#include "cmemory.h"
U_NAMESPACE_BEGIN
class DecimalNumberString: public UMemory {
public:
DecimalNumberString();
~DecimalNumberString();
DecimalNumberString(const StringPiece &, UErrorCode &status);
DecimalNumberString &append(char, UErrorCode &status);
DecimalNumberString &append(const StringPiece &s, UErrorCode &status);
char &operator[] (int32_t index);
const char &operator[] (int32_t index) const;
int32_t length() const;
void setLength(int32_t length, UErrorCode &status);
operator StringPiece() const;
private:
int32_t fLength;
MaybeStackArray<char, 40> fText;
UBool ensureCapacity(int32_t neededSize, UErrorCode &status);
};
U_NAMESPACE_END
#endif // DECNUMSTR_H

20
icu4c/source/i18n/digitlst.cpp
View file

@ -28,6 +28,7 @@
#if !UCONFIG_NO_FORMATTING
#include "unicode/putil.h"
#include "charstr.h"
#include "cmemory.h"
#include "cstring.h"
#include "putilimp.h"
@ -525,22 +526,23 @@ int64_t DigitList::getInt64() /*const*/ {
* Format is as defined by the decNumber library, for interchange of
* decimal numbers.
*/
void DigitList::getDecimal(DecimalNumberString &str, UErrorCode &status) {
void DigitList::getDecimal(CharString &str, UErrorCode &status) {
if (U_FAILURE(status)) {
return;
}
// A decimal number in string form can, worst case, be 14 characters longer
// than the number of digits. So says the decNumber library doc.
int32_t maxLength = fDecNumber->digits + 15;
str.setLength(maxLength, status);
int32_t maxLength = fDecNumber->digits + 14;
int32_t capacity = 0;
char *buffer = str.clear().getAppendBuffer(maxLength, 0, capacity, status);
if (U_FAILURE(status)) {
return; // Memory allocation error on growing the string.
}
uprv_decNumberToString(this->fDecNumber, &str[0]);
int32_t len = uprv_strlen(&str[0]);
U_ASSERT(len <= maxLength);
str.setLength(len, status);
U_ASSERT(capacity >= maxLength);
uprv_decNumberToString(this->fDecNumber, buffer);
U_ASSERT(uprv_strlen(buffer) <= maxLength);
str.append(buffer, -1, status);
}
/**
@ -668,7 +670,7 @@ DigitList::set(int64_t source)
/**
* Set the DigitList from a decimal number string.
*
* The incoming string _must_ be nul terminated, even thought it is arriving
* The incoming string _must_ be nul terminated, even though it is arriving
* as a StringPiece because that is what the decNumber library wants.
* We can get away with this for an internal function; it would not
* be acceptable for a public API.

7
icu4c/source/i18n/digitlst.h
View file

@ -32,7 +32,6 @@
#include "decContext.h"
#include "decNumber.h"
#include "cmemory.h"
#include "decnumstr.h"
// Decimal digits in a 64-bit int
#define INT64_DIGITS 19
@ -51,6 +50,8 @@ typedef enum EDigitListValues {
U_NAMESPACE_BEGIN
class CharString;
// Export an explicit template instantiation of the MaybeStackHeaderAndArray that
// is used as a data member of DigitList.
//
@ -202,8 +203,8 @@ public:
/**
* Utility routine to get the value of the digit list as a decimal string.
*/
void getDecimal(DecimalNumberString &str, UErrorCode &status);
*/
void getDecimal(CharString &str, UErrorCode &status);
/**
* Return true if the number represented by this object can fit into

19
icu4c/source/i18n/fmtable.cpp
View file

@ -21,10 +21,10 @@
#include "unicode/ustring.h"
#include "unicode/measure.h"
#include "unicode/curramt.h"
#include "charstr.h"
#include "cmemory.h"
#include "cstring.h"
#include "decNumber.h"
#include "decnumstr.h"
#include "digitlst.h"
// *****************************************************************************
@ -255,7 +255,7 @@ Formattable::operator=(const Formattable& source)
fDecimalNum = new DigitList(*source.fDecimalNum);
}
if (source.fDecimalStr != NULL) {
fDecimalStr = new DecimalNumberString(*source.fDecimalStr, status);
fDecimalStr = new CharString(*source.fDecimalStr, status);
if (U_FAILURE(status)) {
delete fDecimalStr;
fDecimalStr = NULL;
@ -672,7 +672,7 @@ StringPiece Formattable::getDecimalNumber(UErrorCode &status) {
return "";
}
if (fDecimalStr != NULL) {
return *fDecimalStr;
return fDecimalStr->toStringPiece();
}
if (fDecimalNum == NULL) {
@ -704,14 +704,14 @@ StringPiece Formattable::getDecimalNumber(UErrorCode &status) {
}
}
fDecimalStr = new DecimalNumberString;
fDecimalStr = new CharString;
if (fDecimalStr == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return "";
}
fDecimalNum->getDecimal(*fDecimalStr, status);
return *fDecimalStr;
return fDecimalStr->toStringPiece();
}
@ -750,18 +750,13 @@ Formattable::setDecimalNumber(const StringPiece &numberString, UErrorCode &statu
// Copy the input string and nul-terminate it.
// The decNumber library requires nul-terminated input. StringPiece input
// is not guaranteed nul-terminated. Too bad.
// DecimalNumberStrings automatically adds the nul.
DecimalNumberString s(numberString, status);
if (U_FAILURE(status)) {
return;
}
// CharString automatically adds the nul.
DigitList *dnum = new DigitList();
if (dnum == NULL) {
status = U_MEMORY_ALLOCATION_ERROR;
return;
}
dnum->set(s, status);
dnum->set(CharString(numberString, status).toStringPiece(), status);
if (U_FAILURE(status)) {
delete dnum;
return; // String didn't contain a decimal number.

8
icu4c/source/i18n/i18n.vcproj
View file

@ -1426,14 +1426,6 @@
RelativePath=".\decNumberLocal.h"
>
</File>
<File
RelativePath=".\decnumstr.cpp"
>
</File>
<File
RelativePath=".\decnumstr.h"
>
</File>
<File
RelativePath=".\digitlst.cpp"
>

23
icu4c/source/i18n/transreg.cpp
View file

@ -1,6 +1,6 @@
/*
**********************************************************************
* Copyright (c) 2001-2008, International Business Machines
* Copyright (c) 2001-2010, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Date Name Description
@ -239,7 +239,6 @@ TransliteratorSpec::TransliteratorSpec(const UnicodeString& theSpec)
res(0)
{
UErrorCode status = U_ZERO_ERROR;
CharString topch(theSpec);
Locale topLoc("");
LocaleUtility::initLocaleFromName(theSpec, topLoc);
if (!topLoc.isBogus()) {
@ -258,7 +257,8 @@ TransliteratorSpec::TransliteratorSpec(const UnicodeString& theSpec)
status = U_ZERO_ERROR;
static const int32_t capacity = 10;
UScriptCode script[capacity]={USCRIPT_INVALID_CODE};
int32_t num = uscript_getCode(topch,script,capacity, &status);
int32_t num = uscript_getCode(CharString().appendInvariantChars(theSpec, status).data(),
script, capacity, &status);
if (num > 0 && script[0] != USCRIPT_INVALID_CODE) {
scriptName = UnicodeString(uscript_getName(script[0]), -1, US_INV);
}
@ -1079,30 +1079,27 @@ TransliteratorEntry* TransliteratorRegistry::findInBundle(const TransliteratorSp
}
UnicodeString s(specToFind.get());
utag.append(s.toUpper(""));
CharString tag(utag);
UErrorCode status = U_ZERO_ERROR;
ResourceBundle subres(specToOpen.getBundle().get(tag, status));
ResourceBundle subres(specToOpen.getBundle().get(
CharString().appendInvariantChars(utag, status).data(), status));
if (U_FAILURE(status) || status == U_USING_DEFAULT_WARNING) {
continue;
}
s.truncate(0);
if (specToOpen.get() != LocaleUtility::initNameFromLocale(subres.getLocale(), s)) {
continue;
}
if (variant.length() != 0) {
CharString var(variant);
status = U_ZERO_ERROR;
resStr = subres.getStringEx(var, status);
resStr = subres.getStringEx(
CharString().appendInvariantChars(variant, status).data(), status);
if (U_SUCCESS(status)) {
// Exit loop successfully
break;
}
}
else {
} else {
// Variant is empty, which means match the first variant listed.
status = U_ZERO_ERROR;
resStr = subres.getStringEx(1, status);

9
icu4c/source/i18n/unicode/fmtable.h
View file

@ -28,8 +28,8 @@
U_NAMESPACE_BEGIN
class DecimalNumberString;
class DigitList;
class CharString;
class DigitList;
/**
* Formattable objects can be passed to the Format class or
@ -617,7 +617,7 @@ private:
* string or array objects.
*/
void dispose(void);
/**
* Common initialization, for use by constructors.
*/
@ -637,7 +637,7 @@ private:
} fArrayAndCount;
} fValue;
DecimalNumberString *fDecimalStr;
CharString *fDecimalStr;
DigitList *fDecimalNum;
Type fType;
@ -672,4 +672,3 @@ U_NAMESPACE_END
#endif //_FMTABLE
//eof

5
icu4c/source/test/intltest/numfmtst.cpp
View file

@ -1898,7 +1898,7 @@ void NumberFormatTest::TestCases() {
case 1:
// loc= <locale>
if (!tokens.next(tok, ec)) goto error;
loc = Locale::createFromName(CharString(tok));
loc = Locale::createFromName(CharString().appendInvariantChars(tok, ec).data());
break;
case 2: // f:
case 3: // fp:
@ -1965,7 +1965,8 @@ void NumberFormatTest::TestCases() {
mloc = tok;
delete mfmt;
mfmt = MeasureFormat::createCurrencyFormat(
Locale::createFromName(CharString(mloc)), ec);
Locale::createFromName(
CharString().appendInvariantChars(mloc, ec).data()), ec);
if (U_FAILURE(ec)) {
errln("FAIL: " + where + "Loc \"" + mloc + "\": " + u_errorName(ec));
ec = U_ZERO_ERROR;

63
icu4c/source/test/intltest/strtest.cpp
View file

@ -12,14 +12,17 @@
* created by: Markus W. Scherer
*/
#include <string.h>
#include "unicode/utypes.h"
#include "unicode/putil.h"
#include "intltest.h"
#include "strtest.h"
#include "unicode/ustring.h"
#include "unicode/std_string.h"
#include "unicode/stringpiece.h"
#include <string.h>
#include "unicode/unistr.h"
#include "unicode/ustring.h"
#include "charstr.h"
#include "intltest.h"
#include "strtest.h"
StringTest::~StringTest() {}
@ -215,6 +218,12 @@ void StringTest::runIndexedTest(int32_t index, UBool exec, const char *&name, ch
TestStringByteSink();
}
break;
case 14:
name="TestCharString";
if(exec) {
TestCharString();
}
break;
default:
name="";
break;
@ -525,3 +534,49 @@ StringTest::TestSTLCompatibility() {
myvect.push_back(UnicodeString("blah"));
#endif
}
void
StringTest::TestCharString() {
IcuTestErrorCode errorCode(*this, "TestCharString()");
char expected[400];
static const char longStr[] =
"This is a long string that is meant to cause reallocation of the internal buffer of CharString.";
CharString chStr(longStr, errorCode);
if (0 != strcmp(longStr, chStr.data()) || (int32_t)strlen(longStr) != chStr.length()) {
errln("CharString(longStr) failed.");
}
StringPiece sp(chStr.toStringPiece());
sp.remove_prefix(4);
chStr.append(sp, errorCode).append(chStr, errorCode);
strcpy(expected, longStr);
strcat(expected, longStr+4);
strcat(expected, longStr);
strcat(expected, longStr+4);
if (0 != strcmp(expected, chStr.data()) || (int32_t)strlen(expected) != chStr.length()) {
errln("CharString(longStr).append(substring of self).append(self) failed.");
}
chStr.clear().append("abc", errorCode).append("defghij", 3, errorCode);
if (0 != strcmp("abcdef", chStr.data()) || 6 != chStr.length()) {
errln("CharString.clear().append(abc).append(defghij, 3) failed.");
}
chStr.appendInvariantChars(UNICODE_STRING_SIMPLE(
"This is a long string that is meant to cause reallocation of the internal buffer of CharString."),
errorCode);
strcpy(expected, "abcdef");
strcat(expected, longStr);
if (0 != strcmp(expected, chStr.data()) || (int32_t)strlen(expected) != chStr.length()) {
errln("CharString.appendInvariantChars(longStr) failed.");
}
int32_t appendCapacity = 0;
char *buffer = chStr.getAppendBuffer(2, 10, appendCapacity, errorCode);
if (errorCode.isFailure()) {
return;
}
memcpy(buffer, "*****", 5);
chStr.append(buffer, 5, errorCode);
chStr.truncate(chStr.length()-3);
strcat(expected, "**");
if (0 != strcmp(expected, chStr.data()) || (int32_t)strlen(expected) != chStr.length()) {
errln("CharString.getAppendBuffer().append(**) failed.");
}
}

5
icu4c/source/test/intltest/strtest.h
View file

@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-2009, International Business Machines Corporation and
* Copyright (c) 1997-2010, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/* file name: strtest.h
@ -15,7 +15,7 @@
/*
* Test character- and string- related settings in utypes.h,
* macros in putil.h, and constructors in unistr.h .
* Also basic tests for std_string.h .
* Also basic tests for std_string.h and charstr.h .
*/
#ifndef __STRTEST_H__
@ -41,6 +41,7 @@ private:
void TestCheckedArrayByteSink();
void TestStringByteSink();
void TestSTLCompatibility();
void TestCharString();
};
#endif

19
icu4c/source/test/intltest/ustrtest.cpp
View file

@ -58,11 +58,10 @@ void UnicodeStringTest::runIndexedTest( int32_t index, UBool exec, const char* &
case 13: name = "TestUnescape"; if (exec) TestUnescape(); break;
case 14: name = "TestCountChar32"; if (exec) TestCountChar32(); break;
case 15: name = "TestStringEnumeration"; if (exec) TestStringEnumeration(); break;
case 16: name = "TestCharString"; if (exec) TestCharString(); break;
case 17: name = "TestNameSpace"; if (exec) TestNameSpace(); break;
case 18: name = "TestUTF32"; if (exec) TestUTF32(); break;
case 19: name = "TestUTF8"; if (exec) TestUTF8(); break;
case 20: name = "TestReadOnlyAlias"; if (exec) TestReadOnlyAlias(); break;
case 16: name = "TestNameSpace"; if (exec) TestNameSpace(); break;
case 17: name = "TestUTF32"; if (exec) TestUTF32(); break;
case 18: name = "TestUTF8"; if (exec) TestUTF8(); break;
case 19: name = "TestReadOnlyAlias"; if (exec) TestReadOnlyAlias(); break;
default: name = ""; break; //needed to end loop
}
@ -1743,16 +1742,6 @@ UnicodeStringTest::TestStringEnumeration() {
uenum_close(uten);
}
void
UnicodeStringTest::TestCharString() {
static const char originalCStr[] =
"This is a large string that is meant to over flow the internal buffer of CharString. At the time of writing this test, the internal buffer is 128 bytes.";
CharString chStr(originalCStr);
if (strcmp(originalCStr, chStr) != 0) {
errln("CharString doesn't work with large strings.");
}
}
/*
* Namespace test, to make sure that macros like UNICODE_STRING include the
* namespace qualifier.

1
icu4c/source/test/intltest/ustrtest.h
View file

@ -73,7 +73,6 @@ public:
void TestCountChar32(void);
void TestBogus();
void TestStringEnumeration();
void TestCharString(void);
void TestNameSpace(void);
void TestUTF32(void);
void TestUTF8(void);