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

ICU-21833 Replace UChar with char16_t in all C++ code.

Browse source
This commit is contained in:
Fredrik Roubert 2022-12-27 16:54:24 +09:00 • committed by Fredrik Roubert
parent 08f14db4c4
commit 2de88f9d9c
543 changed files with 6133 additions and 6133 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -25,23 +25,23 @@ Appendable::~Appendable() {}
UBool
Appendable::appendCodePoint(UChar32 c) {
if(c<=0xffff) {
return appendCodeUnit((UChar)c);
return appendCodeUnit((char16_t)c);
} else {
return appendCodeUnit(U16_LEAD(c)) && appendCodeUnit(U16_TRAIL(c));
}
}
UBool
Appendable::appendString(const UChar *s, int32_t length) {
Appendable::appendString(const char16_t *s, int32_t length) {
if(length<0) {
UChar c;
char16_t c;
while((c=*s++)!=0) {
if(!appendCodeUnit(c)) {
return false;
}
}
} else if(length>0) {
const UChar *limit=s+length;
const char16_t *limit=s+length;
do {
if(!appendCodeUnit(*s++)) {
return false;
@ -56,10 +56,10 @@ Appendable::reserveAppendCapacity(int32_t /*appendCapacity*/) {
return true;
}
UChar *
char16_t *
Appendable::getAppendBuffer(int32_t minCapacity,
int32_t /*desiredCapacityHint*/,
UChar *scratch, int32_t scratchCapacity,
char16_t *scratch, int32_t scratchCapacity,
int32_t *resultCapacity) {
if(minCapacity<1 || scratchCapacity<minCapacity) {
*resultCapacity=0;

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

@ -319,9 +319,9 @@ BMPSet::contains(UChar32 c) const {
* Check for sufficient length for trail unit for each surrogate pair.
* Handle single surrogates as surrogate code points as usual in ICU.
*/
const UChar *
BMPSet::span(const UChar *s, const UChar *limit, USetSpanCondition spanCondition) const {
UChar c, c2;
const char16_t *
BMPSet::span(const char16_t *s, const char16_t *limit, USetSpanCondition spanCondition) const {
char16_t c, c2;
if(spanCondition) {
// span
@ -408,9 +408,9 @@ BMPSet::span(const UChar *s, const UChar *limit, USetSpanCondition spanCondition
}
/* Symmetrical with span(). */
const UChar *
BMPSet::spanBack(const UChar *s, const UChar *limit, USetSpanCondition spanCondition) const {
UChar c, c2;
const char16_t *
BMPSet::spanBack(const char16_t *s, const char16_t *limit, USetSpanCondition spanCondition) const {
char16_t c, c2;
if(spanCondition) {
// span

4
icu4c/source/common/bmpset.h
View file

@ -48,14 +48,14 @@ public:
* It must be s<limit and spanCondition==0 or 1.
* @return The string pointer which limits the span.
*/
const UChar *span(const UChar *s, const UChar *limit, USetSpanCondition spanCondition) const;
const char16_t *span(const char16_t *s, const char16_t *limit, USetSpanCondition spanCondition) const;
/*
* Span the trailing substring for which each character c has spanCondition==contains(c).
* It must be s<limit and spanCondition==0 or 1.
* @return The string pointer which starts the span.
*/
const UChar *spanBack(const UChar *s, const UChar *limit, USetSpanCondition spanCondition) const;
const char16_t *spanBack(const char16_t *s, const char16_t *limit, USetSpanCondition spanCondition) const;
/*
* Span the initial substring for which each character c has spanCondition==contains(c).

6
icu4c/source/common/brkeng.cpp
View file

@ -250,7 +250,7 @@ ICULanguageBreakFactory::loadDictionaryMatcherFor(UScriptCode script) {
UResourceBundle *b = ures_open(U_ICUDATA_BRKITR, "", &status);
b = ures_getByKeyWithFallback(b, "dictionaries", b, &status);
int32_t dictnlength = 0;
const UChar *dictfname =
const char16_t *dictfname =
ures_getStringByKeyWithFallback(b, uscript_getShortName(script), &dictnlength, &status);
if (U_FAILURE(status)) {
ures_close(b);
@ -258,7 +258,7 @@ ICULanguageBreakFactory::loadDictionaryMatcherFor(UScriptCode script) {
}
CharString dictnbuf;
CharString ext;
const UChar *extStart = u_memrchr(dictfname, 0x002e, dictnlength); // last dot
const char16_t *extStart = u_memrchr(dictfname, 0x002e, dictnlength); // last dot
if (extStart != nullptr) {
int32_t len = (int32_t)(extStart - dictfname);
ext.appendInvariantChars(UnicodeString(false, extStart + 1, dictnlength - len - 1), status);
@ -281,7 +281,7 @@ ICULanguageBreakFactory::loadDictionaryMatcherFor(UScriptCode script) {
m = new BytesDictionaryMatcher(characters, transform, file);
}
else if (trieType == DictionaryData::TRIE_TYPE_UCHARS) {
const UChar *characters = (const UChar *)(data + offset);
const char16_t *characters = (const char16_t *)(data + offset);
m = new UCharsDictionaryMatcher(characters, file);
}
if (m == nullptr) {

4
icu4c/source/common/brkiter.cpp
View file

@ -60,7 +60,7 @@ BreakIterator::buildInstance(const Locale& loc, const char *type, UErrorCode &st
char ext[4]={'\0'};
CharString actualLocale;
int32_t size;
const UChar* brkfname = nullptr;
const char16_t* brkfname = nullptr;
UResourceBundle brkRulesStack;
UResourceBundle brkNameStack;
UResourceBundle *brkRules = &brkRulesStack;
@ -95,7 +95,7 @@ BreakIterator::buildInstance(const Locale& loc, const char *type, UErrorCode &st
if (U_SUCCESS(status) && brkfname) {
actualLocale.append(ures_getLocaleInternal(brkName, &status), -1, status);
UChar* extStart=u_strchr(brkfname, 0x002e);
char16_t* extStart=u_strchr(brkfname, 0x002e);
int len = 0;
if (extStart != nullptr){
len = (int)(extStart-brkfname);

4
icu4c/source/common/bytestriebuilder.cpp
View file

@ -282,7 +282,7 @@ BytesTrieBuilder::getElementStringLength(int32_t i) const {
return elements[i].getStringLength(*strings);
}
UChar
char16_t
BytesTrieBuilder::getElementUnit(int32_t i, int32_t byteIndex) const {
return (uint8_t)elements[i].charAt(byteIndex, *strings);
}
@ -329,7 +329,7 @@ BytesTrieBuilder::skipElementsBySomeUnits(int32_t i, int32_t byteIndex, int32_t
}
int32_t
BytesTrieBuilder::indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, UChar byte) const {
BytesTrieBuilder::indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, char16_t byte) const {
char b=(char)byte;
while(b==elements[i].charAt(byteIndex, *strings)) {
++i;

8
icu4c/source/common/caniter.cpp
View file

@ -352,7 +352,7 @@ UnicodeString* CanonicalIterator::getEquivalents(const UnicodeString &segment, i
permutations.setValueDeleter(uprv_deleteUObject);
basic.setValueDeleter(uprv_deleteUObject);
UChar USeg[256];
char16_t USeg[256];
int32_t segLen = segment.extract(USeg, 256, status);
getEquivalents2(&basic, USeg, segLen, status);
@ -429,7 +429,7 @@ UnicodeString* CanonicalIterator::getEquivalents(const UnicodeString &segment, i
return finalResult;
}
Hashtable *CanonicalIterator::getEquivalents2(Hashtable *fillinResult, const UChar *segment, int32_t segLen, UErrorCode &status) {
Hashtable *CanonicalIterator::getEquivalents2(Hashtable *fillinResult, const char16_t *segment, int32_t segLen, UErrorCode &status) {
if (U_FAILURE(status)) {
return nullptr;
@ -497,7 +497,7 @@ Hashtable *CanonicalIterator::getEquivalents2(Hashtable *fillinResult, const UCh
* (with canonical rearrangement!)
* If so, take the remainder, and return the equivalents
*/
Hashtable *CanonicalIterator::extract(Hashtable *fillinResult, UChar32 comp, const UChar *segment, int32_t segLen, int32_t segmentPos, UErrorCode &status) {
Hashtable *CanonicalIterator::extract(Hashtable *fillinResult, UChar32 comp, const char16_t *segment, int32_t segLen, int32_t segmentPos, UErrorCode &status) {
//Hashtable *CanonicalIterator::extract(UChar32 comp, const UnicodeString &segment, int32_t segLen, int32_t segmentPos, UErrorCode &status) {
//if (PROGRESS) printf(" extract: %s, ", UToS(Tr(UnicodeString(comp))));
//if (PROGRESS) printf("%s, %i\n", UToS(Tr(segment)), segmentPos);
@ -517,7 +517,7 @@ Hashtable *CanonicalIterator::extract(Hashtable *fillinResult, UChar32 comp, con
status = U_MEMORY_ALLOCATION_ERROR;
return nullptr;
}
const UChar *decomp=decompString.getBuffer();
const char16_t *decomp=decompString.getBuffer();
int32_t decompLen=decompString.length();
// See if it matches the start of segment (at segmentPos)

2
icu4c/source/common/characterproperties.cpp
View file

@ -67,7 +67,7 @@ _set_addRange(USet *set, UChar32 start, UChar32 end) {
}
void U_CALLCONV
_set_addString(USet *set, const UChar *str, int32_t length) {
_set_addString(USet *set, const char16_t *str, int32_t length) {
((UnicodeSet *)set)->add(icu::UnicodeString((UBool)(length<0), str, length));
}

2
icu4c/source/common/chariter.cpp
View file

@ -85,7 +85,7 @@ CharacterIterator::operator=(const CharacterIterator &that) {
// implementing first[32]PostInc() directly in a subclass should be faster
// but these implementations make subclassing a little easier
UChar
char16_t
CharacterIterator::firstPostInc(void) {
setToStart();
return nextPostInc();

2
icu4c/source/common/charstr.cpp
View file

@ -200,7 +200,7 @@ CharString &CharString::appendInvariantChars(const UnicodeString &s, UErrorCode
return appendInvariantChars(s.getBuffer(), s.length(), errorCode);
}
CharString &CharString::appendInvariantChars(const UChar* uchars, int32_t ucharsLen, UErrorCode &errorCode) {
CharString &CharString::appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return *this;
}

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

@ -156,7 +156,7 @@ public:
UErrorCode &errorCode);
CharString &appendInvariantChars(const UnicodeString &s, UErrorCode &errorCode);
CharString &appendInvariantChars(const UChar* uchars, int32_t ucharsLen, UErrorCode& errorCode);
CharString &appendInvariantChars(const char16_t* uchars, int32_t ucharsLen, UErrorCode& errorCode);
/**
* Appends a filename/path part, e.g., a directory name.

4
icu4c/source/common/cpputils.h
View file

@ -62,8 +62,8 @@ inline void uprv_arrayCopy(const int32_t* src, int32_t srcStart,
static
inline void
uprv_arrayCopy(const UChar *src, int32_t srcStart,
UChar *dst, int32_t dstStart, int32_t count)
uprv_arrayCopy(const char16_t *src, int32_t srcStart,
char16_t *dst, int32_t dstStart, int32_t count)
{ uprv_memcpy(dst+dstStart, src+srcStart, (size_t)count * sizeof(*src)); }
/**

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

@ -46,7 +46,7 @@ void U_CALLCONV initSingleton(UErrorCode &errorCode) {
// TODO: turn this into a shared helper function
// Requires the major version to match, and then requires at least the minor version.
UBool udata_isAcceptableMajorMinor(
const UDataInfo &info, const UChar *dataFormat, uint8_t major, uint8_t minor) {
const UDataInfo &info, const char16_t *dataFormat, uint8_t major, uint8_t minor) {
return
info.size >= 20 &&
info.isBigEndian == U_IS_BIG_ENDIAN &&
@ -104,7 +104,7 @@ EmojiProps::load(UErrorCode &errorCode) {
offset = inIndexes[i];
nextOffset = inIndexes[i + 1];
// Set/leave nullptr if there is no UCharsTrie.
const UChar *p = nextOffset > offset ? (const UChar *)(inBytes + offset) : nullptr;
const char16_t *p = nextOffset > offset ? (const char16_t *)(inBytes + offset) : nullptr;
stringTries[getStringTrieIndex(i)] = p;
}
}
@ -160,14 +160,14 @@ EmojiProps::hasBinaryPropertyImpl(UChar32 c, UProperty which) const {
}
UBool
EmojiProps::hasBinaryProperty(const UChar *s, int32_t length, UProperty which) {
EmojiProps::hasBinaryProperty(const char16_t *s, int32_t length, UProperty which) {
UErrorCode errorCode = U_ZERO_ERROR;
const EmojiProps *ep = getSingleton(errorCode);
return U_SUCCESS(errorCode) && ep->hasBinaryPropertyImpl(s, length, which);
}
UBool
EmojiProps::hasBinaryPropertyImpl(const UChar *s, int32_t length, UProperty which) const {
EmojiProps::hasBinaryPropertyImpl(const char16_t *s, int32_t length, UProperty which) const {
if (s == nullptr && length != 0) { return false; }
if (length <= 0 && (length == 0 || *s == 0)) { return false; } // empty string
// The caller should have delegated single code points to hasBinaryProperty(c, which).
@ -181,7 +181,7 @@ EmojiProps::hasBinaryPropertyImpl(const UChar *s, int32_t length, UProperty whic
lastProp = UCHAR_RGI_EMOJI_ZWJ_SEQUENCE;
}
for (int32_t prop = firstProp; prop <= lastProp; ++prop) {
const UChar *trieUChars = stringTries[prop - UCHAR_BASIC_EMOJI];
const char16_t *trieUChars = stringTries[prop - UCHAR_BASIC_EMOJI];
if (trieUChars != nullptr) {
UCharsTrie trie(trieUChars);
UStringTrieResult result = trie.next(s, length);
@ -206,7 +206,7 @@ EmojiProps::addStrings(const USetAdder *sa, UProperty which, UErrorCode &errorCo
lastProp = UCHAR_RGI_EMOJI_ZWJ_SEQUENCE;
}
for (int32_t prop = firstProp; prop <= lastProp; ++prop) {
const UChar *trieUChars = stringTries[prop - UCHAR_BASIC_EMOJI];
const char16_t *trieUChars = stringTries[prop - UCHAR_BASIC_EMOJI];
if (trieUChars != nullptr) {
UCharsTrie::Iterator iter(trieUChars, 0, errorCode);
while (iter.next(errorCode)) {

6
icu4c/source/common/emojiprops.h
View file

@ -23,7 +23,7 @@ public:
static const EmojiProps *getSingleton(UErrorCode &errorCode);
static UBool hasBinaryProperty(UChar32 c, UProperty which);
static UBool hasBinaryProperty(const UChar *s, int32_t length, UProperty which);
static UBool hasBinaryProperty(const char16_t *s, int32_t length, UProperty which);
void addPropertyStarts(const USetAdder *sa, UErrorCode &errorCode) const;
void addStrings(const USetAdder *sa, UProperty which, UErrorCode &errorCode) const;
@ -78,11 +78,11 @@ private:
void load(UErrorCode &errorCode);
UBool hasBinaryPropertyImpl(UChar32 c, UProperty which) const;
UBool hasBinaryPropertyImpl(const UChar *s, int32_t length, UProperty which) const;
UBool hasBinaryPropertyImpl(const char16_t *s, int32_t length, UProperty which) const;
UDataMemory *memory = nullptr;
UCPTrie *cpTrie = nullptr;
const UChar *stringTries[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
const char16_t *stringTries[6] = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
};
U_NAMESPACE_END

24
icu4c/source/common/filteredbrk.cpp
View file

@ -130,7 +130,7 @@ static const int32_t kPARTIAL = (1<<0); //< partial - need to run through forwar
static const int32_t kMATCH = (1<<1); //< exact match - skip this one.
static const int32_t kSuppressInReverse = (1<<0);
static const int32_t kAddToForward = (1<<1);
static const UChar kFULLSTOP = 0x002E; // '.'
static const char16_t kFULLSTOP = 0x002E; // '.'
/**
* Shared data for SimpleFilteredSentenceBreakIterator
@ -289,11 +289,11 @@ SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
// Assume a space is following the '.' (so we handle the case: "Mr. /Brown")
if(utext_previous32(fText.getAlias())==u' ') { // TODO: skip a class of chars here??
// TODO only do this the 1st time?
//if(debug2) u_printf("skipping prev: |%C| \n", (UChar)uch);
//if(debug2) u_printf("skipping prev: |%C| \n", (char16_t)uch);
} else {
//if(debug2) u_printf("not skipping prev: |%C| \n", (UChar)uch);
//if(debug2) u_printf("not skipping prev: |%C| \n", (char16_t)uch);
utext_next32(fText.getAlias());
//if(debug2) u_printf(" -> : |%C| \n", (UChar)uch);
//if(debug2) u_printf(" -> : |%C| \n", (char16_t)uch);
}
{
@ -309,20 +309,20 @@ SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
if(!USTRINGTRIE_HAS_NEXT(r)) {
break;
}
//if(debug2) u_printf("rev< /%C/ cont?%d @%d\n", (UChar)uch, r, utext_getNativeIndex(fText.getAlias()));
//if(debug2) u_printf("rev< /%C/ cont?%d @%d\n", (char16_t)uch, r, utext_getNativeIndex(fText.getAlias()));
}
}
//if(bestValue >= 0) {
//if(debug2) u_printf("rev<+/%C/+end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
//if(debug2) u_printf("rev<+/%C/+end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (char16_t)uch, r, bestPosn, bestValue);
//}
if(bestPosn>=0) {
//if(debug2) u_printf("rev< /%C/ end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (UChar)uch, r, bestPosn, bestValue);
//if(debug2) u_printf("rev< /%C/ end of seq.. r=%d, bestPosn=%d, bestValue=%d\n", (char16_t)uch, r, bestPosn, bestValue);
//if(USTRINGTRIE_MATCHES(r)) { // matched - so, now what?
//int32_t bestValue = iter.getValue();
////if(debug2) u_printf("rev< /%C/ matched, skip..%d bestValue=%d\n", (UChar)uch, r, bestValue);
////if(debug2) u_printf("rev< /%C/ matched, skip..%d bestValue=%d\n", (char16_t)uch, r, bestValue);
if(bestValue == kMATCH) { // exact match!
//if(debug2) u_printf(" exact backward match\n");
@ -340,15 +340,15 @@ SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
UChar32 uch;
while((uch=utext_next32(fText.getAlias()))!=U_SENTINEL &&
USTRINGTRIE_HAS_NEXT(rfwd=iter.nextForCodePoint(uch))) {
//if(debug2) u_printf("fwd> /%C/ cont?%d @%d\n", (UChar)uch, rfwd, utext_getNativeIndex(fText.getAlias()));
//if(debug2) u_printf("fwd> /%C/ cont?%d @%d\n", (char16_t)uch, rfwd, utext_getNativeIndex(fText.getAlias()));
}
if(USTRINGTRIE_MATCHES(rfwd)) {
//if(debug2) u_printf("fwd> /%C/ == forward match!\n", (UChar)uch);
//if(debug2) u_printf("fwd> /%C/ == forward match!\n", (char16_t)uch);
// only full matches here, nothing to check
// skip the next:
return kExceptionHere;
} else {
//if(debug2) u_printf("fwd> /%C/ no match.\n", (UChar)uch);
//if(debug2) u_printf("fwd> /%C/ no match.\n", (char16_t)uch);
// no match (no exception) -return the 'underlying' break
return kNoExceptionHere;
}
@ -356,7 +356,7 @@ SimpleFilteredSentenceBreakIterator::breakExceptionAt(int32_t n) {
return kNoExceptionHere; // internal error and/or no forwards trie
}
} else {
//if(debug2) u_printf("rev< /%C/ .. no match..%d\n", (UChar)uch, r); // no best match
//if(debug2) u_printf("rev< /%C/ .. no match..%d\n", (char16_t)uch, r); // no best match
return kNoExceptionHere; // No match - so exit. Not an exception.
}
}

68
icu4c/source/common/locdispnames.cpp
View file

@ -55,7 +55,7 @@ Locale::getDisplayLanguage(UnicodeString& dispLang) const
UnicodeString&
Locale::getDisplayLanguage(const Locale &displayLocale,
UnicodeString &result) const {
UChar *buffer;
char16_t *buffer;
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length;
@ -95,7 +95,7 @@ Locale::getDisplayScript(UnicodeString& dispScript) const
UnicodeString&
Locale::getDisplayScript(const Locale &displayLocale,
UnicodeString &result) const {
UChar *buffer;
char16_t *buffer;
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length;
@ -135,7 +135,7 @@ Locale::getDisplayCountry(UnicodeString& dispCntry) const
UnicodeString&
Locale::getDisplayCountry(const Locale &displayLocale,
UnicodeString &result) const {
UChar *buffer;
char16_t *buffer;
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length;
@ -175,7 +175,7 @@ Locale::getDisplayVariant(UnicodeString& dispVar) const
UnicodeString&
Locale::getDisplayVariant(const Locale &displayLocale,
UnicodeString &result) const {
UChar *buffer;
char16_t *buffer;
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length;
@ -215,7 +215,7 @@ Locale::getDisplayName( UnicodeString& name ) const
UnicodeString&
Locale::getDisplayName(const Locale &displayLocale,
UnicodeString &result) const {
UChar *buffer;
char16_t *buffer;
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length;
@ -302,9 +302,9 @@ _getStringOrCopyKey(const char *path, const char *locale,
const char* subTableKey,
const char *itemKey,
const char *substitute,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode) {
const UChar *s = nullptr;
const char16_t *s = nullptr;
int32_t length = 0;
if(itemKey==nullptr) {
@ -362,7 +362,7 @@ typedef int32_t U_CALLCONV UDisplayNameGetter(const char *, char *, int32_t, UE
static int32_t
_getDisplayNameForComponent(const char *locale,
const char *displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UDisplayNameGetter *getter,
const char *tag,
UErrorCode *pErrorCode) {
@ -408,7 +408,7 @@ _getDisplayNameForComponent(const char *locale,
U_CAPI int32_t U_EXPORT2
uloc_getDisplayLanguage(const char *locale,
const char *displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode) {
return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
uloc_getLanguage, _kLanguages, pErrorCode);
@ -417,7 +417,7 @@ uloc_getDisplayLanguage(const char *locale,
U_CAPI int32_t U_EXPORT2
uloc_getDisplayScript(const char* locale,
const char* displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode)
{
UErrorCode err = U_ZERO_ERROR;
@ -442,7 +442,7 @@ uloc_getDisplayScript(const char* locale,
static int32_t
uloc_getDisplayScriptInContext(const char* locale,
const char* displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode)
{
return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
@ -452,7 +452,7 @@ uloc_getDisplayScriptInContext(const char* locale,
U_CAPI int32_t U_EXPORT2
uloc_getDisplayCountry(const char *locale,
const char *displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode) {
return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
uloc_getCountry, _kCountries, pErrorCode);
@ -466,7 +466,7 @@ uloc_getDisplayCountry(const char *locale,
U_CAPI int32_t U_EXPORT2
uloc_getDisplayVariant(const char *locale,
const char *displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode) {
return _getDisplayNameForComponent(locale, displayLocale, dest, destCapacity,
uloc_getVariant, _kVariants, pErrorCode);
@ -487,14 +487,14 @@ uloc_getDisplayVariant(const char *locale,
U_CAPI int32_t U_EXPORT2
uloc_getDisplayName(const char *locale,
const char *displayLocale,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
UErrorCode *pErrorCode)
{
static const UChar defaultSeparator[9] = { 0x007b, 0x0030, 0x007d, 0x002c, 0x0020, 0x007b, 0x0031, 0x007d, 0x0000 }; /* "{0}, {1}" */
static const UChar sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */
static const UChar sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */
static const char16_t defaultSeparator[9] = { 0x007b, 0x0030, 0x007d, 0x002c, 0x0020, 0x007b, 0x0031, 0x007d, 0x0000 }; /* "{0}, {1}" */
static const char16_t sub0[4] = { 0x007b, 0x0030, 0x007d , 0x0000 } ; /* {0} */
static const char16_t sub1[4] = { 0x007b, 0x0031, 0x007d , 0x0000 } ; /* {1} */
static const int32_t subLen = 3;
static const UChar defaultPattern[10] = {
static const char16_t defaultPattern[10] = {
0x007b, 0x0030, 0x007d, 0x0020, 0x0028, 0x007b, 0x0031, 0x007d, 0x0029, 0x0000
}; /* {0} ({1}) */
static const int32_t defaultPatLen = 9;
@ -503,16 +503,16 @@ uloc_getDisplayName(const char *locale,
int32_t length; /* of formatted result */
const UChar *separator;
const char16_t *separator;
int32_t sepLen = 0;
const UChar *pattern;
const char16_t *pattern;
int32_t patLen = 0;
int32_t sub0Pos, sub1Pos;
UChar formatOpenParen = 0x0028; // (
UChar formatReplaceOpenParen = 0x005B; // [
UChar formatCloseParen = 0x0029; // )
UChar formatReplaceCloseParen = 0x005D; // ]
char16_t formatOpenParen = 0x0028; // (
char16_t formatReplaceOpenParen = 0x005B; // [
char16_t formatCloseParen = 0x0029; // )
char16_t formatReplaceCloseParen = 0x005D; // ]
UBool haveLang = true; /* assume true, set false if we find we don't have
a lang component in the locale */
@ -557,13 +557,13 @@ uloc_getDisplayName(const char *locale,
* This is similar to how pattern is handled below.
*/
{
UChar *p0=u_strstr(separator, sub0);
UChar *p1=u_strstr(separator, sub1);
char16_t *p0=u_strstr(separator, sub0);
char16_t *p1=u_strstr(separator, sub1);
if (p0==nullptr || p1==nullptr || p1<p0) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
separator = (const UChar *)p0 + subLen;
separator = (const char16_t *)p0 + subLen;
sepLen = static_cast<int32_t>(p1 - separator);
}
@ -574,8 +574,8 @@ uloc_getDisplayName(const char *locale,
sub1Pos=defaultSub1Pos;
// use default formatOpenParen etc. set above
} else { /* non-default pattern */
UChar *p0=u_strstr(pattern, sub0);
UChar *p1=u_strstr(pattern, sub1);
char16_t *p0=u_strstr(pattern, sub0);
char16_t *p1=u_strstr(pattern, sub1);
if (p0==nullptr || p1==nullptr) {
*pErrorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
@ -602,7 +602,7 @@ uloc_getDisplayName(const char *locale,
* adjust the parameters so padding is not added, and repeat.
*/
do {
UChar* p=dest;
char16_t* p=dest;
int32_t patPos=0; /* position in the pattern, used for non-substitution portions */
int32_t langLen=0; /* length of language substitution */
int32_t langPos=0; /* position in output of language substitution */
@ -712,7 +712,7 @@ uloc_getDisplayName(const char *locale,
if (len>0) {
/* we added a component, so add separator and write it if there's room. */
if(len+sepLen<=cap) {
const UChar * plimit = p + len;
const char16_t * plimit = p + len;
for (; p < plimit; p++) {
if (*p == formatOpenParen) {
*p = formatReplaceOpenParen;
@ -788,7 +788,7 @@ uloc_getDisplayName(const char *locale,
U_CAPI int32_t U_EXPORT2
uloc_getDisplayKeyword(const char* keyword,
const char* displayLocale,
UChar* dest,
char16_t* dest,
int32_t destCapacity,
UErrorCode* status){
@ -820,7 +820,7 @@ U_CAPI int32_t U_EXPORT2
uloc_getDisplayKeywordValue( const char* locale,
const char* keyword,
const char* displayLocale,
UChar* dest,
char16_t* dest,
int32_t destCapacity,
UErrorCode* status){
@ -849,7 +849,7 @@ uloc_getDisplayKeywordValue( const char* locale,
if(uprv_stricmp(keyword, _kCurrency)==0){
int32_t dispNameLen = 0;
const UChar *dispName = nullptr;
const char16_t *dispName = nullptr;
icu::LocalUResourceBundlePointer bundle(
ures_open(U_ICUDATA_CURR, displayLocale, status));

42
icu4c/source/common/locdspnm.cpp
View file

@ -125,7 +125,7 @@ ICUDataTable::get(const char* tableKey, const char* subTableKey, const char* ite
UErrorCode status = U_ZERO_ERROR;
int32_t len = 0;
const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
const char16_t *s = uloc_getTableStringWithFallback(path, locale.getName(),
tableKey, subTableKey, itemKey,
&len, &status);
if (U_SUCCESS(status) && len > 0) {
@ -140,7 +140,7 @@ ICUDataTable::getNoFallback(const char* tableKey, const char* subTableKey, const
UErrorCode status = U_ZERO_ERROR;
int32_t len = 0;
const UChar *s = uloc_getTableStringWithFallback(path, locale.getName(),
const char16_t *s = uloc_getTableStringWithFallback(path, locale.getName(),
tableKey, subTableKey, itemKey,
&len, &status);
if (U_SUCCESS(status)) {
@ -467,16 +467,16 @@ LocaleDisplayNamesImpl::initialize(void) {
pattern = UnicodeString("{0} ({1})", -1, US_INV);
}
format.applyPatternMinMaxArguments(pattern, 2, 2, status);
if (pattern.indexOf((UChar)0xFF08) >= 0) {
formatOpenParen.setTo((UChar)0xFF08); // fullwidth (
formatReplaceOpenParen.setTo((UChar)0xFF3B); // fullwidth [
formatCloseParen.setTo((UChar)0xFF09); // fullwidth )
formatReplaceCloseParen.setTo((UChar)0xFF3D); // fullwidth ]
if (pattern.indexOf((char16_t)0xFF08) >= 0) {
formatOpenParen.setTo((char16_t)0xFF08); // fullwidth (
formatReplaceOpenParen.setTo((char16_t)0xFF3B); // fullwidth [
formatCloseParen.setTo((char16_t)0xFF09); // fullwidth )
formatReplaceCloseParen.setTo((char16_t)0xFF3D); // fullwidth ]
} else {
formatOpenParen.setTo((UChar)0x0028); // (
formatReplaceOpenParen.setTo((UChar)0x005B); // [
formatCloseParen.setTo((UChar)0x0029); // )
formatReplaceCloseParen.setTo((UChar)0x005D); // ]
formatOpenParen.setTo((char16_t)0x0028); // (
formatReplaceOpenParen.setTo((char16_t)0x005B); // [
formatCloseParen.setTo((char16_t)0x0029); // )
formatReplaceCloseParen.setTo((char16_t)0x005D); // ]
}
UnicodeString ktPattern;
@ -680,7 +680,7 @@ LocaleDisplayNamesImpl::localeDisplayName(const Locale& loc,
appendWithSep(resultRemainder, temp3);
} else {
appendWithSep(resultRemainder, temp)
.append((UChar)0x3d /* = */)
.append((char16_t)0x3d /* = */)
.append(temp2);
}
}
@ -879,7 +879,7 @@ LocaleDisplayNamesImpl::keyValueDisplayName(const char* key,
UErrorCode sts = U_ZERO_ERROR;
UnicodeString ustrValue(value, -1, US_INV);
int32_t len;
const UChar *currencyName = ucurr_getName(ustrValue.getTerminatedBuffer(),
const char16_t *currencyName = ucurr_getName(ustrValue.getTerminatedBuffer(),
locale.getBaseName(), UCURR_LONG_NAME, nullptr /* isChoiceFormat */, &len, &sts);
if (U_FAILURE(sts)) {
// Return the value as is on failure
@ -995,7 +995,7 @@ uldn_getContext(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
const char *locale,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
@ -1017,7 +1017,7 @@ uldn_localeDisplayName(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
const char *lang,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
@ -1035,7 +1035,7 @@ uldn_languageDisplayName(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
const char *script,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
@ -1053,7 +1053,7 @@ uldn_scriptDisplayName(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
UScriptCode scriptCode,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
return uldn_scriptDisplayName(ldn, uscript_getName(scriptCode), result, maxResultSize, pErrorCode);
@ -1062,7 +1062,7 @@ uldn_scriptCodeDisplayName(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
const char *region,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
@ -1080,7 +1080,7 @@ uldn_regionDisplayName(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
const char *variant,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
@ -1098,7 +1098,7 @@ uldn_variantDisplayName(const ULocaleDisplayNames *ldn,
U_CAPI int32_t U_EXPORT2
uldn_keyDisplayName(const ULocaleDisplayNames *ldn,
const char *key,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {
@ -1117,7 +1117,7 @@ U_CAPI int32_t U_EXPORT2
uldn_keyValueDisplayName(const ULocaleDisplayNames *ldn,
const char *key,
const char *value,
UChar *result,
char16_t *result,
int32_t maxResultSize,
UErrorCode *pErrorCode) {
if (U_FAILURE(*pErrorCode)) {

2
icu4c/source/common/loclikely.cpp
View file

@ -58,7 +58,7 @@ findLikelySubtags(const char* localeID,
if (!U_FAILURE(*err)) {
int32_t resLen = 0;
const UChar* s = nullptr;
const char16_t* s = nullptr;
UErrorCode tmpErr = U_ZERO_ERROR;
icu::LocalUResourceBundlePointer subtags(ures_openDirect(nullptr, "likelySubtags", &tmpErr));
if (U_SUCCESS(tmpErr)) {

8
icu4c/source/common/locresdata.cpp
View file

@ -41,7 +41,7 @@
* default locale because that would result in a mix of languages that is
* unpredictable to the programmer and most likely useless.
*/
U_CAPI const UChar * U_EXPORT2
U_CAPI const char16_t * U_EXPORT2
uloc_getTableStringWithFallback(const char *path, const char *locale,
const char *tableKey, const char *subTableKey,
const char *itemKey,
@ -49,7 +49,7 @@ uloc_getTableStringWithFallback(const char *path, const char *locale,
UErrorCode *pErrorCode)
{
/* char localeBuffer[ULOC_FULLNAME_CAPACITY*4];*/
const UChar *item=nullptr;
const char16_t *item=nullptr;
UErrorCode errorCode;
char explicitFallbackName[ULOC_FULLNAME_CAPACITY] = {0};
@ -117,7 +117,7 @@ uloc_getTableStringWithFallback(const char *path, const char *locale,
/* still can't figure out ?.. try the fallback mechanism */
int32_t len = 0;
const UChar* fallbackLocale = nullptr;
const char16_t* fallbackLocale = nullptr;
*pErrorCode = errorCode;
errorCode = U_ZERO_ERROR;
@ -162,7 +162,7 @@ _uloc_getOrientationHelper(const char* localeId,
uloc_canonicalize(localeId, localeBuffer, sizeof(localeBuffer), status);
if (!U_FAILURE(*status)) {
const UChar* const value =
const char16_t* const value =
uloc_getTableStringWithFallback(
nullptr,
localeBuffer,

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

@ -24,9 +24,9 @@
static icu::UInitOnce LocaleUtilityInitOnce {};
static icu::Hashtable * LocaleUtility_cache = nullptr;
#define UNDERSCORE_CHAR ((UChar)0x005f)
#define AT_SIGN_CHAR ((UChar)64)
#define PERIOD_CHAR ((UChar)46)
#define UNDERSCORE_CHAR ((char16_t)0x005f)
#define AT_SIGN_CHAR ((char16_t)64)
#define PERIOD_CHAR ((char16_t)46)
/*
******************************************************************
@ -94,14 +94,14 @@ LocaleUtility::canonicalLocaleString(const UnicodeString* id, UnicodeString& res
n = end;
}
for (; i < n; ++i) {
UChar c = result.charAt(i);
char16_t c = result.charAt(i);
if (c >= 0x0041 && c <= 0x005a) {
c += 0x20;
result.setCharAt(i, c);
}
}
for (n = end; i < n; ++i) {
UChar c = result.charAt(i);
char16_t c = result.charAt(i);
if (c >= 0x0061 && c <= 0x007a) {
c -= 0x20;
result.setCharAt(i, c);
@ -112,7 +112,7 @@ LocaleUtility::canonicalLocaleString(const UnicodeString* id, UnicodeString& res
#if 0
// This code does a proper full level 2 canonicalization of id.
// It's nasty to go from UChar to char to char to UChar -- but
// It's nasty to go from char16_t to char to char to char16_t -- but
// that's what you have to do to use the uloc_canonicalize
// function on UnicodeStrings.
@ -172,7 +172,7 @@ LocaleUtility::initLocaleFromName(const UnicodeString& id, Locale& result)
int32_t prev, i;
prev = 0;
for(;;) {
i = id.indexOf((UChar)0x40, prev);
i = id.indexOf((char16_t)0x40, prev);
if(i < 0) {
// no @ between prev and the rest of the string
id.extract(prev, INT32_MAX, buffer + prev, BUFLEN - prev, US_INV);
@ -232,7 +232,7 @@ LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID)
const char* path = cbundleID.isEmpty() ? nullptr : cbundleID.data();
icu::LocalUEnumerationPointer uenum(ures_openAvailableLocales(path, &status));
for (;;) {
const UChar* id = uenum_unext(uenum.getAlias(), nullptr, &status);
const char16_t* id = uenum_unext(uenum.getAlias(), nullptr, &status);
if (id == nullptr) {
break;
}

18
icu4c/source/common/lstmbe.cpp
View file

@ -361,7 +361,7 @@ struct LSTMData : public UMemory {
~LSTMData();
UHashtable* fDict;
EmbeddingType fType;
const UChar* fName;
const char16_t* fName;
ConstArray2D fEmbedding;
ConstArray2D fForwardW;
ConstArray2D fForwardU;
@ -394,7 +394,7 @@ LSTMData::LSTMData(UResourceBundle* rb, UErrorCode &status)
ures_getByKey(rb, "hunits", nullptr, &status));
if (U_FAILURE(status)) return;
int32_t hunits = ures_getInt(hunits_res.getAlias(), &status);
const UChar* type = ures_getStringByKey(rb, "type", nullptr, &status);
const char16_t* type = ures_getStringByKey(rb, "type", nullptr, &status);
if (U_FAILURE(status)) return;
if (u_strCompare(type, -1, u"codepoints", -1, false) == 0) {
fType = CODE_POINTS;
@ -419,7 +419,7 @@ LSTMData::LSTMData(UResourceBundle* rb, UErrorCode &status)
int32_t stringLength;
for (int32_t idx = 0; idx < num_index; idx++) {
stringArray.getValue(idx, value);
const UChar* str = value.getString(stringLength, status);
const char16_t* str = value.getString(stringLength, status);
uhash_putiAllowZero(fDict, (void*)str, idx, &status);
if (U_FAILURE(status)) return;
#ifdef LSTM_VECTORIZER_DEBUG
@ -477,7 +477,7 @@ public:
UVector32 &offsets, UVector32 &indices,
UErrorCode &status) const = 0;
protected:
int32_t stringToIndex(const UChar* str) const {
int32_t stringToIndex(const char16_t* str) const {
UBool found = false;
int32_t ret = uhash_getiAndFound(fDict, (const void*)str, &found);
if (!found) {
@ -524,13 +524,13 @@ void CodePointsVectorizer::vectorize(
if (U_FAILURE(status)) return;
utext_setNativeIndex(text, startPos);
int32_t current;
UChar str[2] = {0, 0};
char16_t str[2] = {0, 0};
while (U_SUCCESS(status) &&
(current = (int32_t)utext_getNativeIndex(text)) < endPos) {
// Since the LSTMBreakEngine is currently only accept chars in BMP,
// we can ignore the possibility of hitting supplementary code
// point.
str[0] = (UChar) utext_next32(text);
str[0] = (char16_t) utext_next32(text);
U_ASSERT(!U_IS_SURROGATE(str[0]));
offsets.addElement(current, status);
indices.addElement(stringToIndex(str), status);
@ -576,7 +576,7 @@ void GraphemeClusterVectorizer::vectorize(
}
int32_t last = startPos;
int32_t current = startPos;
UChar str[MAX_GRAPHEME_CLSTER_LENGTH];
char16_t str[MAX_GRAPHEME_CLSTER_LENGTH];
while ((current = graphemeIter->next()) != BreakIterator::DONE) {
if (current >= endPos) {
break;
@ -777,7 +777,7 @@ LSTMBreakEngine::~LSTMBreakEngine() {
delete fVectorizer;
}
const UChar* LSTMBreakEngine::name() const {
const char16_t* LSTMBreakEngine::name() const {
return fData->fName;
}
@ -846,7 +846,7 @@ U_CAPI void U_EXPORT2 DeleteLSTMData(const LSTMData* data)
delete data;
}
U_CAPI const UChar* U_EXPORT2 LSTMDataName(const LSTMData* data)
U_CAPI const char16_t* U_EXPORT2 LSTMDataName(const LSTMData* data)
{
return data->fName;
}

124
icu4c/source/common/messagepattern.cpp
View file

@ -32,56 +32,56 @@ U_NAMESPACE_BEGIN
// Unicode character/code point constants ---------------------------------- ***
static const UChar u_pound=0x23;
static const UChar u_apos=0x27;
static const UChar u_plus=0x2B;
static const UChar u_comma=0x2C;
static const UChar u_minus=0x2D;
static const UChar u_dot=0x2E;
static const UChar u_colon=0x3A;
static const UChar u_lessThan=0x3C;
static const UChar u_equal=0x3D;
static const UChar u_A=0x41;
static const UChar u_C=0x43;
static const UChar u_D=0x44;
static const UChar u_E=0x45;
static const UChar u_H=0x48;
static const UChar u_I=0x49;
static const UChar u_L=0x4C;
static const UChar u_N=0x4E;
static const UChar u_O=0x4F;
static const UChar u_P=0x50;
static const UChar u_R=0x52;
static const UChar u_S=0x53;
static const UChar u_T=0x54;
static const UChar u_U=0x55;
static const UChar u_Z=0x5A;
static const UChar u_a=0x61;
static const UChar u_c=0x63;
static const UChar u_d=0x64;
static const UChar u_e=0x65;
static const UChar u_f=0x66;
static const UChar u_h=0x68;
static const UChar u_i=0x69;
static const UChar u_l=0x6C;
static const UChar u_n=0x6E;
static const UChar u_o=0x6F;
static const UChar u_p=0x70;
static const UChar u_r=0x72;
static const UChar u_s=0x73;
static const UChar u_t=0x74;
static const UChar u_u=0x75;
static const UChar u_z=0x7A;
static const UChar u_leftCurlyBrace=0x7B;
static const UChar u_pipe=0x7C;
static const UChar u_rightCurlyBrace=0x7D;
static const UChar u_lessOrEqual=0x2264; // U+2264 is <=
static const char16_t u_pound=0x23;
static const char16_t u_apos=0x27;
static const char16_t u_plus=0x2B;
static const char16_t u_comma=0x2C;
static const char16_t u_minus=0x2D;
static const char16_t u_dot=0x2E;
static const char16_t u_colon=0x3A;
static const char16_t u_lessThan=0x3C;
static const char16_t u_equal=0x3D;
static const char16_t u_A=0x41;
static const char16_t u_C=0x43;
static const char16_t u_D=0x44;
static const char16_t u_E=0x45;
static const char16_t u_H=0x48;
static const char16_t u_I=0x49;
static const char16_t u_L=0x4C;
static const char16_t u_N=0x4E;
static const char16_t u_O=0x4F;
static const char16_t u_P=0x50;
static const char16_t u_R=0x52;
static const char16_t u_S=0x53;
static const char16_t u_T=0x54;
static const char16_t u_U=0x55;
static const char16_t u_Z=0x5A;
static const char16_t u_a=0x61;
static const char16_t u_c=0x63;
static const char16_t u_d=0x64;
static const char16_t u_e=0x65;
static const char16_t u_f=0x66;
static const char16_t u_h=0x68;
static const char16_t u_i=0x69;
static const char16_t u_l=0x6C;
static const char16_t u_n=0x6E;
static const char16_t u_o=0x6F;
static const char16_t u_p=0x70;
static const char16_t u_r=0x72;
static const char16_t u_s=0x73;
static const char16_t u_t=0x74;
static const char16_t u_u=0x75;
static const char16_t u_z=0x7A;
static const char16_t u_leftCurlyBrace=0x7B;
static const char16_t u_pipe=0x7C;
static const char16_t u_rightCurlyBrace=0x7D;
static const char16_t u_lessOrEqual=0x2264; // U+2264 is <=
static const UChar kOffsetColon[]={ // "offset:"
static const char16_t kOffsetColon[]={ // "offset:"
u_o, u_f, u_f, u_s, u_e, u_t, u_colon
};
static const UChar kOther[]={ // "other"
static const char16_t kOther[]={ // "other"
u_o, u_t, u_h, u_e, u_r
};
@ -351,7 +351,7 @@ MessagePattern::autoQuoteApostropheDeep() const {
for(int32_t i=count; i>0;) {
const Part &part=getPart(--i);
if(part.getType()==UMSGPAT_PART_TYPE_INSERT_CHAR) {
modified.insert(part.index, (UChar)part.value);
modified.insert(part.index, (char16_t)part.value);
}
}
return modified;
@ -451,7 +451,7 @@ MessagePattern::parseMessage(int32_t index, int32_t msgStartLength,
if(index>=msg.length()) {
break;
}
UChar c=msg.charAt(index++);
char16_t c=msg.charAt(index++);
if(c==u_apos) {
if(index==msg.length()) {
// The apostrophe is the last character in the pattern.
@ -582,7 +582,7 @@ MessagePattern::parseArg(int32_t index, int32_t argStartLength, int32_t nestingL
errorCode=U_UNMATCHED_BRACES;
return 0;
}
UChar c=msg.charAt(index);
char16_t c=msg.charAt(index);
if(c==u_rightCurlyBrace) {
// all done
} else if(c!=u_comma) {
@ -663,7 +663,7 @@ MessagePattern::parseSimpleStyle(int32_t index, UParseError *parseError, UErrorC
int32_t start=index;
int32_t nestedBraces=0;
while(index<msg.length()) {
UChar c=msg.charAt(index++);
char16_t c=msg.charAt(index++);
if(c==u_apos) {
// Treat apostrophe as quoting but include it in the style part.
// Find the end of the quoted literal text.
@ -738,7 +738,7 @@ MessagePattern::parseChoiceStyle(int32_t index, int32_t nestingLevel,
errorCode=U_PATTERN_SYNTAX_ERROR;
return 0;
}
UChar c=msg.charAt(index);
char16_t c=msg.charAt(index);
if(!(c==u_pound || c==u_lessThan || c==u_lessOrEqual)) { // U+2264 is <=
setParseError(parseError, start); // Expected choice separator (#<\u2264) instead of c.
errorCode=U_PATTERN_SYNTAX_ERROR;
@ -895,7 +895,7 @@ MessagePattern::parseArgNumber(const UnicodeString &s, int32_t start, int32_t li
int32_t number;
// Defer numeric errors until we know there are only digits.
UBool badNumber;
UChar c=s.charAt(start++);
char16_t c=s.charAt(start++);
if(c==0x30) {
if(start==limit) {
return 0;
@ -941,7 +941,7 @@ MessagePattern::parseDouble(int32_t start, int32_t limit, UBool allowInfinity,
int32_t value=0;
int32_t isNegative=0; // not boolean so that we can easily add it to value
int32_t index=start;
UChar c=msg.charAt(index++);
char16_t c=msg.charAt(index++);
if(c==u_minus) {
isNegative=1;
if(index==limit) {
@ -1004,17 +1004,17 @@ MessagePattern::parseDouble(int32_t start, int32_t limit, UBool allowInfinity,
int32_t
MessagePattern::skipWhiteSpace(int32_t index) {
const UChar *s=msg.getBuffer();
const char16_t *s=msg.getBuffer();
int32_t msgLength=msg.length();
const UChar *t=PatternProps::skipWhiteSpace(s+index, msgLength-index);
const char16_t *t=PatternProps::skipWhiteSpace(s+index, msgLength-index);
return (int32_t)(t-s);
}
int32_t
MessagePattern::skipIdentifier(int32_t index) {
const UChar *s=msg.getBuffer();
const char16_t *s=msg.getBuffer();
int32_t msgLength=msg.length();
const UChar *t=PatternProps::skipIdentifier(s+index, msgLength-index);
const char16_t *t=PatternProps::skipIdentifier(s+index, msgLength-index);
return (int32_t)(t-s);
}
@ -1022,7 +1022,7 @@ int32_t
MessagePattern::skipDouble(int32_t index) {
int32_t msgLength=msg.length();
while(index<msgLength) {
UChar c=msg.charAt(index);
char16_t c=msg.charAt(index);
// U+221E: Allow the infinity symbol, for ChoiceFormat patterns.
if((c<0x30 && c!=u_plus && c!=u_minus && c!=u_dot) || (c>0x39 && c!=u_e && c!=u_E && c!=0x221e)) {
break;
@ -1039,7 +1039,7 @@ MessagePattern::isArgTypeChar(UChar32 c) {
UBool
MessagePattern::isChoice(int32_t index) {
UChar c;
char16_t c;
return
((c=msg.charAt(index++))==u_c || c==u_C) &&
((c=msg.charAt(index++))==u_h || c==u_H) &&
@ -1051,7 +1051,7 @@ MessagePattern::isChoice(int32_t index) {
UBool
MessagePattern::isPlural(int32_t index) {
UChar c;
char16_t c;
return
((c=msg.charAt(index++))==u_p || c==u_P) &&
((c=msg.charAt(index++))==u_l || c==u_L) &&
@ -1063,7 +1063,7 @@ MessagePattern::isPlural(int32_t index) {
UBool
MessagePattern::isSelect(int32_t index) {
UChar c;
char16_t c;
return
((c=msg.charAt(index++))==u_s || c==u_S) &&
((c=msg.charAt(index++))==u_e || c==u_E) &&
@ -1075,7 +1075,7 @@ MessagePattern::isSelect(int32_t index) {
UBool
MessagePattern::isOrdinal(int32_t index) {
UChar c;
char16_t c;
return
((c=msg.charAt(index++))==u_o || c==u_O) &&
((c=msg.charAt(index++))==u_r || c==u_R) &&

54
icu4c/source/common/norm2allmodes.h
View file

@ -43,7 +43,7 @@ public:
dest.setToBogus();
return dest;
}
const UChar *sArray=src.getBuffer();
const char16_t *sArray=src.getBuffer();
if(&dest==&src || sArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
dest.setToBogus();
@ -57,7 +57,7 @@ public:
return dest;
}
virtual void
normalize(const UChar *src, const UChar *limit,
normalize(const char16_t *src, const char16_t *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
// normalize and append
@ -82,7 +82,7 @@ public:
if(U_FAILURE(errorCode)) {
return first;
}
const UChar *secondArray=second.getBuffer();
const char16_t *secondArray=second.getBuffer();
if(&first==&second || secondArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return first;
@ -103,14 +103,14 @@ public:
return first;
}
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
normalizeAndAppend(const char16_t *src, const char16_t *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const = 0;
virtual UBool
getDecomposition(UChar32 c, UnicodeString &decomposition) const U_OVERRIDE {
UChar buffer[4];
char16_t buffer[4];
int32_t length;
const UChar *d=impl.getDecomposition(c, buffer, length);
const char16_t *d=impl.getDecomposition(c, buffer, length);
if(d==nullptr) {
return false;
}
@ -123,9 +123,9 @@ public:
}
virtual UBool
getRawDecomposition(UChar32 c, UnicodeString &decomposition) const U_OVERRIDE {
UChar buffer[30];
char16_t buffer[30];
int32_t length;
const UChar *d=impl.getRawDecomposition(c, buffer, length);
const char16_t *d=impl.getRawDecomposition(c, buffer, length);
if(d==nullptr) {
return false;
}
@ -152,12 +152,12 @@ public:
if(U_FAILURE(errorCode)) {
return false;
}
const UChar *sArray=s.getBuffer();
const char16_t *sArray=s.getBuffer();
if(sArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return false;
}
const UChar *sLimit=sArray+s.length();
const char16_t *sLimit=sArray+s.length();
return sLimit==spanQuickCheckYes(sArray, sLimit, errorCode);
}
virtual UNormalizationCheckResult
@ -169,15 +169,15 @@ public:
if(U_FAILURE(errorCode)) {
return 0;
}
const UChar *sArray=s.getBuffer();
const char16_t *sArray=s.getBuffer();
if(sArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return 0;
}
return (int32_t)(spanQuickCheckYes(sArray, sArray+s.length(), errorCode)-sArray);
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const = 0;
virtual const char16_t *
spanQuickCheckYes(const char16_t *src, const char16_t *limit, UErrorCode &errorCode) const = 0;
virtual UNormalizationCheckResult getQuickCheck(UChar32) const {
return UNORM_YES;
@ -193,13 +193,13 @@ public:
private:
virtual void
normalize(const UChar *src, const UChar *limit,
normalize(const char16_t *src, const char16_t *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
impl.decompose(src, limit, &buffer, errorCode);
}
using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
normalizeAndAppend(const char16_t *src, const char16_t *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
impl.decomposeAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
@ -228,8 +228,8 @@ private:
return sLimit == impl.decomposeUTF8(0, s, sLimit, nullptr, nullptr, errorCode);
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const U_OVERRIDE {
virtual const char16_t *
spanQuickCheckYes(const char16_t *src, const char16_t *limit, UErrorCode &errorCode) const U_OVERRIDE {
return impl.decompose(src, limit, nullptr, errorCode);
}
using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
@ -255,7 +255,7 @@ public:
private:
virtual void
normalize(const UChar *src, const UChar *limit,
normalize(const char16_t *src, const char16_t *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
impl.compose(src, limit, onlyContiguous, true, buffer, errorCode);
}
@ -277,7 +277,7 @@ private:
}
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
normalizeAndAppend(const char16_t *src, const char16_t *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
impl.composeAndAppend(src, limit, doNormalize, onlyContiguous, safeMiddle, buffer, errorCode);
@ -288,7 +288,7 @@ private:
if(U_FAILURE(errorCode)) {
return false;
}
const UChar *sArray=s.getBuffer();
const char16_t *sArray=s.getBuffer();
if(sArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return false;
@ -313,7 +313,7 @@ private:
if(U_FAILURE(errorCode)) {
return UNORM_MAYBE;
}
const UChar *sArray=s.getBuffer();
const char16_t *sArray=s.getBuffer();
if(sArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
return UNORM_MAYBE;
@ -322,8 +322,8 @@ private:
impl.composeQuickCheck(sArray, sArray+s.length(), onlyContiguous, &qcResult);
return qcResult;
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &) const U_OVERRIDE {
virtual const char16_t *
spanQuickCheckYes(const char16_t *src, const char16_t *limit, UErrorCode &) const U_OVERRIDE {
return impl.composeQuickCheck(src, limit, onlyContiguous, nullptr);
}
using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.
@ -350,19 +350,19 @@ public:
private:
virtual void
normalize(const UChar *src, const UChar *limit,
normalize(const char16_t *src, const char16_t *limit,
ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
impl.makeFCD(src, limit, &buffer, errorCode);
}
using Normalizer2WithImpl::normalize; // Avoid warning about hiding base class function.
virtual void
normalizeAndAppend(const UChar *src, const UChar *limit, UBool doNormalize,
normalizeAndAppend(const char16_t *src, const char16_t *limit, UBool doNormalize,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer, UErrorCode &errorCode) const U_OVERRIDE {
impl.makeFCDAndAppend(src, limit, doNormalize, safeMiddle, buffer, errorCode);
}
virtual const UChar *
spanQuickCheckYes(const UChar *src, const UChar *limit, UErrorCode &errorCode) const U_OVERRIDE {
virtual const char16_t *
spanQuickCheckYes(const char16_t *src, const char16_t *limit, UErrorCode &errorCode) const U_OVERRIDE {
return impl.makeFCD(src, limit, nullptr, errorCode);
}
using Normalizer2WithImpl::spanQuickCheckYes; // Avoid warning about hiding base class function.

26
icu4c/source/common/normalizer2.cpp
View file

@ -327,8 +327,8 @@ unorm2_close(UNormalizer2 *norm2) {
U_CAPI int32_t U_EXPORT2
unorm2_normalize(const UNormalizer2 *norm2,
const UChar *src, int32_t length,
UChar *dest, int32_t capacity,
const char16_t *src, int32_t length,
char16_t *dest, int32_t capacity,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return 0;
@ -361,8 +361,8 @@ unorm2_normalize(const UNormalizer2 *norm2,
static int32_t
normalizeSecondAndAppend(const UNormalizer2 *norm2,
UChar *first, int32_t firstLength, int32_t firstCapacity,
const UChar *second, int32_t secondLength,
char16_t *first, int32_t firstLength, int32_t firstCapacity,
const char16_t *second, int32_t secondLength,
UBool doNormalize,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
@ -417,8 +417,8 @@ normalizeSecondAndAppend(const UNormalizer2 *norm2,
U_CAPI int32_t U_EXPORT2
unorm2_normalizeSecondAndAppend(const UNormalizer2 *norm2,
UChar *first, int32_t firstLength, int32_t firstCapacity,
const UChar *second, int32_t secondLength,
char16_t *first, int32_t firstLength, int32_t firstCapacity,
const char16_t *second, int32_t secondLength,
UErrorCode *pErrorCode) {
return normalizeSecondAndAppend(norm2,
first, firstLength, firstCapacity,
@ -428,8 +428,8 @@ unorm2_normalizeSecondAndAppend(const UNormalizer2 *norm2,
U_CAPI int32_t U_EXPORT2
unorm2_append(const UNormalizer2 *norm2,
UChar *first, int32_t firstLength, int32_t firstCapacity,
const UChar *second, int32_t secondLength,
char16_t *first, int32_t firstLength, int32_t firstCapacity,
const char16_t *second, int32_t secondLength,
UErrorCode *pErrorCode) {
return normalizeSecondAndAppend(norm2,
first, firstLength, firstCapacity,
@ -439,7 +439,7 @@ unorm2_append(const UNormalizer2 *norm2,
U_CAPI int32_t U_EXPORT2
unorm2_getDecomposition(const UNormalizer2 *norm2,
UChar32 c, UChar *decomposition, int32_t capacity,
UChar32 c, char16_t *decomposition, int32_t capacity,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return 0;
@ -458,7 +458,7 @@ unorm2_getDecomposition(const UNormalizer2 *norm2,
U_CAPI int32_t U_EXPORT2
unorm2_getRawDecomposition(const UNormalizer2 *norm2,
UChar32 c, UChar *decomposition, int32_t capacity,
UChar32 c, char16_t *decomposition, int32_t capacity,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return 0;
@ -487,7 +487,7 @@ unorm2_getCombiningClass(const UNormalizer2 *norm2, UChar32 c) {
U_CAPI UBool U_EXPORT2
unorm2_isNormalized(const UNormalizer2 *norm2,
const UChar *s, int32_t length,
const char16_t *s, int32_t length,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return 0;
@ -502,7 +502,7 @@ unorm2_isNormalized(const UNormalizer2 *norm2,
U_CAPI UNormalizationCheckResult U_EXPORT2
unorm2_quickCheck(const UNormalizer2 *norm2,
const UChar *s, int32_t length,
const char16_t *s, int32_t length,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return UNORM_NO;
@ -517,7 +517,7 @@ unorm2_quickCheck(const UNormalizer2 *norm2,
U_CAPI int32_t U_EXPORT2
unorm2_spanQuickCheckYes(const UNormalizer2 *norm2,
const UChar *s, int32_t length,
const char16_t *s, int32_t length,
UErrorCode *pErrorCode) {
if(U_FAILURE(*pErrorCode)) {
return 0;

194
icu4c/source/common/normalizer2impl.cpp
View file

@ -81,8 +81,8 @@ UChar32 codePointFromValidUTF8(const uint8_t *cpStart, const uint8_t *cpLimit) {
case 2:
return ((c&0x1f)<<6) | (cpStart[1]&0x3f);
case 3:
// no need for (c&0xf) because the upper bits are truncated after <<12 in the cast to (UChar)
return (UChar)((c<<12) | ((cpStart[1]&0x3f)<<6) | (cpStart[2]&0x3f));
// no need for (c&0xf) because the upper bits are truncated after <<12 in the cast to (char16_t)
return (char16_t)((c<<12) | ((cpStart[1]&0x3f)<<6) | (cpStart[2]&0x3f));
case 4:
return ((c&7)<<18) | ((cpStart[1]&0x3f)<<12) | ((cpStart[2]&0x3f)<<6) | (cpStart[3]&0x3f);
default:
@ -204,7 +204,7 @@ UBool ReorderingBuffer::init(int32_t destCapacity, UErrorCode &errorCode) {
return true;
}
UBool ReorderingBuffer::equals(const UChar *otherStart, const UChar *otherLimit) const {
UBool ReorderingBuffer::equals(const char16_t *otherStart, const char16_t *otherLimit) const {
int32_t length=(int32_t)(limit-start);
return
length==(int32_t)(otherLimit-otherStart) &&
@ -256,7 +256,7 @@ UBool ReorderingBuffer::appendSupplementary(UChar32 c, uint8_t cc, UErrorCode &e
return true;
}
UBool ReorderingBuffer::append(const UChar *s, int32_t length, UBool isNFD,
UBool ReorderingBuffer::append(const char16_t *s, int32_t length, UBool isNFD,
uint8_t leadCC, uint8_t trailCC,
UErrorCode &errorCode) {
if(length==0) {
@ -272,7 +272,7 @@ UBool ReorderingBuffer::append(const UChar *s, int32_t length, UBool isNFD,
} else if(leadCC<=1) {
reorderStart=limit+1; // Ok if not a code point boundary.
}
const UChar *sLimit=s+length;
const char16_t *sLimit=s+length;
do { *limit++=*s++; } while(s!=sLimit);
lastCC=trailCC;
} else {
@ -304,7 +304,7 @@ UBool ReorderingBuffer::appendZeroCC(UChar32 c, UErrorCode &errorCode) {
}
remainingCapacity-=cpLength;
if(cpLength==1) {
*limit++=(UChar)c;
*limit++=(char16_t)c;
} else {
limit[0]=U16_LEAD(c);
limit[1]=U16_TRAIL(c);
@ -315,7 +315,7 @@ UBool ReorderingBuffer::appendZeroCC(UChar32 c, UErrorCode &errorCode) {
return true;
}
UBool ReorderingBuffer::appendZeroCC(const UChar *s, const UChar *sLimit, UErrorCode &errorCode) {
UBool ReorderingBuffer::appendZeroCC(const char16_t *s, const char16_t *sLimit, UErrorCode &errorCode) {
if(s==sLimit) {
return true;
}
@ -375,7 +375,7 @@ UBool ReorderingBuffer::resize(int32_t appendLength, UErrorCode &errorCode) {
void ReorderingBuffer::skipPrevious() {
codePointLimit=codePointStart;
UChar c=*--codePointStart;
char16_t c=*--codePointStart;
if(U16_IS_TRAIL(c) && start<codePointStart && U16_IS_LEAD(*(codePointStart-1))) {
--codePointStart;
}
@ -387,7 +387,7 @@ uint8_t ReorderingBuffer::previousCC() {
return 0;
}
UChar32 c=*--codePointStart;
UChar c2;
char16_t c2;
if(U16_IS_TRAIL(c) && start<codePointStart && U16_IS_LEAD(c2=*(codePointStart-1))) {
--codePointStart;
c=U16_GET_SUPPLEMENTARY(c2, c);
@ -400,8 +400,8 @@ uint8_t ReorderingBuffer::previousCC() {
void ReorderingBuffer::insert(UChar32 c, uint8_t cc) {
for(setIterator(), skipPrevious(); previousCC()>cc;) {}
// insert c at codePointLimit, after the character with prevCC<=cc
UChar *q=limit;
UChar *r=limit+=U16_LENGTH(c);
char16_t *q=limit;
char16_t *r=limit+=U16_LENGTH(c);
do {
*--r=*--q;
} while(codePointLimit!=q);
@ -429,9 +429,9 @@ Normalizer2Impl::~Normalizer2Impl() {
void
Normalizer2Impl::init(const int32_t *inIndexes, const UCPTrie *inTrie,
const uint16_t *inExtraData, const uint8_t *inSmallFCD) {
minDecompNoCP = static_cast<UChar>(inIndexes[IX_MIN_DECOMP_NO_CP]);
minCompNoMaybeCP = static_cast<UChar>(inIndexes[IX_MIN_COMP_NO_MAYBE_CP]);
minLcccCP = static_cast<UChar>(inIndexes[IX_MIN_LCCC_CP]);
minDecompNoCP = static_cast<char16_t>(inIndexes[IX_MIN_DECOMP_NO_CP]);
minCompNoMaybeCP = static_cast<char16_t>(inIndexes[IX_MIN_COMP_NO_MAYBE_CP]);
minLcccCP = static_cast<char16_t>(inIndexes[IX_MIN_LCCC_CP]);
minYesNo = static_cast<uint16_t>(inIndexes[IX_MIN_YES_NO]);
minYesNoMappingsOnly = static_cast<uint16_t>(inIndexes[IX_MIN_YES_NO_MAPPINGS_ONLY]);
@ -503,7 +503,7 @@ Normalizer2Impl::addPropertyStarts(const USetAdder *sa, UErrorCode & /*errorCode
}
/* add Hangul LV syllables and LV+1 because of skippables */
for(UChar c=Hangul::HANGUL_BASE; c<Hangul::HANGUL_LIMIT; c+=Hangul::JAMO_T_COUNT) {
for(char16_t c=Hangul::HANGUL_BASE; c<Hangul::HANGUL_LIMIT; c+=Hangul::JAMO_T_COUNT) {
sa->add(sa->set, c);
sa->add(sa->set, c+1);
}
@ -524,8 +524,8 @@ Normalizer2Impl::addCanonIterPropertyStarts(const USetAdder *sa, UErrorCode &err
}
}
const UChar *
Normalizer2Impl::copyLowPrefixFromNulTerminated(const UChar *src,
const char16_t *
Normalizer2Impl::copyLowPrefixFromNulTerminated(const char16_t *src,
UChar32 minNeedDataCP,
ReorderingBuffer *buffer,
UErrorCode &errorCode) const {
@ -534,8 +534,8 @@ Normalizer2Impl::copyLowPrefixFromNulTerminated(const UChar *src,
// data and check the first part of the string.
// After this prefix, determine the string length to simplify the rest
// of the code.
const UChar *prevSrc=src;
UChar c;
const char16_t *prevSrc=src;
char16_t c;
while((c=*src++)<minNeedDataCP && c!=0) {}
// Back out the last character for full processing.
// Copy this prefix.
@ -554,7 +554,7 @@ Normalizer2Impl::decompose(const UnicodeString &src, UnicodeString &dest,
dest.setToBogus();
return dest;
}
const UChar *sArray=src.getBuffer();
const char16_t *sArray=src.getBuffer();
if(&dest==&src || sArray==nullptr) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
dest.setToBogus();
@ -565,7 +565,7 @@ Normalizer2Impl::decompose(const UnicodeString &src, UnicodeString &dest,
}
void
Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
Normalizer2Impl::decompose(const char16_t *src, const char16_t *limit,
UnicodeString &dest,
int32_t destLengthEstimate,
UErrorCode &errorCode) const {
@ -582,8 +582,8 @@ Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
// Dual functionality:
// buffer!=nullptr: normalize
// buffer==nullptr: isNormalized/spanQuickCheckYes
const UChar *
Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
const char16_t *
Normalizer2Impl::decompose(const char16_t *src, const char16_t *limit,
ReorderingBuffer *buffer,
UErrorCode &errorCode) const {
UChar32 minNoCP=minDecompNoCP;
@ -595,12 +595,12 @@ Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
limit=u_strchr(src, 0);
}
const UChar *prevSrc;
const char16_t *prevSrc;
UChar32 c=0;
uint16_t norm16=0;
// only for quick check
const UChar *prevBoundary=src;
const char16_t *prevBoundary=src;
uint8_t prevCC=0;
for(;;) {
@ -613,7 +613,7 @@ Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
} else if(!U16_IS_LEAD(c)) {
break;
} else {
UChar c2;
char16_t c2;
if((src+1)!=limit && U16_IS_TRAIL(c2=src[1])) {
c=U16_GET_SUPPLEMENTARY(c, c2);
norm16=UCPTRIE_FAST_SUPP_GET(normTrie, UCPTRIE_16, c);
@ -669,8 +669,8 @@ Normalizer2Impl::decompose(const UChar *src, const UChar *limit,
// fail the quick check loop and/or where the quick check loop's overhead
// is unlikely to be amortized.
// Called by the compose() and makeFCD() implementations.
const UChar *
Normalizer2Impl::decomposeShort(const UChar *src, const UChar *limit,
const char16_t *
Normalizer2Impl::decomposeShort(const char16_t *src, const char16_t *limit,
UBool stopAtCompBoundary, UBool onlyContiguous,
ReorderingBuffer &buffer, UErrorCode &errorCode) const {
if (U_FAILURE(errorCode)) {
@ -680,7 +680,7 @@ Normalizer2Impl::decomposeShort(const UChar *src, const UChar *limit,
if (stopAtCompBoundary && *src < minCompNoMaybeCP) {
return src;
}
const UChar *prevSrc = src;
const char16_t *prevSrc = src;
UChar32 c;
uint16_t norm16;
UCPTRIE_FAST_U16_NEXT(normTrie, UCPTRIE_16, src, limit, c, norm16);
@ -714,7 +714,7 @@ UBool Normalizer2Impl::decompose(UChar32 c, uint16_t norm16,
return buffer.append(c, 0, errorCode);
} else if(isHangulLV(norm16) || isHangulLVT(norm16)) {
// Hangul syllable: decompose algorithmically
UChar jamos[3];
char16_t jamos[3];
return buffer.appendZeroCC(jamos, jamos+Hangul::decompose(c, jamos), errorCode);
}
// c decomposes, get everything from the variable-length extra data
@ -728,7 +728,7 @@ UBool Normalizer2Impl::decompose(UChar32 c, uint16_t norm16,
} else {
leadCC=0;
}
return buffer.append((const UChar *)mapping+1, length, true, leadCC, trailCC, errorCode);
return buffer.append((const char16_t *)mapping+1, length, true, leadCC, trailCC, errorCode);
}
// Dual functionality:
@ -943,14 +943,14 @@ Normalizer2Impl::decomposeShort(const uint8_t *src, const uint8_t *limit,
return src;
}
const UChar *
Normalizer2Impl::getDecomposition(UChar32 c, UChar buffer[4], int32_t &length) const {
const char16_t *
Normalizer2Impl::getDecomposition(UChar32 c, char16_t buffer[4], int32_t &length) const {
uint16_t norm16;
if(c<minDecompNoCP || isMaybeOrNonZeroCC(norm16=getNorm16(c))) {
// c does not decompose
return nullptr;
}
const UChar *decomp = nullptr;
const char16_t *decomp = nullptr;
if(isDecompNoAlgorithmic(norm16)) {
// Maps to an isCompYesAndZeroCC.
c=mapAlgorithmic(c, norm16);
@ -970,15 +970,15 @@ Normalizer2Impl::getDecomposition(UChar32 c, UChar buffer[4], int32_t &length) c
// c decomposes, get everything from the variable-length extra data
const uint16_t *mapping=getMapping(norm16);
length=*mapping&MAPPING_LENGTH_MASK;
return (const UChar *)mapping+1;
return (const char16_t *)mapping+1;
}
// The capacity of the buffer must be 30=MAPPING_LENGTH_MASK-1
// so that a raw mapping fits that consists of one unit ("rm0")
// plus all but the first two code units of the normal mapping.
// The maximum length of a normal mapping is 31=MAPPING_LENGTH_MASK.
const UChar *
Normalizer2Impl::getRawDecomposition(UChar32 c, UChar buffer[30], int32_t &length) const {
const char16_t *
Normalizer2Impl::getRawDecomposition(UChar32 c, char16_t buffer[30], int32_t &length) const {
uint16_t norm16;
if(c<minDecompNoCP || isDecompYes(norm16=getNorm16(c))) {
// c does not decompose
@ -1005,21 +1005,21 @@ Normalizer2Impl::getRawDecomposition(UChar32 c, UChar buffer[30], int32_t &lengt
uint16_t rm0=*rawMapping;
if(rm0<=MAPPING_LENGTH_MASK) {
length=rm0;
return (const UChar *)rawMapping-rm0;
return (const char16_t *)rawMapping-rm0;
} else {
// Copy the normal mapping and replace its first two code units with rm0.
buffer[0]=(UChar)rm0;
u_memcpy(buffer+1, (const UChar *)mapping+1+2, mLength-2);
buffer[0]=(char16_t)rm0;
u_memcpy(buffer+1, (const char16_t *)mapping+1+2, mLength-2);
length=mLength-1;
return buffer;
}
} else {
length=mLength;
return (const UChar *)mapping+1;
return (const char16_t *)mapping+1;
}
}
void Normalizer2Impl::decomposeAndAppend(const UChar *src, const UChar *limit,
void Normalizer2Impl::decomposeAndAppend(const char16_t *src, const char16_t *limit,
UBool doDecompose,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer,
@ -1032,9 +1032,9 @@ void Normalizer2Impl::decomposeAndAppend(const UChar *src, const UChar *limit,
// Just merge the strings at the boundary.
bool isFirst = true;
uint8_t firstCC = 0, prevCC = 0, cc;
const UChar *p = src;
const char16_t *p = src;
while (p != limit) {
const UChar *codePointStart = p;
const char16_t *codePointStart = p;
UChar32 c;
uint16_t norm16;
UCPTRIE_FAST_U16_NEXT(normTrie, UCPTRIE_16, p, limit, c, norm16);
@ -1218,13 +1218,13 @@ void Normalizer2Impl::addComposites(const uint16_t *list, UnicodeSet &set) const
*/
void Normalizer2Impl::recompose(ReorderingBuffer &buffer, int32_t recomposeStartIndex,
UBool onlyContiguous) const {
UChar *p=buffer.getStart()+recomposeStartIndex;
UChar *limit=buffer.getLimit();
char16_t *p=buffer.getStart()+recomposeStartIndex;
char16_t *limit=buffer.getLimit();
if(p==limit) {
return;
}
UChar *starter, *pRemove, *q, *r;
char16_t *starter, *pRemove, *q, *r;
const uint16_t *compositionsList;
UChar32 c, compositeAndFwd;
uint16_t norm16;
@ -1252,15 +1252,15 @@ void Normalizer2Impl::recompose(ReorderingBuffer &buffer, int32_t recomposeStart
// c is a Jamo V/T, see if we can compose it with the previous character.
if(c<Hangul::JAMO_T_BASE) {
// c is a Jamo Vowel, compose with previous Jamo L and following Jamo T.
UChar prev=(UChar)(*starter-Hangul::JAMO_L_BASE);
char16_t prev=(char16_t)(*starter-Hangul::JAMO_L_BASE);
if(prev<Hangul::JAMO_L_COUNT) {
pRemove=p-1;
UChar syllable=(UChar)
char16_t syllable=(char16_t)
(Hangul::HANGUL_BASE+
(prev*Hangul::JAMO_V_COUNT+(c-Hangul::JAMO_V_BASE))*
Hangul::JAMO_T_COUNT);
UChar t;
if(p!=limit && (t=(UChar)(*p-Hangul::JAMO_T_BASE))<Hangul::JAMO_T_COUNT) {
char16_t t;
if(p!=limit && (t=(char16_t)(*p-Hangul::JAMO_T_BASE))<Hangul::JAMO_T_COUNT) {
++p;
syllable+=t; // The next character was a Jamo T.
}
@ -1298,7 +1298,7 @@ void Normalizer2Impl::recompose(ReorderingBuffer &buffer, int32_t recomposeStart
starter[0]=U16_LEAD(composite);
starter[1]=U16_TRAIL(composite);
} else {
*starter=(UChar)composite;
*starter=(char16_t)composite;
// The composite is shorter than the starter,
// move the intermediate characters forward one.
starterIsSupplementary=false;
@ -1323,7 +1323,7 @@ void Normalizer2Impl::recompose(ReorderingBuffer &buffer, int32_t recomposeStart
*--starter=U16_LEAD(composite); // undo the temporary increment
} else {
// both are on the BMP
*starter=(UChar)composite;
*starter=(char16_t)composite;
}
/* remove the combining mark by moving the following text over it */
@ -1435,12 +1435,12 @@ Normalizer2Impl::composePair(UChar32 a, UChar32 b) const {
// doCompose: normalize
// !doCompose: isNormalized (buffer must be empty and initialized)
UBool
Normalizer2Impl::compose(const UChar *src, const UChar *limit,
Normalizer2Impl::compose(const char16_t *src, const char16_t *limit,
UBool onlyContiguous,
UBool doCompose,
ReorderingBuffer &buffer,
UErrorCode &errorCode) const {
const UChar *prevBoundary=src;
const char16_t *prevBoundary=src;
UChar32 minNoMaybeCP=minCompNoMaybeCP;
if(limit==nullptr) {
src=copyLowPrefixFromNulTerminated(src, minNoMaybeCP,
@ -1463,7 +1463,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
for (;;) {
// Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
// or with (compYes && ccc==0) properties.
const UChar *prevSrc;
const char16_t *prevSrc;
UChar32 c = 0;
uint16_t norm16 = 0;
for (;;) {
@ -1482,7 +1482,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
if(!U16_IS_LEAD(c)) {
break;
} else {
UChar c2;
char16_t c2;
if(src!=limit && U16_IS_TRAIL(c2=*src)) {
++src;
c=U16_GET_SUPPLEMENTARY(c, c2);
@ -1528,7 +1528,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
break;
}
const UChar *mapping = reinterpret_cast<const UChar *>(getMapping(norm16));
const char16_t *mapping = reinterpret_cast<const char16_t *>(getMapping(norm16));
int32_t length = *mapping++ & MAPPING_LENGTH_MASK;
if(!buffer.appendZeroCC(mapping, mapping + length, errorCode)) {
break;
@ -1552,11 +1552,11 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
// Other "noNo" type, or need to examine more text around this character:
// Fall through to the slow path.
} else if (isJamoVT(norm16) && prevBoundary != prevSrc) {
UChar prev=*(prevSrc-1);
char16_t prev=*(prevSrc-1);
if(c<Hangul::JAMO_T_BASE) {
// The current character is a Jamo Vowel,
// compose with previous Jamo L and following Jamo T.
UChar l = (UChar)(prev-Hangul::JAMO_L_BASE);
char16_t l = (char16_t)(prev-Hangul::JAMO_L_BASE);
if(l<Hangul::JAMO_L_COUNT) {
if (!doCompose) {
return false;
@ -1581,7 +1581,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
break;
}
if(!buffer.appendBMP((UChar)syllable, 0, errorCode)) {
if(!buffer.appendBMP((char16_t)syllable, 0, errorCode)) {
break;
}
prevBoundary = src;
@ -1606,7 +1606,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
if (prevBoundary != prevSrc && !buffer.appendZeroCC(prevBoundary, prevSrc, errorCode)) {
break;
}
if(!buffer.appendBMP((UChar)syllable, 0, errorCode)) {
if(!buffer.appendBMP((char16_t)syllable, 0, errorCode)) {
break;
}
prevBoundary = src;
@ -1627,7 +1627,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
} else {
// If !onlyContiguous (not FCC), then we ignore the tccc of
// the previous character which passed the quick check "yes && ccc==0" test.
const UChar *nextSrc;
const char16_t *nextSrc;
uint16_t n16;
for (;;) {
if (src == limit) {
@ -1667,7 +1667,7 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
// Slow path: Find the nearest boundaries around the current character,
// decompose and recompose.
if (prevBoundary != prevSrc && !norm16HasCompBoundaryBefore(norm16)) {
const UChar *p = prevSrc;
const char16_t *p = prevSrc;
UCPTRIE_FAST_U16_PREV(normTrie, UCPTRIE_16, prevBoundary, p, c, norm16);
if (!norm16HasCompBoundaryAfter(norm16, onlyContiguous)) {
prevSrc = p;
@ -1705,11 +1705,11 @@ Normalizer2Impl::compose(const UChar *src, const UChar *limit,
// Very similar to compose(): Make the same changes in both places if relevant.
// pQCResult==nullptr: spanQuickCheckYes
// pQCResult!=nullptr: quickCheck (*pQCResult must be UNORM_YES)
const UChar *
Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
const char16_t *
Normalizer2Impl::composeQuickCheck(const char16_t *src, const char16_t *limit,
UBool onlyContiguous,
UNormalizationCheckResult *pQCResult) const {
const UChar *prevBoundary=src;
const char16_t *prevBoundary=src;
UChar32 minNoMaybeCP=minCompNoMaybeCP;
if(limit==nullptr) {
UErrorCode errorCode=U_ZERO_ERROR;
@ -1727,7 +1727,7 @@ Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
for(;;) {
// Fast path: Scan over a sequence of characters below the minimum "no or maybe" code point,
// or with (compYes && ccc==0) properties.
const UChar *prevSrc;
const char16_t *prevSrc;
UChar32 c = 0;
uint16_t norm16 = 0;
for (;;) {
@ -1743,7 +1743,7 @@ Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
if(!U16_IS_LEAD(c)) {
break;
} else {
UChar c2;
char16_t c2;
if(src!=limit && U16_IS_TRAIL(c2=*src)) {
++src;
c=U16_GET_SUPPLEMENTARY(c, c2);
@ -1766,7 +1766,7 @@ Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
if (norm16HasCompBoundaryBefore(norm16)) {
prevBoundary = prevSrc;
} else {
const UChar *p = prevSrc;
const char16_t *p = prevSrc;
uint16_t n16;
UCPTRIE_FAST_U16_PREV(normTrie, UCPTRIE_16, prevBoundary, p, c, n16);
if (norm16HasCompBoundaryAfter(n16, onlyContiguous)) {
@ -1788,7 +1788,7 @@ Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
} else {
// If !onlyContiguous (not FCC), then we ignore the tccc of
// the previous character which passed the quick check "yes && ccc==0" test.
const UChar *nextSrc;
const char16_t *nextSrc;
for (;;) {
if (norm16 < MIN_YES_YES_WITH_CC) {
if (pQCResult != nullptr) {
@ -1828,23 +1828,23 @@ Normalizer2Impl::composeQuickCheck(const UChar *src, const UChar *limit,
}
}
void Normalizer2Impl::composeAndAppend(const UChar *src, const UChar *limit,
void Normalizer2Impl::composeAndAppend(const char16_t *src, const char16_t *limit,
UBool doCompose,
UBool onlyContiguous,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer,
UErrorCode &errorCode) const {
if(!buffer.isEmpty()) {
const UChar *firstStarterInSrc=findNextCompBoundary(src, limit, onlyContiguous);
const char16_t *firstStarterInSrc=findNextCompBoundary(src, limit, onlyContiguous);
if(src!=firstStarterInSrc) {
const UChar *lastStarterInDest=findPreviousCompBoundary(buffer.getStart(),
const char16_t *lastStarterInDest=findPreviousCompBoundary(buffer.getStart(),
buffer.getLimit(), onlyContiguous);
int32_t destSuffixLength=(int32_t)(buffer.getLimit()-lastStarterInDest);
UnicodeString middle(lastStarterInDest, destSuffixLength);
buffer.removeSuffix(destSuffixLength);
safeMiddle=middle;
middle.append(src, (int32_t)(firstStarterInSrc-src));
const UChar *middleStart=middle.getBuffer();
const char16_t *middleStart=middle.getBuffer();
compose(middleStart, middleStart+middle.length(), onlyContiguous,
true, buffer, errorCode);
if(U_FAILURE(errorCode)) {
@ -1933,7 +1933,7 @@ Normalizer2Impl::composeUTF8(uint32_t options, UBool onlyContiguous,
}
const uint16_t *mapping = getMapping(norm16);
int32_t length = *mapping++ & MAPPING_LENGTH_MASK;
if (!ByteSinkUtil::appendChange(prevSrc, src, (const UChar *)mapping, length,
if (!ByteSinkUtil::appendChange(prevSrc, src, (const char16_t *)mapping, length,
*sink, edits, errorCode)) {
break;
}
@ -2120,7 +2120,7 @@ Normalizer2Impl::composeUTF8(uint32_t options, UBool onlyContiguous,
return true;
}
UBool Normalizer2Impl::hasCompBoundaryBefore(const UChar *src, const UChar *limit) const {
UBool Normalizer2Impl::hasCompBoundaryBefore(const char16_t *src, const char16_t *limit) const {
if (src == limit || *src < minCompNoMaybeCP) {
return true;
}
@ -2139,7 +2139,7 @@ UBool Normalizer2Impl::hasCompBoundaryBefore(const uint8_t *src, const uint8_t *
return norm16HasCompBoundaryBefore(norm16);
}
UBool Normalizer2Impl::hasCompBoundaryAfter(const UChar *start, const UChar *p,
UBool Normalizer2Impl::hasCompBoundaryAfter(const char16_t *start, const char16_t *p,
UBool onlyContiguous) const {
if (start == p) {
return true;
@ -2160,10 +2160,10 @@ UBool Normalizer2Impl::hasCompBoundaryAfter(const uint8_t *start, const uint8_t
return norm16HasCompBoundaryAfter(norm16, onlyContiguous);
}
const UChar *Normalizer2Impl::findPreviousCompBoundary(const UChar *start, const UChar *p,
const char16_t *Normalizer2Impl::findPreviousCompBoundary(const char16_t *start, const char16_t *p,
UBool onlyContiguous) const {
while (p != start) {
const UChar *codePointLimit = p;
const char16_t *codePointLimit = p;
UChar32 c;
uint16_t norm16;
UCPTRIE_FAST_U16_PREV(normTrie, UCPTRIE_16, start, p, c, norm16);
@ -2177,10 +2177,10 @@ const UChar *Normalizer2Impl::findPreviousCompBoundary(const UChar *start, const
return p;
}
const UChar *Normalizer2Impl::findNextCompBoundary(const UChar *p, const UChar *limit,
const char16_t *Normalizer2Impl::findNextCompBoundary(const char16_t *p, const char16_t *limit,
UBool onlyContiguous) const {
while (p != limit) {
const UChar *codePointStart = p;
const char16_t *codePointStart = p;
UChar32 c;
uint16_t norm16;
UCPTRIE_FAST_U16_NEXT(normTrie, UCPTRIE_16, p, limit, c, norm16);
@ -2194,7 +2194,7 @@ const UChar *Normalizer2Impl::findNextCompBoundary(const UChar *p, const UChar *
return p;
}
uint8_t Normalizer2Impl::getPreviousTrailCC(const UChar *start, const UChar *p) const {
uint8_t Normalizer2Impl::getPreviousTrailCC(const char16_t *start, const char16_t *p) const {
if (start == p) {
return 0;
}
@ -2269,13 +2269,13 @@ uint16_t Normalizer2Impl::getFCD16FromNormData(UChar32 c) const {
// Dual functionality:
// buffer!=nullptr: normalize
// buffer==nullptr: isNormalized/quickCheck/spanQuickCheckYes
const UChar *
Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
const char16_t *
Normalizer2Impl::makeFCD(const char16_t *src, const char16_t *limit,
ReorderingBuffer *buffer,
UErrorCode &errorCode) const {
// Tracks the last FCD-safe boundary, before lccc=0 or after properly-ordered tccc<=1.
// Similar to the prevBoundary in the compose() implementation.
const UChar *prevBoundary=src;
const char16_t *prevBoundary=src;
int32_t prevFCD16=0;
if(limit==nullptr) {
src=copyLowPrefixFromNulTerminated(src, minLcccCP, buffer, errorCode);
@ -2300,7 +2300,7 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
// The exception is the call to decomposeShort() which uses the buffer
// in the normal way.
const UChar *prevSrc;
const char16_t *prevSrc;
UChar32 c=0;
uint16_t fcd16=0;
@ -2315,7 +2315,7 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
++src;
} else {
if(U16_IS_LEAD(c)) {
UChar c2;
char16_t c2;
if((src+1)!=limit && U16_IS_TRAIL(c2=src[1])) {
c=U16_GET_SUPPLEMENTARY(c, c2);
}
@ -2350,7 +2350,7 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
}
}
} else {
const UChar *p=src-1;
const char16_t *p=src-1;
if(U16_IS_TRAIL(*p) && prevSrc<p && U16_IS_LEAD(*(p-1))) {
--p;
// Need to fetch the previous character's FCD value because
@ -2410,22 +2410,22 @@ Normalizer2Impl::makeFCD(const UChar *src, const UChar *limit,
return src;
}
void Normalizer2Impl::makeFCDAndAppend(const UChar *src, const UChar *limit,
void Normalizer2Impl::makeFCDAndAppend(const char16_t *src, const char16_t *limit,
UBool doMakeFCD,
UnicodeString &safeMiddle,
ReorderingBuffer &buffer,
UErrorCode &errorCode) const {
if(!buffer.isEmpty()) {
const UChar *firstBoundaryInSrc=findNextFCDBoundary(src, limit);
const char16_t *firstBoundaryInSrc=findNextFCDBoundary(src, limit);
if(src!=firstBoundaryInSrc) {
const UChar *lastBoundaryInDest=findPreviousFCDBoundary(buffer.getStart(),
const char16_t *lastBoundaryInDest=findPreviousFCDBoundary(buffer.getStart(),
buffer.getLimit());
int32_t destSuffixLength=(int32_t)(buffer.getLimit()-lastBoundaryInDest);
UnicodeString middle(lastBoundaryInDest, destSuffixLength);
buffer.removeSuffix(destSuffixLength);
safeMiddle=middle;
middle.append(src, (int32_t)(firstBoundaryInSrc-src));
const UChar *middleStart=middle.getBuffer();
const char16_t *middleStart=middle.getBuffer();
makeFCD(middleStart, middleStart+middle.length(), &buffer, errorCode);
if(U_FAILURE(errorCode)) {
return;
@ -2443,9 +2443,9 @@ void Normalizer2Impl::makeFCDAndAppend(const UChar *src, const UChar *limit,
}
}
const UChar *Normalizer2Impl::findPreviousFCDBoundary(const UChar *start, const UChar *p) const {
const char16_t *Normalizer2Impl::findPreviousFCDBoundary(const char16_t *start, const char16_t *p) const {
while(start<p) {
const UChar *codePointLimit = p;
const char16_t *codePointLimit = p;
UChar32 c;
uint16_t norm16;
UCPTRIE_FAST_U16_PREV(normTrie, UCPTRIE_16, start, p, c, norm16);
@ -2459,9 +2459,9 @@ const UChar *Normalizer2Impl::findPreviousFCDBoundary(const UChar *start, const
return p;
}
const UChar *Normalizer2Impl::findNextFCDBoundary(const UChar *p, const UChar *limit) const {
const char16_t *Normalizer2Impl::findNextFCDBoundary(const char16_t *p, const char16_t *limit) const {
while(p<limit) {
const UChar *codePointStart=p;
const char16_t *codePointStart=p;
UChar32 c;
uint16_t norm16;
UCPTRIE_FAST_U16_NEXT(normTrie, UCPTRIE_16, p, limit, c, norm16);

16
icu4c/source/common/patternprops.cpp
View file

@ -164,8 +164,8 @@ PatternProps::isWhiteSpace(UChar32 c) {
}
}
const UChar *
PatternProps::skipWhiteSpace(const UChar *s, int32_t length) {
const char16_t *
PatternProps::skipWhiteSpace(const char16_t *s, int32_t length) {
while(length>0 && isWhiteSpace(*s)) {
++s;
--length;
@ -183,8 +183,8 @@ PatternProps::skipWhiteSpace(const UnicodeString& s, int32_t start) {
return i;
}
const UChar *
PatternProps::trimWhiteSpace(const UChar *s, int32_t &length) {
const char16_t *
PatternProps::trimWhiteSpace(const char16_t *s, int32_t &length) {
if(length<=0 || (!isWhiteSpace(s[0]) && !isWhiteSpace(s[length-1]))) {
return s;
}
@ -205,11 +205,11 @@ PatternProps::trimWhiteSpace(const UChar *s, int32_t &length) {
}
UBool
PatternProps::isIdentifier(const UChar *s, int32_t length) {
PatternProps::isIdentifier(const char16_t *s, int32_t length) {
if(length<=0) {
return false;
}
const UChar *limit=s+length;
const char16_t *limit=s+length;
do {
if(isSyntaxOrWhiteSpace(*s++)) {
return false;
@ -218,8 +218,8 @@ PatternProps::isIdentifier(const UChar *s, int32_t length) {
return true;
}
const UChar *
PatternProps::skipIdentifier(const UChar *s, int32_t length) {
const char16_t *
PatternProps::skipIdentifier(const char16_t *s, int32_t length) {
while(length>0 && !isSyntaxOrWhiteSpace(*s)) {
++s;
--length;

8
icu4c/source/common/patternprops.h
View file

@ -62,7 +62,7 @@ public:
* Skips over Pattern_White_Space starting at s.
* @return The smallest pointer at or after s with a non-white space character.
*/
static const UChar *skipWhiteSpace(const UChar *s, int32_t length);
static const char16_t *skipWhiteSpace(const char16_t *s, int32_t length);
/**
* Skips over Pattern_White_Space starting at index start in s.
@ -73,21 +73,21 @@ public:
/**
* @return s except with leading and trailing Pattern_White_Space removed and length adjusted.
*/
static const UChar *trimWhiteSpace(const UChar *s, int32_t &length);
static const char16_t *trimWhiteSpace(const char16_t *s, int32_t &length);
/**
* Tests whether the string contains a "pattern identifier", that is,
* whether it contains only non-Pattern_White_Space, non-Pattern_Syntax characters.
* @return true if there are no Pattern_White_Space or Pattern_Syntax characters in s.
*/
static UBool isIdentifier(const UChar *s, int32_t length);
static UBool isIdentifier(const char16_t *s, int32_t length);
/**
* Skips over a "pattern identifier" starting at index s.
* @return The smallest pointer at or after s with
* a Pattern_White_Space or Pattern_Syntax character.
*/
static const UChar *skipIdentifier(const UChar *s, int32_t length);
static const char16_t *skipIdentifier(const char16_t *s, int32_t length);
private:
PatternProps() = delete; // no constructor: all static methods

18
icu4c/source/common/punycode.cpp
View file

@ -179,14 +179,14 @@ constexpr int32_t DECODE_MAX_CHARS=2000;
// encode
U_CAPI int32_t
u_strToPunycode(const UChar *src, int32_t srcLength,
UChar *dest, int32_t destCapacity,
u_strToPunycode(const char16_t *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const UBool *caseFlags,
UErrorCode *pErrorCode) {
int32_t cpBuffer[ENCODE_MAX_CODE_UNITS];
int32_t n, delta, handledCPCount, basicLength, destLength, bias, j, m, q, k, t, srcCPCount;
UChar c, c2;
char16_t c, c2;
/* argument checking */
if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) {
@ -371,13 +371,13 @@ u_strToPunycode(const UChar *src, int32_t srcLength,
// decode
U_CAPI int32_t
u_strFromPunycode(const UChar *src, int32_t srcLength,
UChar *dest, int32_t destCapacity,
u_strFromPunycode(const char16_t *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
UBool *caseFlags,
UErrorCode *pErrorCode) {
int32_t n, destLength, i, bias, basicLength, j, in, oldi, w, k, digit, t,
destCPCount, firstSupplementaryIndex, cpLength;
UChar b;
char16_t b;
/* argument checking */
if(pErrorCode==nullptr || U_FAILURE(*pErrorCode)) {
@ -421,7 +421,7 @@ u_strFromPunycode(const UChar *src, int32_t srcLength,
}
if(j<destCapacity) {
dest[j]=(UChar)b;
dest[j]=(char16_t)b;
if(caseFlags!=nullptr) {
caseFlags[j]=IS_BASIC_UPPERCASE(b);
@ -550,7 +550,7 @@ u_strFromPunycode(const UChar *src, int32_t srcLength,
U16_FWD_N(dest, codeUnitIndex, destLength, i-codeUnitIndex);
}
/* use the UChar index codeUnitIndex instead of the code point index i */
/* use the char16_t index codeUnitIndex instead of the code point index i */
if(codeUnitIndex<destLength) {
uprv_memmove(dest+codeUnitIndex+cpLength,
dest+codeUnitIndex,
@ -563,7 +563,7 @@ u_strFromPunycode(const UChar *src, int32_t srcLength,
}
if(cpLength==1) {
/* BMP, insert one code unit */
dest[codeUnitIndex]=(UChar)n;
dest[codeUnitIndex]=(char16_t)n;
} else {
/* supplementary character, insert two code units */
dest[codeUnitIndex]=U16_LEAD(n);

4
icu4c/source/common/putil.cpp
View file

@ -1389,7 +1389,7 @@ static BOOL U_CALLCONV getIcuDataDirectoryUnderWindowsDirectory(char* directoryB
UErrorCode status = U_ZERO_ERROR;
int32_t windowsPathUtf8Len = 0;
u_strToUTF8(windowsPathUtf8, static_cast<int32_t>(UPRV_LENGTHOF(windowsPathUtf8)),
&windowsPathUtf8Len, reinterpret_cast<const UChar*>(windowsPath), -1, &status);
&windowsPathUtf8Len, reinterpret_cast<const char16_t*>(windowsPath), -1, &status);
if (U_SUCCESS(status) && (status != U_STRING_NOT_TERMINATED_WARNING) &&
(windowsPathUtf8Len < (UPRV_LENGTHOF(windowsPathUtf8) - 1))) {
@ -2269,7 +2269,7 @@ u_versionFromString(UVersionInfo versionArray, const char *versionString) {
}
U_CAPI void U_EXPORT2
u_versionFromUString(UVersionInfo versionArray, const UChar *versionString) {
u_versionFromUString(UVersionInfo versionArray, const char16_t *versionString) {
if(versionArray!=nullptr && versionString!=nullptr) {
char versionChars[U_MAX_VERSION_STRING_LENGTH+1];
int32_t len = u_strlen(versionString);

2
icu4c/source/common/rbbidata.h
View file

@ -85,7 +85,7 @@ struct RBBIDataHeader {
uint32_t fTrie; /* Offset to Trie data for character categories */
uint32_t fTrieLen;
uint32_t fRuleSource; /* Offset to the source for for the break */
uint32_t fRuleSourceLen; /* rules. Stored UChar *. */
uint32_t fRuleSourceLen; /* rules. Stored char16_t *. */
uint32_t fStatusTable; /* Offset to the table of rule status values */
uint32_t fStatusTableLen;

28
icu4c/source/common/rbbiscan.cpp
View file

@ -46,7 +46,7 @@
// source form of the state transition table for the RBBI rule parser.
//
//------------------------------------------------------------------------------
static const UChar gRuleSet_rule_char_pattern[] = {
static const char16_t gRuleSet_rule_char_pattern[] = {
// Characters that may appear as literals in patterns without escaping or quoting.
// [ ^ [ \ p { Z } \ u 0 0 2 0
0x5b, 0x5e, 0x5b, 0x5c, 0x70, 0x7b, 0x5a, 0x7d, 0x5c, 0x75, 0x30, 0x30, 0x32, 0x30,
@ -55,19 +55,19 @@ static const UChar gRuleSet_rule_char_pattern[] = {
// { L } ] - [ \ p { N } ] ]
0x7b, 0x4c, 0x7d, 0x5d, 0x2d, 0x5b, 0x5c, 0x70, 0x7b, 0x4e, 0x7d, 0x5d, 0x5d, 0};
static const UChar gRuleSet_name_char_pattern[] = {
static const char16_t gRuleSet_name_char_pattern[] = {
// [ _ \ p { L } \ p { N } ]
0x5b, 0x5f, 0x5c, 0x70, 0x7b, 0x4c, 0x7d, 0x5c, 0x70, 0x7b, 0x4e, 0x7d, 0x5d, 0};
static const UChar gRuleSet_digit_char_pattern[] = {
static const char16_t gRuleSet_digit_char_pattern[] = {
// [ 0 - 9 ]
0x5b, 0x30, 0x2d, 0x39, 0x5d, 0};
static const UChar gRuleSet_name_start_char_pattern[] = {
static const char16_t gRuleSet_name_start_char_pattern[] = {
// [ _ \ p { L } ]
0x5b, 0x5f, 0x5c, 0x70, 0x7b, 0x4c, 0x7d, 0x5d, 0 };
static const UChar kAny[] = {0x61, 0x6e, 0x79, 0x00}; // "any"
static const char16_t kAny[] = {0x61, 0x6e, 0x79, 0x00}; // "any"
U_CDECL_BEGIN
@ -809,15 +809,15 @@ void RBBIRuleScanner::findSetFor(const UnicodeString &s, RBBINode *node, Unicode
// Numeric because there is no portable way to enter them as literals.
// (Think EBCDIC).
//
static const UChar chCR = 0x0d; // New lines, for terminating comments.
static const UChar chLF = 0x0a;
static const UChar chNEL = 0x85; // NEL newline variant
static const UChar chLS = 0x2028; // Unicode Line Separator
static const UChar chApos = 0x27; // single quote, for quoted chars.
static const UChar chPound = 0x23; // '#', introduces a comment.
static const UChar chBackSlash = 0x5c; // '\' introduces a char escape
static const UChar chLParen = 0x28;
static const UChar chRParen = 0x29;
static const char16_t chCR = 0x0d; // New lines, for terminating comments.
static const char16_t chLF = 0x0a;
static const char16_t chNEL = 0x85; // NEL newline variant
static const char16_t chLS = 0x2028; // Unicode Line Separator
static const char16_t chApos = 0x27; // single quote, for quoted chars.
static const char16_t chPound = 0x23; // '#', introduces a comment.
static const char16_t chBackSlash = 0x5c; // '\' introduces a char escape
static const char16_t chLParen = 0x28;
static const char16_t chRParen = 0x29;
//------------------------------------------------------------------------------

4
icu4c/source/common/rbbistbl.cpp
View file

@ -41,7 +41,7 @@ U_CDECL_END
U_NAMESPACE_BEGIN
RBBISymbolTable::RBBISymbolTable(RBBIRuleScanner *rs, const UnicodeString &rules, UErrorCode &status)
:fRules(rules), fRuleScanner(rs), ffffString(UChar(0xffff))
:fRules(rules), fRuleScanner(rs), ffffString(char16_t(0xffff))
{
fHashTable = nullptr;
fCachedSetLookup = nullptr;
@ -144,7 +144,7 @@ UnicodeString RBBISymbolTable::parseReference(const UnicodeString& text,
int32_t i = start;
UnicodeString result;
while (i < limit) {
UChar c = text.charAt(i);
char16_t c = text.charAt(i);
if ((i==start && !u_isIDStart(c)) || !u_isIDPart(c)) {
break;
}

10
icu4c/source/common/resbund.cpp
View file

@ -253,7 +253,7 @@ ResourceBundle::clone() const {
UnicodeString ResourceBundle::getString(UErrorCode& status) const {
int32_t len = 0;
const UChar *r = ures_getString(fResource, &len, &status);
const char16_t *r = ures_getString(fResource, &len, &status);
return UnicodeString(true, r, len);
}
@ -311,13 +311,13 @@ ResourceBundle ResourceBundle::getNext(UErrorCode& status) {
UnicodeString ResourceBundle::getNextString(UErrorCode& status) {
int32_t len = 0;
const UChar* r = ures_getNextString(fResource, &len, 0, &status);
const char16_t* r = ures_getNextString(fResource, &len, 0, &status);
return UnicodeString(true, r, len);
}
UnicodeString ResourceBundle::getNextString(const char ** key, UErrorCode& status) {
int32_t len = 0;
const UChar* r = ures_getNextString(fResource, &len, key, &status);
const char16_t* r = ures_getNextString(fResource, &len, key, &status);
return UnicodeString(true, r, len);
}
@ -335,7 +335,7 @@ ResourceBundle ResourceBundle::get(int32_t indexR, UErrorCode& status) const {
UnicodeString ResourceBundle::getStringEx(int32_t indexS, UErrorCode& status) const {
int32_t len = 0;
const UChar* r = ures_getStringByIndex(fResource, indexS, &len, &status);
const char16_t* r = ures_getStringByIndex(fResource, indexS, &len, &status);
return UnicodeString(true, r, len);
}
@ -363,7 +363,7 @@ ResourceBundle ResourceBundle::getWithFallback(const char* key, UErrorCode& stat
}
UnicodeString ResourceBundle::getStringEx(const char* key, UErrorCode& status) const {
int32_t len = 0;
const UChar* r = ures_getStringByKey(fResource, key, &len, &status);
const char16_t* r = ures_getStringByKey(fResource, key, &len, &status);
return UnicodeString(true, r, len);
}

2
icu4c/source/common/resbund_cnv.cpp
View file

@ -49,7 +49,7 @@ ResourceBundle::constructForLocale(const UnicodeString& path,
}
else {
UnicodeString nullTerminatedPath(path);
nullTerminatedPath.append((UChar)0);
nullTerminatedPath.append((char16_t)0);
fResource = ures_openU(nullTerminatedPath.getBuffer(), locale.getName(), &error);
}
}

8
icu4c/source/common/resource.h
View file

@ -136,22 +136,22 @@ public:
*
* @see ures_getString()
*/
virtual const UChar *getString(int32_t &length, UErrorCode &errorCode) const = 0;
virtual const char16_t *getString(int32_t &length, UErrorCode &errorCode) const = 0;
inline UnicodeString getUnicodeString(UErrorCode &errorCode) const {
int32_t len = 0;
const UChar *r = getString(len, errorCode);
const char16_t *r = getString(len, errorCode);
return UnicodeString(true, r, len);
}
/**
* Sets U_RESOURCE_TYPE_MISMATCH if this is not an alias resource.
*/
virtual const UChar *getAliasString(int32_t &length, UErrorCode &errorCode) const = 0;
virtual const char16_t *getAliasString(int32_t &length, UErrorCode &errorCode) const = 0;
inline UnicodeString getAliasUnicodeString(UErrorCode &errorCode) const {
int32_t len = 0;
const UChar *r = getAliasString(len, errorCode);
const char16_t *r = getAliasString(len, errorCode);
return UnicodeString(true, r, len);
}

2
icu4c/source/common/ruleiter.cpp
View file

@ -130,7 +130,7 @@ void RuleCharacterIterator::jumpahead(int32_t count) {
UnicodeString& RuleCharacterIterator::toString(UnicodeString& result) const {
int32_t b = pos.getIndex();
text.extract(0, b, result);
return result.append((UChar) 0x7C).append(text, b, 0x7FFFFFFF); // Insert '|' at index
return result.append((char16_t) 0x7C).append(text, b, 0x7FFFFFFF); // Insert '|' at index
}
*/

4
icu4c/source/common/serv.cpp
View file

@ -25,7 +25,7 @@ U_NAMESPACE_BEGIN
******************************************************************
*/
const UChar ICUServiceKey::PREFIX_DELIMITER = 0x002F; /* '/' */
const char16_t ICUServiceKey::PREFIX_DELIMITER = 0x002F; /* '/' */
ICUServiceKey::ICUServiceKey(const UnicodeString& id)
: _id(id) {
@ -558,7 +558,7 @@ outerEnd:
if (actualReturn != nullptr) {
// strip null prefix
if (result->actualDescriptor.indexOf((UChar)0x2f) == 0) { // U+002f=slash (/)
if (result->actualDescriptor.indexOf((char16_t)0x2f) == 0) { // U+002f=slash (/)
actualReturn->remove();
actualReturn->append(result->actualDescriptor,
1,

2
icu4c/source/common/serv.h
View file

@ -74,7 +74,7 @@ class U_COMMON_API ICUServiceKey : public UObject {
const UnicodeString _id;
protected:
static const UChar PREFIX_DELIMITER;
static const char16_t PREFIX_DELIMITER;
public:

8
icu4c/source/common/servlk.cpp
View file

@ -21,9 +21,9 @@
#include "charstr.h"
#include "uassert.h"
#define UNDERSCORE_CHAR ((UChar)0x005f)
#define AT_SIGN_CHAR ((UChar)64)
#define PERIOD_CHAR ((UChar)46)
#define UNDERSCORE_CHAR ((char16_t)0x005f)
#define AT_SIGN_CHAR ((char16_t)64)
#define PERIOD_CHAR ((char16_t)46)
U_NAMESPACE_BEGIN
@ -74,7 +74,7 @@ LocaleKey::~LocaleKey() {}
UnicodeString&
LocaleKey::prefix(UnicodeString& result) const {
if (_kind != KIND_ANY) {
UChar buffer[64];
char16_t buffer[64];
uprv_itou(buffer, 64, _kind, 10, 0);
UnicodeString temp(buffer);
result.append(temp);

6
icu4c/source/common/servlkf.cpp
View file

@ -22,9 +22,9 @@
#include "ucln_cmn.h"
#include "uassert.h"
#define UNDERSCORE_CHAR ((UChar)0x005f)
#define AT_SIGN_CHAR ((UChar)64)
#define PERIOD_CHAR ((UChar)46)
#define UNDERSCORE_CHAR ((char16_t)0x005f)
#define AT_SIGN_CHAR ((char16_t)64)
#define PERIOD_CHAR ((char16_t)46)
U_NAMESPACE_BEGIN

6
icu4c/source/common/servls.cpp
View file

@ -20,9 +20,9 @@
#include "charstr.h"
#include "uassert.h"
#define UNDERSCORE_CHAR ((UChar)0x005f)
#define AT_SIGN_CHAR ((UChar)64)
#define PERIOD_CHAR ((UChar)46)
#define UNDERSCORE_CHAR ((char16_t)0x005f)
#define AT_SIGN_CHAR ((char16_t)64)
#define PERIOD_CHAR ((char16_t)46)
U_NAMESPACE_BEGIN

6
icu4c/source/common/servrbf.cpp
View file

@ -22,9 +22,9 @@
#include "ucln_cmn.h"
#include "uassert.h"
#define UNDERSCORE_CHAR ((UChar)0x005f)
#define AT_SIGN_CHAR ((UChar)64)
#define PERIOD_CHAR ((UChar)46)
#define UNDERSCORE_CHAR ((char16_t)0x005f)
#define AT_SIGN_CHAR ((char16_t)64)
#define PERIOD_CHAR ((char16_t)46)
U_NAMESPACE_BEGIN

6
icu4c/source/common/servslkf.cpp
View file

@ -21,9 +21,9 @@
#include "charstr.h"
#include "uassert.h"
#define UNDERSCORE_CHAR ((UChar)0x005f)
#define AT_SIGN_CHAR ((UChar)64)
#define PERIOD_CHAR ((UChar)46)
#define UNDERSCORE_CHAR ((char16_t)0x005f)
#define AT_SIGN_CHAR ((char16_t)64)
#define PERIOD_CHAR ((char16_t)46)
U_NAMESPACE_BEGIN

24
icu4c/source/common/simpleformatter.cpp
View file

@ -25,11 +25,11 @@ namespace {
*/
const int32_t ARG_NUM_LIMIT = 0x100;
/**
* Initial and maximum char/UChar value set for a text segment.
* Initial and maximum char/char16_t value set for a text segment.
* Segment length char values are from ARG_NUM_LIMIT+1 to this value here.
* Normally 0xffff, but can be as small as ARG_NUM_LIMIT+1 for testing.
*/
const UChar SEGMENT_LENGTH_PLACEHOLDER_CHAR = 0xffff;
const char16_t SEGMENT_LENGTH_PLACEHOLDER_CHAR = 0xffff;
/**
* Maximum length of a text segment. Longer segments are split into shorter ones.
*/
@ -70,15 +70,15 @@ UBool SimpleFormatter::applyPatternMinMaxArguments(
// Parse consistent with MessagePattern, but
// - support only simple numbered arguments
// - build a simple binary structure into the result string
const UChar *patternBuffer = pattern.getBuffer();
const char16_t *patternBuffer = pattern.getBuffer();
int32_t patternLength = pattern.length();
// Reserve the first char for the number of arguments.
compiledPattern.setTo((UChar)0);
compiledPattern.setTo((char16_t)0);
int32_t textLength = 0;
int32_t maxArg = -1;
UBool inQuote = false;
for (int32_t i = 0; i < patternLength;) {
UChar c = patternBuffer[i++];
char16_t c = patternBuffer[i++];
if (c == APOS) {
if (i < patternLength && (c = patternBuffer[i]) == APOS) {
// double apostrophe, skip the second one
@ -98,7 +98,7 @@ UBool SimpleFormatter::applyPatternMinMaxArguments(
} else if (!inQuote && c == OPEN_BRACE) {
if (textLength > 0) {
compiledPattern.setCharAt(compiledPattern.length() - textLength - 1,
(UChar)(ARG_NUM_LIMIT + textLength));
(char16_t)(ARG_NUM_LIMIT + textLength));
textLength = 0;
}
int32_t argNumber;
@ -129,7 +129,7 @@ UBool SimpleFormatter::applyPatternMinMaxArguments(
if (argNumber > maxArg) {
maxArg = argNumber;
}
compiledPattern.append((UChar)argNumber);
compiledPattern.append((char16_t)argNumber);
continue;
} // else: c is part of literal text
// Append c and track the literal-text segment length.
@ -144,14 +144,14 @@ UBool SimpleFormatter::applyPatternMinMaxArguments(
}
if (textLength > 0) {
compiledPattern.setCharAt(compiledPattern.length() - textLength - 1,
(UChar)(ARG_NUM_LIMIT + textLength));
(char16_t)(ARG_NUM_LIMIT + textLength));
}
int32_t argCount = maxArg + 1;
if (argCount < min || max < argCount) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return false;
}
compiledPattern.setCharAt(0, (UChar)argCount);
compiledPattern.setCharAt(0, (char16_t)argCount);
return true;
}
@ -207,7 +207,7 @@ UnicodeString &SimpleFormatter::formatAndReplace(
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
return result;
}
const UChar *cp = compiledPattern.getBuffer();
const char16_t *cp = compiledPattern.getBuffer();
int32_t cpLength = compiledPattern.length();
if (valuesLength < getArgumentLimit(cp, cpLength)) {
errorCode = U_ILLEGAL_ARGUMENT_ERROR;
@ -246,7 +246,7 @@ UnicodeString &SimpleFormatter::formatAndReplace(
}
UnicodeString SimpleFormatter::getTextWithNoArguments(
const UChar *compiledPattern,
const char16_t *compiledPattern,
int32_t compiledPatternLength,
int32_t* offsets,
int32_t offsetsLength) {
@ -272,7 +272,7 @@ UnicodeString SimpleFormatter::getTextWithNoArguments(
}
UnicodeString &SimpleFormatter::format(
const UChar *compiledPattern, int32_t compiledPatternLength,
const char16_t *compiledPattern, int32_t compiledPatternLength,
const UnicodeString *const *values,
UnicodeString &result, const UnicodeString *resultCopy, UBool forbidResultAsValue,
int32_t *offsets, int32_t offsetsLength,

10
icu4c/source/common/stringtriebuilder.cpp
View file

@ -133,7 +133,7 @@ StringTrieBuilder::writeNode(int32_t start, int32_t limit, int32_t unitIndex) {
// length different units at unitIndex
int32_t
StringTrieBuilder::writeBranchSubNode(int32_t start, int32_t limit, int32_t unitIndex, int32_t length) {
UChar middleUnits[kMaxSplitBranchLevels];
char16_t middleUnits[kMaxSplitBranchLevels];
int32_t lessThan[kMaxSplitBranchLevels];
int32_t ltLength=0;
while(length>getMaxBranchLinearSubNodeLength()) {
@ -154,7 +154,7 @@ StringTrieBuilder::writeBranchSubNode(int32_t start, int32_t limit, int32_t unit
int32_t unitNumber=0;
do {
int32_t i=starts[unitNumber]=start;
UChar unit=getElementUnit(i++, unitIndex);
char16_t unit=getElementUnit(i++, unitIndex);
i=indexOfElementWithNextUnit(i, unitIndex, unit);
isFinal[unitNumber]= start==i-1 && unitIndex+1==getElementStringLength(start);
start=i;
@ -262,7 +262,7 @@ StringTrieBuilder::makeBranchSubNode(int32_t start, int32_t limit, int32_t unitI
if(U_FAILURE(errorCode)) {
return nullptr;
}
UChar middleUnits[kMaxSplitBranchLevels];
char16_t middleUnits[kMaxSplitBranchLevels];
Node *lessThan[kMaxSplitBranchLevels];
int32_t ltLength=0;
while(length>getMaxBranchLinearSubNodeLength()) {
@ -289,7 +289,7 @@ StringTrieBuilder::makeBranchSubNode(int32_t start, int32_t limit, int32_t unitI
int32_t unitNumber=0;
do {
int32_t i=start;
UChar unit=getElementUnit(i++, unitIndex);
char16_t unit=getElementUnit(i++, unitIndex);
i=indexOfElementWithNextUnit(i, unitIndex, unit);
if(start==i-1 && unitIndex+1==getElementStringLength(start)) {
listNode->add(unit, getElementValue(start));
@ -299,7 +299,7 @@ StringTrieBuilder::makeBranchSubNode(int32_t start, int32_t limit, int32_t unitI
start=i;
} while(++unitNumber<length-1);
// unitNumber==length-1, and the maxUnit elements range is [start..limit[
UChar unit=getElementUnit(start, unitIndex);
char16_t unit=getElementUnit(start, unitIndex);
if(start==limit-1 && unitIndex+1==getElementStringLength(start)) {
listNode->add(unit, getElementValue(start));
} else {

40
icu4c/source/common/ubidi.cpp
View file

@ -34,14 +34,14 @@
* rules of the BiDi algorithm, in this example to the second rule of the
* resolution of weak types.
*
* For handling surrogate pairs, where two UChar's form one "abstract" (or UTF-32)
* character according to UTF-16, the second UChar gets the directional property of
* For handling surrogate pairs, where two char16_t's form one "abstract" (or UTF-32)
* character according to UTF-16, the second char16_t gets the directional property of
* the entire character assigned, while the first one gets a BN, a boundary
* neutral, type, which is ignored by most of the algorithm according to
* rule (X9) and the implementation suggestions of the BiDi algorithm.
*
* Later, adjustWSLevels() will set the level for each BN to that of the
* following character (UChar), which results in surrogate pairs getting the
* following character (char16_t), which results in surrogate pairs getting the
* same level on each of their surrogates.
*
* In a UTF-8 implementation, the same thing could be done: the last byte of
@ -337,7 +337,7 @@ ubidi_getReorderingOptions(UBiDi *pBiDi) {
}
U_CAPI UBiDiDirection U_EXPORT2
ubidi_getBaseDirection(const UChar *text,
ubidi_getBaseDirection(const char16_t *text,
int32_t length){
int32_t i;
@ -373,7 +373,7 @@ int32_t length){
*/
static DirProp
firstL_R_AL(UBiDi *pBiDi) {
const UChar *text=pBiDi->prologue;
const char16_t *text=pBiDi->prologue;
int32_t length=pBiDi->proLength;
int32_t i;
UChar32 uchar;
@ -426,7 +426,7 @@ checkParaCount(UBiDi *pBiDi) {
*/
static UBool
getDirProps(UBiDi *pBiDi) {
const UChar *text=pBiDi->text;
const char16_t *text=pBiDi->text;
DirProp *dirProps=pBiDi->dirPropsMemory; /* pBiDi->dirProps is const */
int32_t i=0, originalLength=pBiDi->originalLength;
@ -744,7 +744,7 @@ bracketProcessPDI(BracketData *bd) {
/* newly found opening bracket: create an openings entry */
static UBool /* return true if success */
bracketAddOpening(BracketData *bd, UChar match, int32_t position) {
bracketAddOpening(BracketData *bd, char16_t match, int32_t position) {
IsoRun *pLastIsoRun=&bd->isoRuns[bd->isoRunLast];
Opening *pOpening;
if(pLastIsoRun->limit>=bd->openingsCount) { /* no available new entry */
@ -881,7 +881,7 @@ bracketProcessChar(BracketData *bd, int32_t position) {
dirProps=bd->pBiDi->dirProps;
dirProp=dirProps[position];
if(dirProp==ON) {
UChar c, match;
char16_t c, match;
int32_t idx;
/* First see if it is a matching closing bracket. Hopefully, this is
more efficient than checking if it is a closing bracket at all */
@ -918,7 +918,7 @@ bracketProcessChar(BracketData *bd, int32_t position) {
bracket or it is a case of N0d */
/* Now see if it is an opening bracket */
if(c)
match= static_cast<UChar>(u_getBidiPairedBracket(c)); /* get the matching char */
match= static_cast<char16_t>(u_getBidiPairedBracket(c)); /* get the matching char */
else
match=0;
if(match!=c && /* has a matching char */
@ -1072,7 +1072,7 @@ static UBiDiDirection
resolveExplicitLevels(UBiDi *pBiDi, UErrorCode *pErrorCode) {
DirProp *dirProps=pBiDi->dirProps;
UBiDiLevel *levels=pBiDi->levels;
const UChar *text=pBiDi->text;
const char16_t *text=pBiDi->text;
int32_t i=0, length=pBiDi->length;
Flags flags=pBiDi->flags; /* collect all directionalities in the text */
@ -2068,7 +2068,7 @@ processPropertySeq(UBiDi *pBiDi, LevState *pLevState, uint8_t _prop,
*/
static DirProp
lastL_R_AL(UBiDi *pBiDi) {
const UChar *text=pBiDi->prologue;
const char16_t *text=pBiDi->prologue;
int32_t length=pBiDi->proLength;
int32_t i;
UChar32 uchar;
@ -2096,7 +2096,7 @@ lastL_R_AL(UBiDi *pBiDi) {
*/
static DirProp
firstL_R_AL_EN_AN(UBiDi *pBiDi) {
const UChar *text=pBiDi->epilogue;
const char16_t *text=pBiDi->epilogue;
int32_t length=pBiDi->epiLength;
int32_t i;
UChar32 uchar;
@ -2326,8 +2326,8 @@ adjustWSLevels(UBiDi *pBiDi) {
U_CAPI void U_EXPORT2
ubidi_setContext(UBiDi *pBiDi,
const UChar *prologue, int32_t proLength,
const UChar *epilogue, int32_t epiLength,
const char16_t *prologue, int32_t proLength,
const char16_t *epilogue, int32_t epiLength,
UErrorCode *pErrorCode) {
/* check the argument values */
RETURN_VOID_IF_NULL_OR_FAILING_ERRCODE(pErrorCode);
@ -2362,11 +2362,11 @@ setParaSuccess(UBiDi *pBiDi) {
#define BIDI_ABS(x) ((x)>=0 ? (x) : (-(x)))
static void
setParaRunsOnly(UBiDi *pBiDi, const UChar *text, int32_t length,
setParaRunsOnly(UBiDi *pBiDi, const char16_t *text, int32_t length,
UBiDiLevel paraLevel, UErrorCode *pErrorCode) {
int32_t *runsOnlyMemory = nullptr;
int32_t *visualMap;
UChar *visualText;
char16_t *visualText;
int32_t saveLength, saveTrailingWSStart;
const UBiDiLevel *levels;
UBiDiLevel *saveLevels;
@ -2385,13 +2385,13 @@ setParaRunsOnly(UBiDi *pBiDi, const UChar *text, int32_t length,
goto cleanup3;
}
/* obtain memory for mapping table and visual text */
runsOnlyMemory=static_cast<int32_t *>(uprv_malloc(length*(sizeof(int32_t)+sizeof(UChar)+sizeof(UBiDiLevel))));
runsOnlyMemory=static_cast<int32_t *>(uprv_malloc(length*(sizeof(int32_t)+sizeof(char16_t)+sizeof(UBiDiLevel))));
if(runsOnlyMemory==nullptr) {
*pErrorCode=U_MEMORY_ALLOCATION_ERROR;
goto cleanup3;
}
visualMap=runsOnlyMemory;
visualText=(UChar *)&visualMap[length];
visualText=(char16_t *)&visualMap[length];
saveLevels=(UBiDiLevel *)&visualText[length];
saveOptions=pBiDi->reorderingOptions;
if(saveOptions & UBIDI_OPTION_INSERT_MARKS) {
@ -2551,7 +2551,7 @@ setParaRunsOnly(UBiDi *pBiDi, const UChar *text, int32_t length,
/* ubidi_setPara ------------------------------------------------------------ */
U_CAPI void U_EXPORT2
ubidi_setPara(UBiDi *pBiDi, const UChar *text, int32_t length,
ubidi_setPara(UBiDi *pBiDi, const char16_t *text, int32_t length,
UBiDiLevel paraLevel, UBiDiLevel *embeddingLevels,
UErrorCode *pErrorCode) {
UBiDiDirection direction;
@ -2879,7 +2879,7 @@ ubidi_getDirection(const UBiDi *pBiDi) {
}
}
U_CAPI const UChar * U_EXPORT2
U_CAPI const char16_t * U_EXPORT2
ubidi_getText(const UBiDi *pBiDi) {
if(IS_VALID_PARA_OR_LINE(pBiDi)) {
return pBiDi->text;

10
icu4c/source/common/ubidiln.cpp
View file

@ -694,7 +694,7 @@ ubidi_getRuns(UBiDi *pBiDi, UErrorCode*) {
/* handle remove BiDi control characters */
if(pBiDi->controlCount>0) {
int32_t runIndex;
const UChar *start=pBiDi->text, *limit=start+pBiDi->length, *pu;
const char16_t *start=pBiDi->text, *limit=start+pBiDi->length, *pu;
for(pu=start; pu<limit; pu++) {
if(IS_BIDI_CONTROL_CHAR(*pu)) {
runIndex=getRunFromLogicalIndex(pBiDi, (int32_t)(pu-start));
@ -941,7 +941,7 @@ ubidi_getVisualIndex(UBiDi *pBiDi, int32_t logicalIndex, UErrorCode *pErrorCode)
Run *runs=pBiDi->runs;
int32_t i, j, start, limit, length, insertRemove;
int32_t visualStart=0, controlFound=0;
UChar uchar=pBiDi->text[logicalIndex];
char16_t uchar=pBiDi->text[logicalIndex];
/* is the logical index pointing to a control ? */
if(IS_BIDI_CONTROL_CHAR(uchar)) {
return UBIDI_MAP_NOWHERE;
@ -1036,7 +1036,7 @@ ubidi_getLogicalIndex(UBiDi *pBiDi, int32_t visualIndex, UErrorCode *pErrorCode)
/* handle removed BiDi control characters */
int32_t controlFound=0, insertRemove, length;
int32_t logicalStart, logicalEnd, visualStart=0, j, k;
UChar uchar;
char16_t uchar;
UBool evenRun;
/* add number of controls until visual index */
for(i=0; ; i++, visualStart+=length) {
@ -1171,7 +1171,7 @@ ubidi_getLogicalMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode) {
int32_t controlFound=0, runCount=pBiDi->runCount;
int32_t length, insertRemove;
UBool evenRun;
UChar uchar;
char16_t uchar;
visualStart=0;
/* subtract number of controls found until each index */
for(i=0; i<runCount; i++, visualStart+=length) {
@ -1277,7 +1277,7 @@ ubidi_getVisualMap(UBiDi *pBiDi, int32_t *indexMap, UErrorCode *pErrorCode) {
else if(pBiDi->controlCount>0) {
int32_t runCount=pBiDi->runCount, logicalEnd;
int32_t insertRemove, length, i, j, k, m;
UChar uchar;
char16_t uchar;
UBool evenRun;
runs=pBiDi->runs;
visualStart=0;

18
icu4c/source/common/ubiditransform.cpp
View file

@ -78,8 +78,8 @@ typedef struct {
struct UBiDiTransform {
UBiDi *pBidi; /* pointer to a UBiDi object */
const ReorderingScheme *pActiveScheme; /* effective reordering scheme */
UChar *src; /* input text */
UChar *dest; /* output text */
char16_t *src; /* input text */
char16_t *dest; /* output text */
uint32_t srcLength; /* input text length - not really needed as we are zero-terminated and can u_strlen */
uint32_t srcSize; /* input text capacity excluding the trailing zero */
uint32_t destSize; /* output text capacity */
@ -215,12 +215,12 @@ action_reverse(UBiDiTransform *pTransform, UErrorCode *pErrorCode)
*
* @param pTransform A pointer to the <code>UBiDiTransform</code> structure.
* @param newSrc A pointer whose value is to be used as input text.
* @param newLength A length of the new text in <code>UChar</code>s.
* @param newSize A new source capacity in <code>UChar</code>s.
* @param newLength A length of the new text in <code>char16_t</code>s.
* @param newSize A new source capacity in <code>char16_t</code>s.
* @param pErrorCode Pointer to the error code value.
*/
static void
updateSrc(UBiDiTransform *pTransform, const UChar *newSrc, uint32_t newLength,
updateSrc(UBiDiTransform *pTransform, const char16_t *newSrc, uint32_t newLength,
uint32_t newSize, UErrorCode *pErrorCode)
{
if (newSize < newLength) {
@ -233,7 +233,7 @@ updateSrc(UBiDiTransform *pTransform, const UChar *newSrc, uint32_t newLength,
uprv_free(pTransform->src);
pTransform->src = nullptr;
}
pTransform->src = (UChar *)uprv_malloc(newSize * sizeof(UChar));
pTransform->src = (char16_t *)uprv_malloc(newSize * sizeof(char16_t));
if (pTransform->src == nullptr) {
*pErrorCode = U_MEMORY_ALLOCATION_ERROR;
//pTransform->srcLength = pTransform->srcSize = 0;
@ -387,7 +387,7 @@ static const uint32_t nSchemes = sizeof(Schemes) / sizeof(*Schemes);
* of the first strong bidi character.
*/
static void
resolveBaseDirection(const UChar *text, uint32_t length,
resolveBaseDirection(const char16_t *text, uint32_t length,
UBiDiLevel *pInLevel, UBiDiLevel *pOutLevel)
{
switch (*pInLevel) {
@ -436,8 +436,8 @@ findMatchingScheme(UBiDiLevel inLevel, UBiDiLevel outLevel,
U_CAPI uint32_t U_EXPORT2
ubiditransform_transform(UBiDiTransform *pBiDiTransform,
const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
const char16_t *src, int32_t srcLength,
char16_t *dest, int32_t destSize,
UBiDiLevel inParaLevel, UBiDiOrder inOrder,
UBiDiLevel outParaLevel, UBiDiOrder outOrder,
UBiDiMirroring doMirroring, uint32_t shapingOptions,

28
icu4c/source/common/ubidiwrt.cpp
View file

@ -56,8 +56,8 @@
* we are writing RTL output in reverse.
*/
static int32_t
doWriteForward(const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
doWriteForward(const char16_t *src, int32_t srcLength,
char16_t *dest, int32_t destSize,
uint16_t options,
UErrorCode *pErrorCode) {
/* optimize for several combinations of options */
@ -93,7 +93,7 @@ doWriteForward(const UChar *src, int32_t srcLength,
case UBIDI_REMOVE_BIDI_CONTROLS: {
/* copy the LTR run and remove any BiDi control characters */
int32_t remaining=destSize;
UChar c;
char16_t c;
do {
c=*src++;
if(!IS_BIDI_CONTROL_CHAR(c)) {
@ -149,8 +149,8 @@ doWriteForward(const UChar *src, int32_t srcLength,
}
static int32_t
doWriteReverse(const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
doWriteReverse(const char16_t *src, int32_t srcLength,
char16_t *dest, int32_t destSize,
uint16_t options,
UErrorCode *pErrorCode) {
/*
@ -248,7 +248,7 @@ doWriteReverse(const UChar *src, int32_t srcLength,
/* we need to find out the destination length of the run,
which will not include the BiDi control characters */
int32_t length=srcLength;
UChar ch;
char16_t ch;
i=0;
do {
@ -306,8 +306,8 @@ doWriteReverse(const UChar *src, int32_t srcLength,
}
U_CAPI int32_t U_EXPORT2
ubidi_writeReverse(const UChar *src, int32_t srcLength,
UChar *dest, int32_t destSize,
ubidi_writeReverse(const char16_t *src, int32_t srcLength,
char16_t *dest, int32_t destSize,
uint16_t options,
UErrorCode *pErrorCode) {
int32_t destLength;
@ -355,11 +355,11 @@ ubidi_writeReverse(const UChar *src, int32_t srcLength,
#endif
U_CAPI int32_t U_EXPORT2
ubidi_writeReordered(UBiDi *pBiDi,
UChar *dest, int32_t destSize,
char16_t *dest, int32_t destSize,
uint16_t options,
UErrorCode *pErrorCode) {
const UChar *text;
UChar *saveDest;
const char16_t *text;
char16_t *saveDest;
int32_t length, destCapacity;
int32_t run, runCount, logicalStart, runLength;
@ -459,8 +459,8 @@ ubidi_writeReordered(UBiDi *pBiDi,
} else {
/* insert BiDi controls for "inverse BiDi" */
const DirProp *dirProps=pBiDi->dirProps;
const UChar *src;
UChar uc;
const char16_t *src;
char16_t uc;
UBiDiDirection dir;
int32_t markFlag;
@ -586,7 +586,7 @@ ubidi_writeReordered(UBiDi *pBiDi,
} else {
/* insert BiDi controls for "inverse BiDi" */
const DirProp *dirProps=pBiDi->dirProps;
const UChar *src;
const char16_t *src;
UBiDiDirection dir;
for(run=runCount; --run>=0;) {

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

@ -33,7 +33,7 @@ U_NAMESPACE_USE
U_CAPI UBreakIterator* U_EXPORT2
ubrk_open(UBreakIteratorType type,
const char *locale,
const UChar *text,
const char16_t *text,
int32_t textLength,
UErrorCode *status)
{
@ -94,9 +94,9 @@ ubrk_open(UBreakIteratorType type,
//
//------------------------------------------------------------------------------
U_CAPI UBreakIterator* U_EXPORT2
ubrk_openRules( const UChar *rules,
ubrk_openRules( const char16_t *rules,
int32_t rulesLength,
const UChar *text,
const char16_t *text,
int32_t textLength,
UParseError *parseErr,
UErrorCode *status) {
@ -122,7 +122,7 @@ ubrk_openRules( const UChar *rules,
U_CAPI UBreakIterator* U_EXPORT2
ubrk_openBinaryRules(const uint8_t *binaryRules, int32_t rulesLength,
const UChar * text, int32_t textLength,
const char16_t * text, int32_t textLength,
UErrorCode * status)
{
if (U_FAILURE(*status)) {
@ -188,14 +188,14 @@ ubrk_close(UBreakIterator *bi)
U_CAPI void U_EXPORT2
ubrk_setText(UBreakIterator* bi,
const UChar* text,
const char16_t* text,
int32_t textLength,
UErrorCode* status)
{
UText ut = UTEXT_INITIALIZER;
utext_openUChars(&ut, text, textLength, status);
((BreakIterator*)bi)->setText(&ut, *status);
// A stack allocated UText wrapping a UChar * string
// A stack allocated UText wrapping a char16_t * string
// can be dumped without explicitly closing it.
}

48
icu4c/source/common/ucase.cpp
View file

@ -195,12 +195,12 @@ ucase_totitle(UChar32 c) {
return c;
}
static const UChar iDot[2] = { 0x69, 0x307 };
static const UChar jDot[2] = { 0x6a, 0x307 };
static const UChar iOgonekDot[3] = { 0x12f, 0x307 };
static const UChar iDotGrave[3] = { 0x69, 0x307, 0x300 };
static const UChar iDotAcute[3] = { 0x69, 0x307, 0x301 };
static const UChar iDotTilde[3] = { 0x69, 0x307, 0x303 };
static const char16_t iDot[2] = { 0x69, 0x307 };
static const char16_t jDot[2] = { 0x6a, 0x307 };
static const char16_t iOgonekDot[3] = { 0x12f, 0x307 };
static const char16_t iDotGrave[3] = { 0x69, 0x307, 0x300 };
static const char16_t iDotAcute[3] = { 0x69, 0x307, 0x301 };
static const char16_t iDotTilde[3] = { 0x69, 0x307, 0x303 };
U_CFUNC void U_EXPORT2
@ -250,7 +250,7 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
* full case mappings. Add them all.
*/
const uint16_t *pe0, *pe=GET_EXCEPTIONS(&ucase_props_singleton, props);
const UChar *closure;
const char16_t *closure;
uint16_t excWord=*pe++;
int32_t idx, closureLength, fullLength, length;
@ -276,7 +276,7 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
pe=pe0;
GET_SLOT_VALUE(excWord, UCASE_EXC_CLOSURE, pe, closureLength);
closureLength&=UCASE_CLOSURE_MAX_LENGTH; /* higher bits are reserved */
closure=(const UChar *)pe+1; /* behind this slot, unless there are full case mappings */
closure=(const char16_t *)pe+1; /* behind this slot, unless there are full case mappings */
} else {
closureLength=0;
closure=nullptr;
@ -299,7 +299,7 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
/* add the full case folding string */
length=fullLength&0xf;
if(length!=0) {
sa->addString(sa->set, (const UChar *)pe, length);
sa->addString(sa->set, (const char16_t *)pe, length);
pe+=length;
}
@ -309,7 +309,7 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
fullLength>>=4;
pe+=fullLength;
closure=(const UChar *)pe; /* behind full case mappings */
closure=(const char16_t *)pe; /* behind full case mappings */
}
/* add each code point in the closure string */
@ -325,7 +325,7 @@ ucase_addCaseClosure(UChar32 c, const USetAdder *sa) {
* must be length>0 and max>0 and length<=max
*/
static inline int32_t
strcmpMax(const UChar *s, int32_t length, const UChar *t, int32_t max) {
strcmpMax(const char16_t *s, int32_t length, const char16_t *t, int32_t max) {
int32_t c1, c2;
max-=length; /* we require length<=max, so no need to decrement max in the loop */
@ -350,7 +350,7 @@ strcmpMax(const UChar *s, int32_t length, const UChar *t, int32_t max) {
}
U_CFUNC UBool U_EXPORT2
ucase_addStringCaseClosure(const UChar *s, int32_t length, const USetAdder *sa) {
ucase_addStringCaseClosure(const char16_t *s, int32_t length, const USetAdder *sa) {
int32_t i, start, limit, result, unfoldRows, unfoldRowWidth, unfoldStringWidth;
if(ucase_props_singleton.unfold==nullptr || s==nullptr) {
@ -383,7 +383,7 @@ ucase_addStringCaseClosure(const UChar *s, int32_t length, const USetAdder *sa)
limit=unfoldRows;
while(start<limit) {
i=(start+limit)/2;
const UChar *p=reinterpret_cast<const UChar *>(unfold+(i*unfoldRowWidth));
const char16_t *p=reinterpret_cast<const char16_t *>(unfold+(i*unfoldRowWidth));
result=strcmpMax(s, length, p, unfoldStringWidth);
if(result==0) {
@ -409,7 +409,7 @@ ucase_addStringCaseClosure(const UChar *s, int32_t length, const USetAdder *sa)
U_NAMESPACE_BEGIN
FullCaseFoldingIterator::FullCaseFoldingIterator()
: unfold(reinterpret_cast<const UChar *>(ucase_props_singleton.unfold)),
: unfold(reinterpret_cast<const char16_t *>(ucase_props_singleton.unfold)),
unfoldRows(unfold[UCASE_UNFOLD_ROWS]),
unfoldRowWidth(unfold[UCASE_UNFOLD_ROW_WIDTH]),
unfoldStringWidth(unfold[UCASE_UNFOLD_STRING_WIDTH]),
@ -421,7 +421,7 @@ FullCaseFoldingIterator::FullCaseFoldingIterator()
UChar32
FullCaseFoldingIterator::next(UnicodeString &full) {
// Advance past the last-delivered code point.
const UChar *p=unfold+(currentRow*unfoldRowWidth);
const char16_t *p=unfold+(currentRow*unfoldRowWidth);
if(rowCpIndex>=unfoldRowWidth || p[rowCpIndex]==0) {
++currentRow;
p+=unfoldRowWidth;
@ -1053,7 +1053,7 @@ isFollowedByDotAbove(UCaseContextIterator *iter, void *context) {
U_CAPI int32_t U_EXPORT2
ucase_toFullLower(UChar32 c,
UCaseContextIterator *iter, void *context,
const UChar **pString,
const char16_t **pString,
int32_t loc) {
// The sign of the result has meaning, input must be non-negative so that it can be returned as is.
U_ASSERT(c >= 0);
@ -1180,7 +1180,7 @@ ucase_toFullLower(UChar32 c,
full&=UCASE_FULL_LOWER;
if(full!=0) {
/* set the output pointer to the lowercase mapping */
*pString=reinterpret_cast<const UChar *>(pe+1);
*pString=reinterpret_cast<const char16_t *>(pe+1);
/* return the string length */
return full;
@ -1204,7 +1204,7 @@ ucase_toFullLower(UChar32 c,
static int32_t
toUpperOrTitle(UChar32 c,
UCaseContextIterator *iter, void *context,
const UChar **pString,
const char16_t **pString,
int32_t loc,
UBool upperNotTitle) {
// The sign of the result has meaning, input must be non-negative so that it can be returned as is.
@ -1286,7 +1286,7 @@ toUpperOrTitle(UChar32 c,
if(full!=0) {
/* set the output pointer to the result string */
*pString=reinterpret_cast<const UChar *>(pe);
*pString=reinterpret_cast<const char16_t *>(pe);
/* return the string length */
return full;
@ -1315,7 +1315,7 @@ toUpperOrTitle(UChar32 c,
U_CAPI int32_t U_EXPORT2
ucase_toFullUpper(UChar32 c,
UCaseContextIterator *iter, void *context,
const UChar **pString,
const char16_t **pString,
int32_t caseLocale) {
return toUpperOrTitle(c, iter, context, pString, caseLocale, true);
}
@ -1323,7 +1323,7 @@ ucase_toFullUpper(UChar32 c,
U_CAPI int32_t U_EXPORT2
ucase_toFullTitle(UChar32 c,
UCaseContextIterator *iter, void *context,
const UChar **pString,
const char16_t **pString,
int32_t caseLocale) {
return toUpperOrTitle(c, iter, context, pString, caseLocale, false);
}
@ -1440,7 +1440,7 @@ ucase_fold(UChar32 c, uint32_t options) {
U_CAPI int32_t U_EXPORT2
ucase_toFullFolding(UChar32 c,
const UChar **pString,
const char16_t **pString,
uint32_t options) {
// The sign of the result has meaning, input must be non-negative so that it can be returned as is.
U_ASSERT(c >= 0);
@ -1493,7 +1493,7 @@ ucase_toFullFolding(UChar32 c,
if(full!=0) {
/* set the output pointer to the result string */
*pString=reinterpret_cast<const UChar *>(pe);
*pString=reinterpret_cast<const char16_t *>(pe);
/* return the string length */
return full;
@ -1562,7 +1562,7 @@ u_foldCase(UChar32 c, uint32_t options) {
U_CFUNC int32_t U_EXPORT2
ucase_hasBinaryProperty(UChar32 c, UProperty which) {
/* case mapping properties */
const UChar *resultString;
const char16_t *resultString;
switch(which) {
case UCHAR_LOWERCASE:
return (UBool)(UCASE_LOWER==ucase_getType(c));

6
icu4c/source/common/ucase.h
View file

@ -142,7 +142,7 @@ private:
FullCaseFoldingIterator(const FullCaseFoldingIterator &) = delete; // no copy
FullCaseFoldingIterator &operator=(const FullCaseFoldingIterator &) = delete; // no assignment
const UChar *unfold;
const char16_t *unfold;
int32_t unfoldRows;
int32_t unfoldRowWidth;
int32_t unfoldStringWidth;
@ -159,9 +159,9 @@ private:
namespace LatinCase {
/** Case mapping/folding data for code points up to U+017F. */
constexpr UChar LIMIT = 0x180;
constexpr char16_t LIMIT = 0x180;
/** U+017F case-folds and uppercases crossing the ASCII boundary. */
constexpr UChar LONG_S = 0x17f;
constexpr char16_t LONG_S = 0x17f;
/** Exception: Complex mapping, or too-large delta. */
constexpr int8_t EXC = -0x80;

10
icu4c/source/common/ucasemap.cpp
View file

@ -136,7 +136,7 @@ namespace {
/* append a full case mapping result, see UCASE_MAX_STRING_LENGTH */
inline UBool
appendResult(int32_t cpLength, int32_t result, const UChar *s,
appendResult(int32_t cpLength, int32_t result, const char16_t *s,
ByteSink &sink, uint32_t options, icu::Edits *edits, UErrorCode &errorCode) {
U_ASSERT(U_SUCCESS(errorCode));
@ -292,7 +292,7 @@ void toLower(int32_t caseLocale, uint32_t options,
break;
}
// slow path
const UChar *s;
const char16_t *s;
if (caseLocale >= 0) {
csc->cpStart = cpStart;
csc->cpLimit = srcIndex;
@ -402,7 +402,7 @@ void toUpper(int32_t caseLocale, uint32_t options,
// slow path
csc->cpStart = cpStart;
csc->cpLimit = srcIndex;
const UChar *s;
const char16_t *s;
c = ucase_toFullUpper(c, utf8_caseContextIterator, csc, &s, caseLocale);
if (c >= 0) {
ByteSinkUtil::appendUnchanged(src + prev, cpStart - prev,
@ -580,7 +580,7 @@ ucasemap_internalUTF8ToTitle(
if(c>=0) {
csc.cpStart=titleStart;
csc.cpLimit=titleLimit;
const UChar *s;
const char16_t *s;
c=ucase_toFullTitle(c, utf8_caseContextIterator, &csc, &s, caseLocale);
if (!appendResult(titleLimit-titleStart, c, s, sink, options, edits, errorCode)) {
return;
@ -783,7 +783,7 @@ void toUpper(uint32_t options,
}
}
} else if(c>=0) {
const UChar *s;
const char16_t *s;
c=ucase_toFullUpper(c, nullptr, nullptr, &s, UCASE_LOC_GREEK);
if (!appendResult(nextIndex - i, c, s, sink, options, edits, errorCode)) {
return;

24
icu4c/source/common/ucasemap_imp.h
View file

@ -139,16 +139,16 @@ ustrcase_getCaseLocale(const char *locale);
/** Implements UStringCaseMapper. */
U_CFUNC int32_t U_CALLCONV
ustrcase_internalToLower(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const char16_t *src, int32_t srcLength,
icu::Edits *edits,
UErrorCode &errorCode);
/** Implements UStringCaseMapper. */
U_CFUNC int32_t U_CALLCONV
ustrcase_internalToUpper(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const char16_t *src, int32_t srcLength,
icu::Edits *edits,
UErrorCode &errorCode);
@ -158,8 +158,8 @@ ustrcase_internalToUpper(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_IT
U_CFUNC int32_t U_CALLCONV
ustrcase_internalToTitle(int32_t caseLocale, uint32_t options,
icu::BreakIterator *iter,
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const char16_t *src, int32_t srcLength,
icu::Edits *edits,
UErrorCode &errorCode);
@ -168,8 +168,8 @@ ustrcase_internalToTitle(int32_t caseLocale, uint32_t options,
/** Implements UStringCaseMapper. */
U_CFUNC int32_t U_CALLCONV
ustrcase_internalFold(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const char16_t *src, int32_t srcLength,
icu::Edits *edits,
UErrorCode &errorCode);
@ -179,8 +179,8 @@ ustrcase_internalFold(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERA
*/
U_CFUNC int32_t
ustrcase_map(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const char16_t *src, int32_t srcLength,
UStringCaseMapper *stringCaseMapper,
icu::Edits *edits,
UErrorCode &errorCode);
@ -192,8 +192,8 @@ ustrcase_map(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
*/
U_CFUNC int32_t
ustrcase_mapWithOverlap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITERATOR_PARAM
UChar *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
char16_t *dest, int32_t destCapacity,
const char16_t *src, int32_t srcLength,
UStringCaseMapper *stringCaseMapper,
UErrorCode &errorCode);

6
icu4c/source/common/ucat.cpp
View file

@ -46,13 +46,13 @@ u_catclose(u_nl_catd catd) {
ures_close((UResourceBundle*) catd); /* may be nullptr */
}
U_CAPI const UChar* U_EXPORT2
U_CAPI const char16_t* U_EXPORT2
u_catgets(u_nl_catd catd, int32_t set_num, int32_t msg_num,
const UChar* s,
const char16_t* s,
int32_t* len, UErrorCode* ec) {
char key[MAX_KEY_LEN];
const UChar* result;
const char16_t* result;
if (ec == nullptr || U_FAILURE(*ec)) {
goto ERROR;

22
icu4c/source/common/ucharstrie.cpp
View file

@ -30,7 +30,7 @@ UCharsTrie::~UCharsTrie() {
UStringTrieResult
UCharsTrie::current() const {
const UChar *pos=pos_;
const char16_t *pos=pos_;
if(pos==nullptr) {
return USTRINGTRIE_NO_MATCH;
} else {
@ -59,7 +59,7 @@ UCharsTrie::nextForCodePoint(UChar32 cp) {
}
UStringTrieResult
UCharsTrie::branchNext(const UChar *pos, int32_t length, int32_t uchar) {
UCharsTrie::branchNext(const char16_t *pos, int32_t length, int32_t uchar) {
// Branch according to the current unit.
if(length==0) {
length=*pos++;
@ -121,7 +121,7 @@ UCharsTrie::branchNext(const UChar *pos, int32_t length, int32_t uchar) {
}
UStringTrieResult
UCharsTrie::nextImpl(const UChar *pos, int32_t uchar) {
UCharsTrie::nextImpl(const char16_t *pos, int32_t uchar) {
int32_t node=*pos++;
for(;;) {
if(node<kMinLinearMatch) {
@ -153,7 +153,7 @@ UCharsTrie::nextImpl(const UChar *pos, int32_t uchar) {
UStringTrieResult
UCharsTrie::next(int32_t uchar) {
const UChar *pos=pos_;
const char16_t *pos=pos_;
if(pos==nullptr) {
return USTRINGTRIE_NO_MATCH;
}
@ -176,12 +176,12 @@ UCharsTrie::next(int32_t uchar) {
UStringTrieResult
UCharsTrie::next(ConstChar16Ptr ptr, int32_t sLength) {
const UChar *s=ptr;
const char16_t *s=ptr;
if(sLength<0 ? *s==0 : sLength==0) {
// Empty input.
return current();
}
const UChar *pos=pos_;
const char16_t *pos=pos_;
if(pos==nullptr) {
return USTRINGTRIE_NO_MATCH;
}
@ -282,8 +282,8 @@ UCharsTrie::next(ConstChar16Ptr ptr, int32_t sLength) {
}
}
const UChar *
UCharsTrie::findUniqueValueFromBranch(const UChar *pos, int32_t length,
const char16_t *
UCharsTrie::findUniqueValueFromBranch(const char16_t *pos, int32_t length,
UBool haveUniqueValue, int32_t &uniqueValue) {
while(length>kMaxBranchLinearSubNodeLength) {
++pos; // ignore the comparison unit
@ -321,7 +321,7 @@ UCharsTrie::findUniqueValueFromBranch(const UChar *pos, int32_t length,
}
UBool
UCharsTrie::findUniqueValue(const UChar *pos, UBool haveUniqueValue, int32_t &uniqueValue) {
UCharsTrie::findUniqueValue(const char16_t *pos, UBool haveUniqueValue, int32_t &uniqueValue) {
int32_t node=*pos++;
for(;;) {
if(node<kMinLinearMatch) {
@ -365,7 +365,7 @@ UCharsTrie::findUniqueValue(const UChar *pos, UBool haveUniqueValue, int32_t &un
int32_t
UCharsTrie::getNextUChars(Appendable &out) const {
const UChar *pos=pos_;
const char16_t *pos=pos_;
if(pos==nullptr) {
return 0;
}
@ -397,7 +397,7 @@ UCharsTrie::getNextUChars(Appendable &out) const {
}
void
UCharsTrie::getNextBranchUChars(const UChar *pos, int32_t length, Appendable &out) {
UCharsTrie::getNextBranchUChars(const char16_t *pos, int32_t length, Appendable &out) {
while(length>kMaxBranchLinearSubNodeLength) {
++pos; // ignore the comparison unit
getNextBranchUChars(jumpByDelta(pos), length>>1, out);

66
icu4c/source/common/ucharstriebuilder.cpp
View file

@ -47,7 +47,7 @@ public:
return strings[stringOffset];
}
UChar charAt(int32_t index, const UnicodeString &strings) const {
char16_t charAt(int32_t index, const UnicodeString &strings) const {
return strings[stringOffset+1+index];
}
@ -75,7 +75,7 @@ UCharsTrieElement::setTo(const UnicodeString &s, int32_t val,
return;
}
stringOffset=strings.length();
strings.append((UChar)length);
strings.append((char16_t)length);
value=val;
strings.append(s);
}
@ -204,7 +204,7 @@ UCharsTrieBuilder::buildUChars(UStringTrieBuildOption buildOption, UErrorCode &e
prev.fastCopyFrom(current);
}
}
// Create and UChar-serialize the trie for the elements.
// Create and char16_t-serialize the trie for the elements.
ucharsLength=0;
int32_t capacity=strings.length();
if(capacity<1024) {
@ -212,7 +212,7 @@ UCharsTrieBuilder::buildUChars(UStringTrieBuildOption buildOption, UErrorCode &e
}
if(ucharsCapacity<capacity) {
uprv_free(uchars);
uchars=static_cast<UChar *>(uprv_malloc(capacity*2));
uchars=static_cast<char16_t *>(uprv_malloc(capacity*2));
if(uchars==nullptr) {
errorCode=U_MEMORY_ALLOCATION_ERROR;
ucharsCapacity=0;
@ -231,7 +231,7 @@ UCharsTrieBuilder::getElementStringLength(int32_t i) const {
return elements[i].getStringLength(strings);
}
UChar
char16_t
UCharsTrieBuilder::getElementUnit(int32_t i, int32_t unitIndex) const {
return elements[i].charAt(unitIndex, strings);
}
@ -257,7 +257,7 @@ UCharsTrieBuilder::countElementUnits(int32_t start, int32_t limit, int32_t unitI
int32_t length=0; // Number of different units at unitIndex.
int32_t i=start;
do {
UChar unit=elements[i++].charAt(unitIndex, strings);
char16_t unit=elements[i++].charAt(unitIndex, strings);
while(i<limit && unit==elements[i].charAt(unitIndex, strings)) {
++i;
}
@ -269,7 +269,7 @@ UCharsTrieBuilder::countElementUnits(int32_t start, int32_t limit, int32_t unitI
int32_t
UCharsTrieBuilder::skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t count) const {
do {
UChar unit=elements[i++].charAt(unitIndex, strings);
char16_t unit=elements[i++].charAt(unitIndex, strings);
while(unit==elements[i].charAt(unitIndex, strings)) {
++i;
}
@ -278,14 +278,14 @@ UCharsTrieBuilder::skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t
}
int32_t
UCharsTrieBuilder::indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, UChar unit) const {
UCharsTrieBuilder::indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const {
while(unit==elements[i].charAt(unitIndex, strings)) {
++i;
}
return i;
}
UCharsTrieBuilder::UCTLinearMatchNode::UCTLinearMatchNode(const UChar *units, int32_t len, Node *nextNode)
UCharsTrieBuilder::UCTLinearMatchNode::UCTLinearMatchNode(const char16_t *units, int32_t len, Node *nextNode)
: LinearMatchNode(len, nextNode), s(units) {
hash=hash*37u+ustr_hashUCharsN(units, len);
}
@ -329,7 +329,7 @@ UCharsTrieBuilder::ensureCapacity(int32_t length) {
do {
newCapacity*=2;
} while(newCapacity<=length);
UChar *newUChars=static_cast<UChar *>(uprv_malloc(newCapacity*2));
char16_t *newUChars=static_cast<char16_t *>(uprv_malloc(newCapacity*2));
if(newUChars==nullptr) {
// unable to allocate memory
uprv_free(uchars);
@ -351,13 +351,13 @@ UCharsTrieBuilder::write(int32_t unit) {
int32_t newLength=ucharsLength+1;
if(ensureCapacity(newLength)) {
ucharsLength=newLength;
uchars[ucharsCapacity-ucharsLength]=(UChar)unit;
uchars[ucharsCapacity-ucharsLength]=(char16_t)unit;
}
return ucharsLength;
}
int32_t
UCharsTrieBuilder::write(const UChar *s, int32_t length) {
UCharsTrieBuilder::write(const char16_t *s, int32_t length) {
int32_t newLength=ucharsLength+length;
if(ensureCapacity(newLength)) {
ucharsLength=newLength;
@ -376,22 +376,22 @@ UCharsTrieBuilder::writeValueAndFinal(int32_t i, UBool isFinal) {
if(0<=i && i<=UCharsTrie::kMaxOneUnitValue) {
return write(i|(isFinal<<15));
}
UChar intUnits[3];
char16_t intUnits[3];
int32_t length;
if(i<0 || i>UCharsTrie::kMaxTwoUnitValue) {
intUnits[0]=(UChar)(UCharsTrie::kThreeUnitValueLead);
intUnits[1]=(UChar)((uint32_t)i>>16);
intUnits[2]=(UChar)i;
intUnits[0]=(char16_t)(UCharsTrie::kThreeUnitValueLead);
intUnits[1]=(char16_t)((uint32_t)i>>16);
intUnits[2]=(char16_t)i;
length=3;
// } else if(i<=UCharsTrie::kMaxOneUnitValue) {
// intUnits[0]=(UChar)(i);
// intUnits[0]=(char16_t)(i);
// length=1;
} else {
intUnits[0]=(UChar)(UCharsTrie::kMinTwoUnitValueLead+(i>>16));
intUnits[1]=(UChar)i;
intUnits[0]=(char16_t)(UCharsTrie::kMinTwoUnitValueLead+(i>>16));
intUnits[1]=(char16_t)i;
length=2;
}
intUnits[0]=(UChar)(intUnits[0]|(isFinal<<15));
intUnits[0]=(char16_t)(intUnits[0]|(isFinal<<15));
return write(intUnits, length);
}
@ -400,22 +400,22 @@ UCharsTrieBuilder::writeValueAndType(UBool hasValue, int32_t value, int32_t node
if(!hasValue) {
return write(node);
}
UChar intUnits[3];
char16_t intUnits[3];
int32_t length;
if(value<0 || value>UCharsTrie::kMaxTwoUnitNodeValue) {
intUnits[0]=(UChar)(UCharsTrie::kThreeUnitNodeValueLead);
intUnits[1]=(UChar)((uint32_t)value>>16);
intUnits[2]=(UChar)value;
intUnits[0]=(char16_t)(UCharsTrie::kThreeUnitNodeValueLead);
intUnits[1]=(char16_t)((uint32_t)value>>16);
intUnits[2]=(char16_t)value;
length=3;
} else if(value<=UCharsTrie::kMaxOneUnitNodeValue) {
intUnits[0]=(UChar)((value+1)<<6);
intUnits[0]=(char16_t)((value+1)<<6);
length=1;
} else {
intUnits[0]=(UChar)(UCharsTrie::kMinTwoUnitNodeValueLead+((value>>10)&0x7fc0));
intUnits[1]=(UChar)value;
intUnits[0]=(char16_t)(UCharsTrie::kMinTwoUnitNodeValueLead+((value>>10)&0x7fc0));
intUnits[1]=(char16_t)value;
length=2;
}
intUnits[0]|=(UChar)node;
intUnits[0]|=(char16_t)node;
return write(intUnits, length);
}
@ -426,17 +426,17 @@ UCharsTrieBuilder::writeDeltaTo(int32_t jumpTarget) {
if(i<=UCharsTrie::kMaxOneUnitDelta) {
return write(i);
}
UChar intUnits[3];
char16_t intUnits[3];
int32_t length;
if(i<=UCharsTrie::kMaxTwoUnitDelta) {
intUnits[0]=(UChar)(UCharsTrie::kMinTwoUnitDeltaLead+(i>>16));
intUnits[0]=(char16_t)(UCharsTrie::kMinTwoUnitDeltaLead+(i>>16));
length=1;
} else {
intUnits[0]=(UChar)(UCharsTrie::kThreeUnitDeltaLead);
intUnits[1]=(UChar)(i>>16);
intUnits[0]=(char16_t)(UCharsTrie::kThreeUnitDeltaLead);
intUnits[1]=(char16_t)(i>>16);
length=2;
}
intUnits[length++]=(UChar)i;
intUnits[length++]=(char16_t)i;
return write(intUnits, length);
}

8
icu4c/source/common/ucharstrieiterator.cpp
View file

@ -102,7 +102,7 @@ UCharsTrie::Iterator::next(UErrorCode &errorCode) {
if(U_FAILURE(errorCode)) {
return false;
}
const UChar *pos=pos_;
const char16_t *pos=pos_;
if(pos==nullptr) {
if(stack_->isEmpty()) {
return false;
@ -182,8 +182,8 @@ UCharsTrie::Iterator::next(UErrorCode &errorCode) {
}
// Branch node, needs to take the first outbound edge and push state for the rest.
const UChar *
UCharsTrie::Iterator::branchNext(const UChar *pos, int32_t length, UErrorCode &errorCode) {
const char16_t *
UCharsTrie::Iterator::branchNext(const char16_t *pos, int32_t length, UErrorCode &errorCode) {
while(length>kMaxBranchLinearSubNodeLength) {
++pos; // ignore the comparison unit
// Push state for the greater-or-equal edge.
@ -195,7 +195,7 @@ UCharsTrie::Iterator::branchNext(const UChar *pos, int32_t length, UErrorCode &e
}
// List of key-value pairs where values are either final values or jump deltas.
// Read the first (key, value) pair.
UChar trieUnit=*pos++;
char16_t trieUnit=*pos++;
int32_t node=*pos++;
UBool isFinal=(UBool)(node>>15);
int32_t value=readValue(pos, node&=0x7fff);

16
icu4c/source/common/uchriter.cpp
View file

@ -94,7 +94,7 @@ UCharCharacterIterator::clone() const {
return new UCharCharacterIterator(*this);
}
UChar
char16_t
UCharCharacterIterator::first() {
pos = begin;
if(pos < end) {
@ -104,7 +104,7 @@ UCharCharacterIterator::first() {
}
}
UChar
char16_t
UCharCharacterIterator::firstPostInc() {
pos = begin;
if(pos < end) {
@ -114,7 +114,7 @@ UCharCharacterIterator::firstPostInc() {
}
}
UChar
char16_t
UCharCharacterIterator::last() {
pos = end;
if(pos > begin) {
@ -124,7 +124,7 @@ UCharCharacterIterator::last() {
}
}
UChar
char16_t
UCharCharacterIterator::setIndex(int32_t position) {
if(position < begin) {
pos = begin;
@ -140,7 +140,7 @@ UCharCharacterIterator::setIndex(int32_t position) {
}
}
UChar
char16_t
UCharCharacterIterator::current() const {
if (pos >= begin && pos < end) {
return text[pos];
@ -149,7 +149,7 @@ UCharCharacterIterator::current() const {
}
}
UChar
char16_t
UCharCharacterIterator::next() {
if (pos + 1 < end) {
return text[++pos];
@ -160,7 +160,7 @@ UCharCharacterIterator::next() {
}
}
UChar
char16_t
UCharCharacterIterator::nextPostInc() {
if (pos < end) {
return text[pos++];
@ -174,7 +174,7 @@ UCharCharacterIterator::hasNext() {
return (UBool)(pos < end ? true : false);
}
UChar
char16_t
UCharCharacterIterator::previous() {
if (pos > begin) {
return text[--pos];

90
icu4c/source/common/ucnv.cpp
View file

@ -48,7 +48,7 @@
typedef struct UAmbiguousConverter {
const char *name;
const UChar variant5c;
const char16_t variant5c;
} UAmbiguousConverter;
static const UAmbiguousConverter ambiguousConverters[]={
@ -89,9 +89,9 @@ ucnv_openPackage (const char *packageName, const char *converterName, UErrorCo
return ucnv_createConverterFromPackage(packageName, converterName, err);
}
/*Extracts the UChar* to a char* and calls through createConverter */
/*Extracts the char16_t* to a char* and calls through createConverter */
U_CAPI UConverter* U_EXPORT2
ucnv_openU (const UChar * name,
ucnv_openU (const char16_t * name,
UErrorCode * err)
{
char asciiName[UCNV_MAX_CONVERTER_NAME_LENGTH];
@ -479,7 +479,7 @@ ucnv_setSubstChars (UConverter * converter,
U_CAPI void U_EXPORT2
ucnv_setSubstString(UConverter *cnv,
const UChar *s,
const char16_t *s,
int32_t length,
UErrorCode *err) {
alignas(UConverter) char cloneBuffer[U_CNV_SAFECLONE_BUFFERSIZE];
@ -517,7 +517,7 @@ ucnv_setSubstString(UConverter *cnv,
if (length > UCNV_ERROR_BUFFER_LENGTH) {
/*
* Should not occur. The converter should output at least one byte
* per UChar, which means that ucnv_fromUChars() should catch all
* per char16_t, which means that ucnv_fromUChars() should catch all
* overflows.
*/
*err = U_BUFFER_OVERFLOW_ERROR;
@ -833,7 +833,7 @@ static void
_fromUnicodeWithCallback(UConverterFromUnicodeArgs *pArgs, UErrorCode *err) {
UConverterFromUnicode fromUnicode;
UConverter *cnv;
const UChar *s;
const char16_t *s;
char *t;
int32_t *offsets;
int32_t sourceIndex;
@ -841,8 +841,8 @@ _fromUnicodeWithCallback(UConverterFromUnicodeArgs *pArgs, UErrorCode *err) {
UBool converterSawEndOfInput, calledCallback;
/* variables for m:n conversion */
UChar replay[UCNV_EXT_MAX_UCHARS];
const UChar *realSource, *realSourceLimit;
char16_t replay[UCNV_EXT_MAX_UCHARS];
const char16_t *realSource, *realSourceLimit;
int32_t realSourceIndex;
UBool realFlush;
@ -1176,12 +1176,12 @@ ucnv_outputOverflowFromUnicode(UConverter *cnv,
U_CAPI void U_EXPORT2
ucnv_fromUnicode(UConverter *cnv,
char **target, const char *targetLimit,
const UChar **source, const UChar *sourceLimit,
const char16_t **source, const char16_t *sourceLimit,
int32_t *offsets,
UBool flush,
UErrorCode *err) {
UConverterFromUnicodeArgs args;
const UChar *s;
const char16_t *s;
char *t;
/* check parameters */
@ -1200,10 +1200,10 @@ ucnv_fromUnicode(UConverter *cnv,
if ((const void *)U_MAX_PTR(sourceLimit) == (const void *)sourceLimit) {
/*
Prevent code from going into an infinite loop in case we do hit this
limit. The limit pointer is expected to be on a UChar * boundary.
limit. The limit pointer is expected to be on a char16_t * boundary.
This also prevents the next argument check from failing.
*/
sourceLimit = (const UChar *)(((const char *)sourceLimit) - 1);
sourceLimit = (const char16_t *)(((const char *)sourceLimit) - 1);
}
/*
@ -1222,8 +1222,8 @@ ucnv_fromUnicode(UConverter *cnv,
* consumed or the target filled (unless an error occurs).
* An adjustment would be targetLimit=t+0x7fffffff; for example.
*
* 3) Make sure that the user didn't incorrectly cast a UChar * pointer
* to a char * pointer and provide an incomplete UChar code unit.
* 3) Make sure that the user didn't incorrectly cast a char16_t * pointer
* to a char * pointer and provide an incomplete char16_t code unit.
*/
if (sourceLimit<s || targetLimit<t ||
((size_t)(sourceLimit-s)>(size_t)0x3fffffff && sourceLimit>s) ||
@ -1279,7 +1279,7 @@ _toUnicodeWithCallback(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
UConverterToUnicode toUnicode;
UConverter *cnv;
const char *s;
UChar *t;
char16_t *t;
int32_t *offsets;
int32_t sourceIndex;
int32_t errorInputLength;
@ -1568,11 +1568,11 @@ _toUnicodeWithCallback(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
*/
static UBool
ucnv_outputOverflowToUnicode(UConverter *cnv,
UChar **target, const UChar *targetLimit,
char16_t **target, const char16_t *targetLimit,
int32_t **pOffsets,
UErrorCode *err) {
int32_t *offsets;
UChar *overflow, *t;
char16_t *overflow, *t;
int32_t i, length;
t=*target;
@ -1621,14 +1621,14 @@ ucnv_outputOverflowToUnicode(UConverter *cnv,
U_CAPI void U_EXPORT2
ucnv_toUnicode(UConverter *cnv,
UChar **target, const UChar *targetLimit,
char16_t **target, const char16_t *targetLimit,
const char **source, const char *sourceLimit,
int32_t *offsets,
UBool flush,
UErrorCode *err) {
UConverterToUnicodeArgs args;
const char *s;
UChar *t;
char16_t *t;
/* check parameters */
if(err==nullptr || U_FAILURE(*err)) {
@ -1646,10 +1646,10 @@ ucnv_toUnicode(UConverter *cnv,
if ((const void *)U_MAX_PTR(targetLimit) == (const void *)targetLimit) {
/*
Prevent code from going into an infinite loop in case we do hit this
limit. The limit pointer is expected to be on a UChar * boundary.
limit. The limit pointer is expected to be on a char16_t * boundary.
This also prevents the next argument check from failing.
*/
targetLimit = (const UChar *)(((const char *)targetLimit) - 1);
targetLimit = (const char16_t *)(((const char *)targetLimit) - 1);
}
/*
@ -1668,8 +1668,8 @@ ucnv_toUnicode(UConverter *cnv,
* consumed or the target filled (unless an error occurs).
* An adjustment would be sourceLimit=t+0x7fffffff; for example.
*
* 3) Make sure that the user didn't incorrectly cast a UChar * pointer
* to a char * pointer and provide an incomplete UChar code unit.
* 3) Make sure that the user didn't incorrectly cast a char16_t * pointer
* to a char * pointer and provide an incomplete char16_t code unit.
*/
if (sourceLimit<s || targetLimit<t ||
((size_t)(sourceLimit-s)>(size_t)0x7fffffff && sourceLimit>s) ||
@ -1723,9 +1723,9 @@ ucnv_toUnicode(UConverter *cnv,
U_CAPI int32_t U_EXPORT2
ucnv_fromUChars(UConverter *cnv,
char *dest, int32_t destCapacity,
const UChar *src, int32_t srcLength,
const char16_t *src, int32_t srcLength,
UErrorCode *pErrorCode) {
const UChar *srcLimit;
const char16_t *srcLimit;
char *originalDest, *destLimit;
int32_t destLength;
@ -1778,11 +1778,11 @@ ucnv_fromUChars(UConverter *cnv,
U_CAPI int32_t U_EXPORT2
ucnv_toUChars(UConverter *cnv,
UChar *dest, int32_t destCapacity,
char16_t *dest, int32_t destCapacity,
const char *src, int32_t srcLength,
UErrorCode *pErrorCode) {
const char *srcLimit;
UChar *originalDest, *destLimit;
char16_t *originalDest, *destLimit;
int32_t destLength;
/* check arguments */
@ -1816,7 +1816,7 @@ ucnv_toUChars(UConverter *cnv,
/* if an overflow occurs, then get the preflighting length */
if(*pErrorCode==U_BUFFER_OVERFLOW_ERROR)
{
UChar buffer[1024];
char16_t buffer[1024];
destLimit=buffer+UPRV_LENGTHOF(buffer);
do {
@ -1841,7 +1841,7 @@ ucnv_getNextUChar(UConverter *cnv,
const char **source, const char *sourceLimit,
UErrorCode *err) {
UConverterToUnicodeArgs args;
UChar buffer[U16_MAX_LENGTH];
char16_t buffer[U16_MAX_LENGTH];
const char *s;
UChar32 c;
int32_t i, length;
@ -1883,7 +1883,7 @@ ucnv_getNextUChar(UConverter *cnv,
/* flush the target overflow buffer */
if(cnv->UCharErrorBufferLength>0) {
UChar *overflow;
char16_t *overflow;
overflow=cnv->UCharErrorBuffer;
i=0;
@ -1949,7 +1949,7 @@ ucnv_getNextUChar(UConverter *cnv,
}
}
/* convert to one UChar in buffer[0], or handle getNextUChar() errors */
/* convert to one char16_t in buffer[0], or handle getNextUChar() errors */
_toUnicodeWithCallback(&args, err);
if(*err==U_BUFFER_OVERFLOW_ERROR) {
@ -1960,7 +1960,7 @@ ucnv_getNextUChar(UConverter *cnv,
length=(int32_t)(args.target-buffer);
} else {
/* write the lead surrogate from the overflow buffer */
buffer[0]=(UChar)c;
buffer[0]=(char16_t)c;
args.target=buffer+1;
i=0;
length=1;
@ -1982,7 +1982,7 @@ ucnv_getNextUChar(UConverter *cnv,
/* consume c=buffer[0], done */
} else {
/* got a lead surrogate, see if a trail surrogate follows */
UChar c2;
char16_t c2;
if(cnv->UCharErrorBufferLength>0) {
/* got overflow output from the conversion */
@ -2045,13 +2045,13 @@ U_CAPI void U_EXPORT2
ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
char **target, const char *targetLimit,
const char **source, const char *sourceLimit,
UChar *pivotStart, UChar **pivotSource,
UChar **pivotTarget, const UChar *pivotLimit,
char16_t *pivotStart, char16_t **pivotSource,
char16_t **pivotTarget, const char16_t *pivotLimit,
UBool reset, UBool flush,
UErrorCode *pErrorCode) {
UChar pivotBuffer[CHUNK_SIZE];
const UChar *myPivotSource;
UChar *myPivotTarget;
char16_t pivotBuffer[CHUNK_SIZE];
const char16_t *myPivotSource;
char16_t *myPivotTarget;
const char *s;
char *t;
@ -2100,7 +2100,7 @@ ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
/* use the stack pivot buffer */
myPivotSource=myPivotTarget=pivotStart=pivotBuffer;
pivotSource=(UChar **)&myPivotSource;
pivotSource=(char16_t **)&myPivotSource;
pivotTarget=&myPivotTarget;
pivotLimit=pivotBuffer+CHUNK_SIZE;
} else if( pivotStart>=pivotLimit ||
@ -2229,7 +2229,7 @@ ucnv_convertEx(UConverter *targetCnv, UConverter *sourceCnv,
_fromUnicodeWithCallback(&fromUArgs, pErrorCode);
if(U_FAILURE(*pErrorCode)) {
/* target overflow, or conversion error */
*pivotSource=(UChar *)fromUArgs.source;
*pivotSource=(char16_t *)fromUArgs.source;
break;
}
@ -2405,8 +2405,8 @@ ucnv_internalConvert(UConverter *outConverter, UConverter *inConverter,
char *target, int32_t targetCapacity,
const char *source, int32_t sourceLength,
UErrorCode *pErrorCode) {
UChar pivotBuffer[CHUNK_SIZE];
UChar *pivot, *pivot2;
char16_t pivotBuffer[CHUNK_SIZE];
char16_t *pivot, *pivot2;
char *myTarget;
const char *sourceLimit;
@ -2660,11 +2660,11 @@ static const UAmbiguousConverter *ucnv_getAmbiguous(const UConverter *cnv)
U_CAPI void U_EXPORT2
ucnv_fixFileSeparator(const UConverter *cnv,
UChar* source,
char16_t* source,
int32_t sourceLength) {
const UAmbiguousConverter *a;
int32_t i;
UChar variant5c;
char16_t variant5c;
if(cnv==nullptr || source==nullptr || sourceLength<=0 || (a=ucnv_getAmbiguous(cnv))==nullptr)
{
@ -2724,7 +2724,7 @@ ucnv_getInvalidChars (const UConverter * converter,
U_CAPI void U_EXPORT2
ucnv_getInvalidUChars (const UConverter * converter,
UChar *errChars,
char16_t *errChars,
int8_t * len,
UErrorCode * err)
{

60
icu4c/source/common/ucnv2022.cpp
View file

@ -1259,7 +1259,7 @@ T_UConverter_toUnicode_ISO_2022_OFFSETS_LOGIC(UConverterToUnicodeArgs* args,
UErrorCode* err){
const char* mySourceLimit, *realSourceLimit;
const char* sourceStart;
const UChar* myTargetStart;
const char16_t* myTargetStart;
UConverter* saveThis;
UConverterDataISO2022* myData;
int8_t length;
@ -1667,8 +1667,8 @@ UConverter_fromUnicode_ISO_2022_JP_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args
ISO2022State *pFromU2022State;
uint8_t *target = (uint8_t *) args->target;
const uint8_t *targetLimit = (const uint8_t *) args->targetLimit;
const UChar* source = args->source;
const UChar* sourceLimit = args->sourceLimit;
const char16_t* source = args->source;
const char16_t* sourceLimit = args->sourceLimit;
int32_t* offsets = args->offsets;
UChar32 sourceChar;
char buffer[8];
@ -1703,7 +1703,7 @@ getTrail:
/*look ahead to find the trail surrogate*/
if(source < sourceLimit) {
/* test the following code unit */
UChar trail=(UChar) *source;
char16_t trail=(char16_t) *source;
if(U16_IS_TRAIL(trail)) {
source++;
sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);
@ -2082,7 +2082,7 @@ UConverter_toUnicode_ISO_2022_JP_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[2];
const char *mySource = (char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const char *mySourceLimit = args->sourceLimit;
uint32_t targetUniChar = 0x0000;
uint32_t mySourceChar = 0x0000;
@ -2281,25 +2281,25 @@ getTrailByte:
if(args->offsets){
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
*(myTarget++)=(UChar)targetUniChar;
*(myTarget++)=(char16_t)targetUniChar;
}
else if(targetUniChar > missingCharMarker){
/* disassemble the surrogate pair and write to output*/
targetUniChar-=0x0010000;
*myTarget = (UChar)(0xd800+(UChar)(targetUniChar>>10));
*myTarget = (char16_t)(0xd800+(char16_t)(targetUniChar>>10));
if(args->offsets){
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
++myTarget;
if(myTarget< args->targetLimit){
*myTarget = (UChar)(0xdc00+(UChar)(targetUniChar&0x3ff));
*myTarget = (char16_t)(0xdc00+(char16_t)(targetUniChar&0x3ff));
if(args->offsets){
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
++myTarget;
}else{
args->converter->UCharErrorBuffer[args->converter->UCharErrorBufferLength++]=
(UChar)(0xdc00+(UChar)(targetUniChar&0x3ff));
(char16_t)(0xdc00+(char16_t)(targetUniChar&0x3ff));
}
}
@ -2356,8 +2356,8 @@ UConverter_fromUnicode_ISO_2022_KR_OFFSETS_LOGIC_IBM(UConverterFromUnicodeArgs*
static void U_CALLCONV
UConverter_fromUnicode_ISO_2022_KR_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args, UErrorCode* err){
const UChar *source = args->source;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *source = args->source;
const char16_t *sourceLimit = args->sourceLimit;
unsigned char *target = (unsigned char *) args->target;
unsigned char *targetLimit = (unsigned char *) args->targetLimit;
int32_t* offsets = args->offsets;
@ -2480,7 +2480,7 @@ getTrail:
/*look ahead to find the trail surrogate*/
if(source < sourceLimit) {
/* test the following code unit */
UChar trail=(UChar) *source;
char16_t trail=(char16_t) *source;
if(U16_IS_TRAIL(trail)) {
source++;
sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);
@ -2627,7 +2627,7 @@ UConverter_toUnicode_ISO_2022_KR_OFFSETS_LOGIC_IBM(UConverterToUnicodeArgs *args
if(args->offsets != nullptr && sourceStart != args->source) {
/* update offsets to base them on the actual start of the input */
int32_t *offsets = args->offsets;
UChar *target = args->target;
char16_t *target = args->target;
int32_t delta = (int32_t)(args->source - sourceStart);
while(target < subArgs.target) {
if(*offsets >= 0) {
@ -2675,10 +2675,10 @@ UConverter_toUnicode_ISO_2022_KR_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[2];
const char *mySource = ( char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const char *mySourceLimit = args->sourceLimit;
UChar32 targetUniChar = 0x0000;
UChar mySourceChar = 0x0000;
char16_t mySourceChar = 0x0000;
UConverterDataISO2022* myData;
UConverterSharedData* sharedData ;
UBool useFallback;
@ -2772,7 +2772,7 @@ getTrailByte:
/* report a pair of illegal bytes if the second byte is not a DBCS starter */
++mySource;
/* add another bit so that the code below writes 2 bytes in case of error */
mySourceChar = static_cast<UChar>(0x10000 | (mySourceChar << 8) | trailByte);
mySourceChar = static_cast<char16_t>(0x10000 | (mySourceChar << 8) | trailByte);
}
} else {
args->converter->toUBytes[0] = (uint8_t)mySourceChar;
@ -2789,7 +2789,7 @@ getTrailByte:
if(args->offsets) {
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
*(myTarget++)=(UChar)targetUniChar;
*(myTarget++)=(char16_t)targetUniChar;
}
else {
/* Call the callback function*/
@ -2919,8 +2919,8 @@ UConverter_fromUnicode_ISO_2022_CN_OFFSETS_LOGIC(UConverterFromUnicodeArgs* args
ISO2022State *pFromU2022State;
uint8_t *target = (uint8_t *) args->target;
const uint8_t *targetLimit = (const uint8_t *) args->targetLimit;
const UChar* source = args->source;
const UChar* sourceLimit = args->sourceLimit;
const char16_t* source = args->source;
const char16_t* sourceLimit = args->sourceLimit;
int32_t* offsets = args->offsets;
UChar32 sourceChar;
char buffer[8];
@ -2952,7 +2952,7 @@ getTrail:
/*look ahead to find the trail surrogate*/
if(source < sourceLimit) {
/* test the following code unit */
UChar trail=(UChar) *source;
char16_t trail=(char16_t) *source;
if(U16_IS_TRAIL(trail)) {
source++;
sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);
@ -3268,7 +3268,7 @@ UConverter_toUnicode_ISO_2022_CN_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[3];
const char *mySource = (char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const char *mySourceLimit = args->sourceLimit;
uint32_t targetUniChar = 0x0000;
uint32_t mySourceChar = 0x0000;
@ -3417,7 +3417,7 @@ getTrailByte:
}
else{
if(mySourceChar <= 0x7f) {
targetUniChar = (UChar) mySourceChar;
targetUniChar = (char16_t) mySourceChar;
}
}
break;
@ -3426,25 +3426,25 @@ getTrailByte:
if(args->offsets){
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
*(myTarget++)=(UChar)targetUniChar;
*(myTarget++)=(char16_t)targetUniChar;
}
else if(targetUniChar > missingCharMarker){
/* disassemble the surrogate pair and write to output*/
targetUniChar-=0x0010000;
*myTarget = (UChar)(0xd800+(UChar)(targetUniChar>>10));
*myTarget = (char16_t)(0xd800+(char16_t)(targetUniChar>>10));
if(args->offsets){
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
++myTarget;
if(myTarget< args->targetLimit){
*myTarget = (UChar)(0xdc00+(UChar)(targetUniChar&0x3ff));
*myTarget = (char16_t)(0xdc00+(char16_t)(targetUniChar&0x3ff));
if(args->offsets){
args->offsets[myTarget - args->target] = (int32_t)(mySource - args->source - (mySourceChar <= 0xff ? 1 : 2));
}
++myTarget;
}else{
args->converter->UCharErrorBuffer[args->converter->UCharErrorBufferLength++]=
(UChar)(0xdc00+(UChar)(targetUniChar&0x3ff));
(char16_t)(0xdc00+(char16_t)(targetUniChar&0x3ff));
}
}
@ -3805,7 +3805,7 @@ static const UConverterStaticData _ISO2022StaticData={
UCNV_IBM,
UCNV_ISO_2022,
1,
3, /* max 3 bytes per UChar from UTF-8 (4 bytes from surrogate _pair_) */
3, /* max 3 bytes per char16_t from UTF-8 (4 bytes from surrogate _pair_) */
{ 0x1a, 0, 0, 0 },
1,
false,
@ -3850,7 +3850,7 @@ static const UConverterStaticData _ISO2022JPStaticData={
UCNV_IBM,
UCNV_ISO_2022,
1,
6, /* max 6 bytes per UChar: 4-byte escape sequence + DBCS */
6, /* max 6 bytes per char16_t: 4-byte escape sequence + DBCS */
{ 0x1a, 0, 0, 0 },
1,
false,
@ -3901,7 +3901,7 @@ static const UConverterStaticData _ISO2022KRStaticData={
UCNV_IBM,
UCNV_ISO_2022,
1,
8, /* max 8 bytes per UChar */
8, /* max 8 bytes per char16_t */
{ 0x1a, 0, 0, 0 },
1,
false,
@ -3952,7 +3952,7 @@ static const UConverterStaticData _ISO2022CNStaticData={
UCNV_IBM,
UCNV_ISO_2022,
1,
8, /* max 8 bytes per UChar: 4-byte CNS designator + 2 bytes for SS2/SS3 + DBCS */
8, /* max 8 bytes per char16_t: 4-byte CNS designator + 2 bytes for SS2/SS3 + DBCS */
{ 0x1a, 0, 0, 0 },
1,
false,

10
icu4c/source/common/ucnv_cb.cpp
View file

@ -54,8 +54,8 @@ ucnv_cbFromUWriteBytes (UConverterFromUnicodeArgs *args,
U_CAPI void U_EXPORT2
ucnv_cbFromUWriteUChars(UConverterFromUnicodeArgs *args,
const UChar** source,
const UChar* sourceLimit,
const char16_t** source,
const char16_t* sourceLimit,
int32_t offsetIndex,
UErrorCode * err)
{
@ -200,7 +200,7 @@ ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
* and will not recurse.
* At worst we should get a U_BUFFER_OVERFLOW_ERROR.
*/
const UChar *source = (const UChar *)converter->subChars;
const char16_t *source = (const char16_t *)converter->subChars;
ucnv_cbFromUWriteUChars(args, &source, source - length, offsetIndex, err);
return;
}
@ -226,7 +226,7 @@ ucnv_cbFromUWriteSub (UConverterFromUnicodeArgs *args,
U_CAPI void U_EXPORT2
ucnv_cbToUWriteUChars (UConverterToUnicodeArgs *args,
const UChar* source,
const char16_t* source,
int32_t length,
int32_t offsetIndex,
UErrorCode * err)
@ -248,7 +248,7 @@ ucnv_cbToUWriteSub (UConverterToUnicodeArgs *args,
int32_t offsetIndex,
UErrorCode * err)
{
static const UChar kSubstituteChar1 = 0x1A, kSubstituteChar = 0xFFFD;
static const char16_t kSubstituteChar1 = 0x1A, kSubstituteChar = 0xFFFD;
/* could optimize this case, just one uchar */
if(args->converter->invalidCharLength == 1 && args->converter->subChar1 != 0) {

14
icu4c/source/common/ucnv_cnv.cpp
View file

@ -93,12 +93,12 @@ ucnv_fromUWriteBytes(UConverter *cnv,
U_CFUNC void
ucnv_toUWriteUChars(UConverter *cnv,
const UChar *uchars, int32_t length,
UChar **target, const UChar *targetLimit,
const char16_t *uchars, int32_t length,
char16_t **target, const char16_t *targetLimit,
int32_t **offsets,
int32_t sourceIndex,
UErrorCode *pErrorCode) {
UChar *t=*target;
char16_t *t=*target;
int32_t *o;
/* write UChars */
@ -134,24 +134,24 @@ ucnv_toUWriteUChars(UConverter *cnv,
U_CFUNC void
ucnv_toUWriteCodePoint(UConverter *cnv,
UChar32 c,
UChar **target, const UChar *targetLimit,
char16_t **target, const char16_t *targetLimit,
int32_t **offsets,
int32_t sourceIndex,
UErrorCode *pErrorCode) {
UChar *t;
char16_t *t;
int32_t *o;
t=*target;
if(t<targetLimit) {
if(c<=0xffff) {
*t++=(UChar)c;
*t++=(char16_t)c;
c=U_SENTINEL;
} else /* c is a supplementary code point */ {
*t++=U16_LEAD(c);
c=U16_TRAIL(c);
if(t<targetLimit) {
*t++=(UChar)c;
*t++=(char16_t)c;
c=U_SENTINEL;
}
}

8
icu4c/source/common/ucnv_ct.cpp
View file

@ -336,8 +336,8 @@ UConverter_fromUnicode_CompoundText_OFFSETS(UConverterFromUnicodeArgs* args, UEr
UConverter *cnv = args->converter;
uint8_t *target = (uint8_t *) args->target;
const uint8_t *targetLimit = (const uint8_t *) args->targetLimit;
const UChar* source = args->source;
const UChar* sourceLimit = args->sourceLimit;
const char16_t* source = args->source;
const char16_t* sourceLimit = args->sourceLimit;
/* int32_t* offsets = args->offsets; */
UChar32 sourceChar;
UBool useFallback = cnv->useFallback;
@ -368,7 +368,7 @@ getTrail:
/*look ahead to find the trail surrogate*/
if(source < sourceLimit) {
/* test the following code unit */
UChar trail=(UChar) *source;
char16_t trail=(char16_t) *source;
if(U16_IS_TRAIL(trail)) {
source++;
sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);
@ -467,7 +467,7 @@ static void U_CALLCONV
UConverter_toUnicode_CompoundText_OFFSETS(UConverterToUnicodeArgs *args,
UErrorCode* err){
const char *mySource = (char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const char *mySourceLimit = args->sourceLimit;
const char *tmpSourceLimit = mySourceLimit;
uint32_t mySourceChar = 0x0000;

84
icu4c/source/common/ucnv_err.cpp
View file

@ -91,7 +91,7 @@ U_CAPI void U_EXPORT2
UCNV_FROM_U_CALLBACK_STOP (
const void *context,
UConverterFromUnicodeArgs *fromUArgs,
const UChar* codeUnits,
const char16_t* codeUnits,
int32_t length,
UChar32 codePoint,
UConverterCallbackReason reason,
@ -132,7 +132,7 @@ U_CAPI void U_EXPORT2
UCNV_FROM_U_CALLBACK_SKIP (
const void *context,
UConverterFromUnicodeArgs *fromUArgs,
const UChar* codeUnits,
const char16_t* codeUnits,
int32_t length,
UChar32 codePoint,
UConverterCallbackReason reason,
@ -163,7 +163,7 @@ U_CAPI void U_EXPORT2
UCNV_FROM_U_CALLBACK_SUBSTITUTE (
const void *context,
UConverterFromUnicodeArgs *fromArgs,
const UChar* codeUnits,
const char16_t* codeUnits,
int32_t length,
UChar32 codePoint,
UConverterCallbackReason reason,
@ -199,18 +199,18 @@ U_CAPI void U_EXPORT2
UCNV_FROM_U_CALLBACK_ESCAPE (
const void *context,
UConverterFromUnicodeArgs *fromArgs,
const UChar *codeUnits,
const char16_t *codeUnits,
int32_t length,
UChar32 codePoint,
UConverterCallbackReason reason,
UErrorCode * err)
{
UChar valueString[VALUE_STRING_LENGTH];
char16_t valueString[VALUE_STRING_LENGTH];
int32_t valueStringLength = 0;
int32_t i = 0;
const UChar *myValueSource = nullptr;
const char16_t *myValueSource = nullptr;
UErrorCode err2 = U_ZERO_ERROR;
UConverterFromUCallback original = nullptr;
const void *originalContext;
@ -247,8 +247,8 @@ UCNV_FROM_U_CALLBACK_ESCAPE (
{
while (i < length)
{
valueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */
valueString[valueStringLength++] = (char16_t) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
valueString[valueStringLength++] = (char16_t) UNICODE_U_CODEPOINT; /* adding U */
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4);
}
}
@ -259,78 +259,78 @@ UCNV_FROM_U_CALLBACK_ESCAPE (
case UCNV_PRV_ESCAPE_JAVA:
while (i < length)
{
valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */
valueString[valueStringLength++] = (UChar) UNICODE_U_LOW_CODEPOINT; /* adding u */
valueString[valueStringLength++] = (char16_t) UNICODE_RS_CODEPOINT; /* adding \ */
valueString[valueStringLength++] = (char16_t) UNICODE_U_LOW_CODEPOINT; /* adding u */
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4);
}
break;
case UCNV_PRV_ESCAPE_C:
valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */
valueString[valueStringLength++] = (char16_t) UNICODE_RS_CODEPOINT; /* adding \ */
if(length==2){
valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */
valueString[valueStringLength++] = (char16_t) UNICODE_U_CODEPOINT; /* adding U */
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 8);
}
else{
valueString[valueStringLength++] = (UChar) UNICODE_U_LOW_CODEPOINT; /* adding u */
valueString[valueStringLength++] = (char16_t) UNICODE_U_LOW_CODEPOINT; /* adding u */
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 4);
}
break;
case UCNV_PRV_ESCAPE_XML_DEC:
valueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */
valueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */
valueString[valueStringLength++] = (char16_t) UNICODE_AMP_CODEPOINT; /* adding & */
valueString[valueStringLength++] = (char16_t) UNICODE_HASH_CODEPOINT; /* adding # */
if(length==2){
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 10, 0);
}
else{
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 10, 0);
}
valueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
valueString[valueStringLength++] = (char16_t) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
break;
case UCNV_PRV_ESCAPE_XML_HEX:
valueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */
valueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */
valueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */
valueString[valueStringLength++] = (char16_t) UNICODE_AMP_CODEPOINT; /* adding & */
valueString[valueStringLength++] = (char16_t) UNICODE_HASH_CODEPOINT; /* adding # */
valueString[valueStringLength++] = (char16_t) UNICODE_X_LOW_CODEPOINT; /* adding x */
if(length==2){
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0);
}
else{
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 0);
}
valueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
valueString[valueStringLength++] = (char16_t) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
break;
case UCNV_PRV_ESCAPE_UNICODE:
valueString[valueStringLength++] = (UChar) UNICODE_LEFT_CURLY_CODEPOINT; /* adding { */
valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */
valueString[valueStringLength++] = (UChar) UNICODE_PLUS_CODEPOINT; /* adding + */
valueString[valueStringLength++] = (char16_t) UNICODE_LEFT_CURLY_CODEPOINT; /* adding { */
valueString[valueStringLength++] = (char16_t) UNICODE_U_CODEPOINT; /* adding U */
valueString[valueStringLength++] = (char16_t) UNICODE_PLUS_CODEPOINT; /* adding + */
if (length == 2) {
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 4);
} else {
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[0], 16, 4);
}
valueString[valueStringLength++] = (UChar) UNICODE_RIGHT_CURLY_CODEPOINT; /* adding } */
valueString[valueStringLength++] = (char16_t) UNICODE_RIGHT_CURLY_CODEPOINT; /* adding } */
break;
case UCNV_PRV_ESCAPE_CSS2:
valueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */
valueString[valueStringLength++] = (char16_t) UNICODE_RS_CODEPOINT; /* adding \ */
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, codePoint, 16, 0);
/* Always add space character, because the next character might be whitespace,
which would erroneously be considered the termination of the escape sequence. */
valueString[valueStringLength++] = (UChar) UNICODE_SPACE_CODEPOINT;
valueString[valueStringLength++] = (char16_t) UNICODE_SPACE_CODEPOINT;
break;
default:
while (i < length)
{
valueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
valueString[valueStringLength++] = (UChar) UNICODE_U_CODEPOINT; /* adding U */
valueString[valueStringLength++] = (char16_t) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
valueString[valueStringLength++] = (char16_t) UNICODE_U_CODEPOINT; /* adding U */
valueStringLength += uprv_itou (valueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint16_t)codeUnits[i++], 16, 4);
}
}
@ -417,7 +417,7 @@ UCNV_TO_U_CALLBACK_ESCAPE (
UConverterCallbackReason reason,
UErrorCode * err)
{
UChar uniValueString[VALUE_STRING_LENGTH];
char16_t uniValueString[VALUE_STRING_LENGTH];
int32_t valueStringLength = 0;
int32_t i = 0;
@ -430,8 +430,8 @@ UCNV_TO_U_CALLBACK_ESCAPE (
{
while (i < length)
{
uniValueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
uniValueString[valueStringLength++] = (UChar) UNICODE_X_CODEPOINT; /* adding X */
uniValueString[valueStringLength++] = (char16_t) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
uniValueString[valueStringLength++] = (char16_t) UNICODE_X_CODEPOINT; /* adding X */
valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t) codeUnits[i++], 16, 2);
}
}
@ -442,36 +442,36 @@ UCNV_TO_U_CALLBACK_ESCAPE (
case UCNV_PRV_ESCAPE_XML_DEC:
while (i < length)
{
uniValueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */
uniValueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */
uniValueString[valueStringLength++] = (char16_t) UNICODE_AMP_CODEPOINT; /* adding & */
uniValueString[valueStringLength++] = (char16_t) UNICODE_HASH_CODEPOINT; /* adding # */
valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 10, 0);
uniValueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
uniValueString[valueStringLength++] = (char16_t) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
}
break;
case UCNV_PRV_ESCAPE_XML_HEX:
while (i < length)
{
uniValueString[valueStringLength++] = (UChar) UNICODE_AMP_CODEPOINT; /* adding & */
uniValueString[valueStringLength++] = (UChar) UNICODE_HASH_CODEPOINT; /* adding # */
uniValueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */
uniValueString[valueStringLength++] = (char16_t) UNICODE_AMP_CODEPOINT; /* adding & */
uniValueString[valueStringLength++] = (char16_t) UNICODE_HASH_CODEPOINT; /* adding # */
uniValueString[valueStringLength++] = (char16_t) UNICODE_X_LOW_CODEPOINT; /* adding x */
valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 16, 0);
uniValueString[valueStringLength++] = (UChar) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
uniValueString[valueStringLength++] = (char16_t) UNICODE_SEMICOLON_CODEPOINT; /* adding ; */
}
break;
case UCNV_PRV_ESCAPE_C:
while (i < length)
{
uniValueString[valueStringLength++] = (UChar) UNICODE_RS_CODEPOINT; /* adding \ */
uniValueString[valueStringLength++] = (UChar) UNICODE_X_LOW_CODEPOINT; /* adding x */
uniValueString[valueStringLength++] = (char16_t) UNICODE_RS_CODEPOINT; /* adding \ */
uniValueString[valueStringLength++] = (char16_t) UNICODE_X_LOW_CODEPOINT; /* adding x */
valueStringLength += uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t)codeUnits[i++], 16, 2);
}
break;
default:
while (i < length)
{
uniValueString[valueStringLength++] = (UChar) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
uniValueString[valueStringLength++] = (UChar) UNICODE_X_CODEPOINT; /* adding X */
uniValueString[valueStringLength++] = (char16_t) UNICODE_PERCENT_SIGN_CODEPOINT; /* adding % */
uniValueString[valueStringLength++] = (char16_t) UNICODE_X_CODEPOINT; /* adding X */
uprv_itou (uniValueString + valueStringLength, VALUE_STRING_LENGTH - valueStringLength, (uint8_t) codeUnits[i++], 16, 2);
valueStringLength += 2;
}

38
icu4c/source/common/ucnv_ext.cpp
View file

@ -198,7 +198,7 @@ ucnv_extMatchToU(const int32_t *cx, int8_t sisoState,
}
}
/* search for the current UChar */
/* search for the current char16_t */
value=ucnv_extFindToU(toUSection, length, b);
if(value==0) {
/* no match here, stop with the longest match so far */
@ -236,7 +236,7 @@ ucnv_extMatchToU(const int32_t *cx, int8_t sisoState,
static inline void
ucnv_extWriteToU(UConverter *cnv, const int32_t *cx,
uint32_t value,
UChar **target, const UChar *targetLimit,
char16_t **target, const char16_t *targetLimit,
int32_t **offsets, int32_t srcIndex,
UErrorCode *pErrorCode) {
/* output the result */
@ -251,7 +251,7 @@ ucnv_extWriteToU(UConverter *cnv, const int32_t *cx,
/* output a string - with correct data we have resultLength>0 */
ucnv_toUWriteUChars(
cnv,
UCNV_EXT_ARRAY(cx, UCNV_EXT_TO_U_UCHARS_INDEX, UChar)+
UCNV_EXT_ARRAY(cx, UCNV_EXT_TO_U_UCHARS_INDEX, char16_t)+
UCNV_EXT_TO_U_GET_INDEX(value),
UCNV_EXT_TO_U_GET_LENGTH(value),
target, targetLimit,
@ -279,7 +279,7 @@ U_CFUNC UBool
ucnv_extInitialMatchToU(UConverter *cnv, const int32_t *cx,
int32_t firstLength,
const char **src, const char *srcLimit,
UChar **target, const UChar *targetLimit,
char16_t **target, const char16_t *targetLimit,
int32_t **offsets, int32_t srcIndex,
UBool flush,
UErrorCode *pErrorCode) {
@ -459,10 +459,10 @@ extFromUUseMapping(UBool useFallback, uint32_t value, UChar32 firstCP) {
}
/*
* @return index of the UChar, if found; else <0
* @return index of the char16_t, if found; else <0
*/
static inline int32_t
ucnv_extFindFromU(const UChar *fromUSection, int32_t length, UChar u) {
ucnv_extFindFromU(const char16_t *fromUSection, int32_t length, char16_t u) {
int32_t i, start, limit;
/* binary search */
@ -530,19 +530,19 @@ ucnv_extFindFromU(const UChar *fromUSection, int32_t length, UChar u) {
static int32_t
ucnv_extMatchFromU(const int32_t *cx,
UChar32 firstCP,
const UChar *pre, int32_t preLength,
const UChar *src, int32_t srcLength,
const char16_t *pre, int32_t preLength,
const char16_t *src, int32_t srcLength,
uint32_t *pMatchValue,
UBool useFallback, UBool flush) {
const uint16_t *stage12, *stage3;
const uint32_t *stage3b;
const UChar *fromUTableUChars, *fromUSectionUChars;
const char16_t *fromUTableUChars, *fromUSectionUChars;
const uint32_t *fromUTableValues, *fromUSectionValues;
uint32_t value, matchValue;
int32_t i, j, idx, length, matchLength;
UChar c;
char16_t c;
if(cx==nullptr) {
return 0; /* no extension data, no match */
@ -575,7 +575,7 @@ ucnv_extMatchFromU(const int32_t *cx,
idx=(int32_t)UCNV_EXT_FROM_U_GET_PARTIAL_INDEX(value);
/* initialize */
fromUTableUChars=UCNV_EXT_ARRAY(cx, UCNV_EXT_FROM_U_UCHARS_INDEX, UChar);
fromUTableUChars=UCNV_EXT_ARRAY(cx, UCNV_EXT_FROM_U_UCHARS_INDEX, char16_t);
fromUTableValues=UCNV_EXT_ARRAY(cx, UCNV_EXT_FROM_U_VALUES_INDEX, uint32_t);
matchValue=0;
@ -618,7 +618,7 @@ ucnv_extMatchFromU(const int32_t *cx,
}
}
/* search for the current UChar */
/* search for the current char16_t */
idx=ucnv_extFindFromU(fromUSectionUChars, length, c);
if(idx<0) {
/* no match here, stop with the longest match so far */
@ -749,7 +749,7 @@ ucnv_extWriteFromU(UConverter *cnv, const int32_t *cx,
U_CFUNC UBool
ucnv_extInitialMatchFromU(UConverter *cnv, const int32_t *cx,
UChar32 cp,
const UChar **src, const UChar *srcLimit,
const char16_t **src, const char16_t *srcLimit,
char **target, const char *targetLimit,
int32_t **offsets, int32_t srcIndex,
UBool flush,
@ -781,7 +781,7 @@ ucnv_extInitialMatchFromU(UConverter *cnv, const int32_t *cx,
return true;
} else if(match<0) {
/* save state for partial match */
const UChar *s;
const char16_t *s;
int32_t j;
/* copy the first code point */
@ -901,7 +901,7 @@ ucnv_extContinueMatchFromU(UConverter *cnv,
pErrorCode);
} else if(match<0) {
/* save state for partial match */
const UChar *s;
const char16_t *s;
int32_t j;
/* just _append_ the newly consumed input to preFromU[] */
@ -981,16 +981,16 @@ ucnv_extGetUnicodeSetString(const UConverterSharedData *sharedData,
UConverterUnicodeSet which,
int32_t minLength,
UChar32 firstCP,
UChar s[UCNV_EXT_MAX_UCHARS], int32_t length,
char16_t s[UCNV_EXT_MAX_UCHARS], int32_t length,
int32_t sectionIndex,
UErrorCode *pErrorCode) {
const UChar *fromUSectionUChars;
const char16_t *fromUSectionUChars;
const uint32_t *fromUSectionValues;
uint32_t value;
int32_t i, count;
fromUSectionUChars=UCNV_EXT_ARRAY(cx, UCNV_EXT_FROM_U_UCHARS_INDEX, UChar)+sectionIndex;
fromUSectionUChars=UCNV_EXT_ARRAY(cx, UCNV_EXT_FROM_U_UCHARS_INDEX, char16_t)+sectionIndex;
fromUSectionValues=UCNV_EXT_ARRAY(cx, UCNV_EXT_FROM_U_VALUES_INDEX, uint32_t)+sectionIndex;
/* read first pair of the section */
@ -1039,7 +1039,7 @@ ucnv_extGetUnicodeSet(const UConverterSharedData *sharedData,
uint32_t value;
int32_t st1, stage1Length, st2, st3, minLength;
UChar s[UCNV_EXT_MAX_UCHARS];
char16_t s[UCNV_EXT_MAX_UCHARS];
UChar32 c;
int32_t length;

22
icu4c/source/common/ucnv_lmb.cpp
View file

@ -298,8 +298,8 @@ ambiguous mappings: */
static const struct _UniLMBCSGrpMap
{
const UChar uniStartRange;
const UChar uniEndRange;
const char16_t uniStartRange;
const char16_t uniEndRange;
const ulmbcs_byte_t GrpType;
} UniLMBCSGrpMap[]
=
@ -445,7 +445,7 @@ static const struct _UniLMBCSGrpMap
};
static ulmbcs_byte_t
FindLMBCSUniRange(UChar uniChar)
FindLMBCSUniRange(char16_t uniChar)
{
const struct _UniLMBCSGrpMap * pTable = UniLMBCSGrpMap;
@ -748,7 +748,7 @@ LMBCSConversionWorker (
UConverterDataLMBCS * extraInfo, /* subconverters, opt & locale groups */
ulmbcs_byte_t group, /* The group to try */
ulmbcs_byte_t * pStartLMBCS, /* where to put the results */
UChar * pUniChar, /* The input unicode character */
char16_t * pUniChar, /* The input unicode character */
ulmbcs_byte_t * lastConverterIndex, /* output: track last successful group used */
UBool * groups_tried /* output: track any unsuccessful groups */
)
@ -824,7 +824,7 @@ LMBCSConversionWorker (
know we are writing LMBCS using the Unicode group
*/
static size_t
LMBCSConvertUni(ulmbcs_byte_t * pLMBCS, UChar uniChar)
LMBCSConvertUni(ulmbcs_byte_t * pLMBCS, char16_t uniChar)
{
/* encode into LMBCS Unicode range */
uint8_t LowCh = (uint8_t)(uniChar & 0x00FF);
@ -853,7 +853,7 @@ _LMBCSFromUnicode(UConverterFromUnicodeArgs* args,
UErrorCode* err)
{
ulmbcs_byte_t lastConverterIndex = 0;
UChar uniChar;
char16_t uniChar;
ulmbcs_byte_t LMBCS[ULMBCS_CHARSIZE_MAX];
ulmbcs_byte_t * pLMBCS;
int32_t bytes_written;
@ -1085,7 +1085,7 @@ _LMBCSFromUnicode(UConverterFromUnicodeArgs* args,
/* A function to call when we are looking at the Unicode group byte in LMBCS */
static UChar
static char16_t
GetUniFromLMBCSUni(char const ** ppLMBCSin) /* Called with LMBCS-style Unicode byte stream */
{
uint8_t HighCh = *(*ppLMBCSin)++; /* Big-endian Unicode in LMBCS compatibility group*/
@ -1096,7 +1096,7 @@ GetUniFromLMBCSUni(char const ** ppLMBCSin) /* Called with LMBCS-style Unicode
HighCh = LowCh;
LowCh = 0; /* zero-byte in LSB special character */
}
return (UChar)((HighCh << 8) | LowCh);
return (char16_t)((HighCh << 8) | LowCh);
}
@ -1264,7 +1264,7 @@ _LMBCSToUnicodeWithOffsets(UConverterToUnicodeArgs* args,
UErrorCode* err)
{
char LMBCS [ULMBCS_CHARSIZE_MAX];
UChar uniChar; /* one output UNICODE char */
char16_t uniChar; /* one output UNICODE char */
const char * saveSource; /* beginning of current code point */
const char * pStartLMBCS = args->source; /* beginning of whole string */
const char * errSource = nullptr; /* pointer to actual input in case an error occurs */
@ -1292,7 +1292,7 @@ _LMBCSToUnicodeWithOffsets(UConverterToUnicodeArgs* args,
args->source = errSource = LMBCS;
args->sourceLimit = LMBCS+size_old+size_new;
savebytes = (int8_t)(size_old+size_new);
uniChar = (UChar) _LMBCSGetNextUCharWorker(args, err);
uniChar = (char16_t) _LMBCSGetNextUCharWorker(args, err);
args->source = saveSource + ((args->source - LMBCS) - size_old);
args->sourceLimit = saveSourceLimit;
@ -1314,7 +1314,7 @@ _LMBCSToUnicodeWithOffsets(UConverterToUnicodeArgs* args,
else
{
errSource = saveSource;
uniChar = (UChar) _LMBCSGetNextUCharWorker(args, err);
uniChar = (char16_t) _LMBCSGetNextUCharWorker(args, err);
savebytes = (int8_t)(args->source - saveSource);
}
if (U_SUCCESS(*err))

76
icu4c/source/common/ucnv_u16.cpp
View file

@ -52,12 +52,12 @@ static void U_CALLCONV
_UTF16BEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source;
const char16_t *source;
char *target;
int32_t *offsets;
uint32_t targetCapacity, length, sourceIndex;
UChar c, trail;
char16_t c, trail;
char overflow[4];
source=pArgs->source;
@ -92,7 +92,7 @@ _UTF16BEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
/* c!=0 indicates in several places outside the main loops that a surrogate was found */
if((c=(UChar)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
if((c=(char16_t)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
/* the last buffer ended with a lead surrogate, output the surrogate pair */
++source;
--length;
@ -257,11 +257,11 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source;
UChar *target;
char16_t *target;
int32_t *offsets;
uint32_t targetCapacity, length, count, sourceIndex;
UChar c, trail;
char16_t c, trail;
if(pArgs->converter->mode<8) {
_UTF16ToUnicodeWithOffsets(pArgs, pErrorCode);
@ -287,7 +287,7 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
sourceIndex=0;
c=0;
/* complete a partial UChar or pair from the last call */
/* complete a partial char16_t or pair from the last call */
if(cnv->toUnicodeStatus!=0) {
/*
* special case: single byte from a previous buffer,
@ -306,7 +306,7 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
++sourceIndex;
--length;
if(count==2) {
c=((UChar)p[0]<<8)|p[1];
c=((char16_t)p[0]<<8)|p[1];
if(U16_IS_SINGLE(c)) {
/* output the BMP code point */
*target++=c;
@ -325,8 +325,8 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
break;
}
} else if(count==4) {
c=((UChar)p[0]<<8)|p[1];
trail=((UChar)p[2]<<8)|p[3];
c=((char16_t)p[0]<<8)|p[1];
trail=((char16_t)p[2]<<8)|p[3];
if(U16_IS_TRAIL(trail)) {
/* output the surrogate pair */
*target++=c;
@ -386,12 +386,12 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
targetCapacity-=count;
if(offsets==nullptr) {
do {
c=((UChar)source[0]<<8)|source[1];
c=((char16_t)source[0]<<8)|source[1];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])
U16_IS_TRAIL(trail=((char16_t)source[0]<<8)|source[1])
) {
source+=2;
--count;
@ -403,14 +403,14 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
} while(--count>0);
} else {
do {
c=((UChar)source[0]<<8)|source[1];
c=((char16_t)source[0]<<8)|source[1];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
*offsets++=sourceIndex;
sourceIndex+=2;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])
U16_IS_TRAIL(trail=((char16_t)source[0]<<8)|source[1])
) {
source+=2;
--count;
@ -447,7 +447,7 @@ _UTF16BEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
if(U16_IS_SURROGATE_LEAD(c)) {
if(length>=2) {
if(U16_IS_TRAIL(trail=((UChar)source[0]<<8)|source[1])) {
if(U16_IS_TRAIL(trail=((char16_t)source[0]<<8)|source[1])) {
/* output the surrogate pair, will overflow (see conditions comment above) */
source+=2;
length-=2;
@ -509,7 +509,7 @@ _UTF16BEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
}
if(s+2>sourceLimit) {
/* only one byte: truncated UChar */
/* only one byte: truncated char16_t */
pArgs->converter->toUBytes[0]=*s++;
pArgs->converter->toULength=1;
pArgs->source=(const char *)s;
@ -517,7 +517,7 @@ _UTF16BEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
return 0xffff;
}
/* get one UChar */
/* get one char16_t */
c=((UChar32)*s<<8)|s[1];
s+=2;
@ -525,10 +525,10 @@ _UTF16BEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
if(U_IS_SURROGATE(c)) {
if(U16_IS_SURROGATE_LEAD(c)) {
if(s+2<=sourceLimit) {
UChar trail;
char16_t trail;
/* get a second UChar and see if it is a trail surrogate */
trail=((UChar)*s<<8)|s[1];
/* get a second char16_t and see if it is a trail surrogate */
trail=((char16_t)*s<<8)|s[1];
if(U16_IS_TRAIL(trail)) {
c=U16_GET_SUPPLEMENTARY(c, trail);
s+=2;
@ -653,12 +653,12 @@ static void U_CALLCONV
_UTF16LEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source;
const char16_t *source;
char *target;
int32_t *offsets;
uint32_t targetCapacity, length, sourceIndex;
UChar c, trail;
char16_t c, trail;
char overflow[4];
source=pArgs->source;
@ -693,7 +693,7 @@ _UTF16LEFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
/* c!=0 indicates in several places outside the main loops that a surrogate was found */
if((c=(UChar)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
if((c=(char16_t)cnv->fromUChar32)!=0 && U16_IS_TRAIL(trail=*source) && targetCapacity>=4) {
/* the last buffer ended with a lead surrogate, output the surrogate pair */
++source;
--length;
@ -858,11 +858,11 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source;
UChar *target;
char16_t *target;
int32_t *offsets;
uint32_t targetCapacity, length, count, sourceIndex;
UChar c, trail;
char16_t c, trail;
if(pArgs->converter->mode<8) {
_UTF16ToUnicodeWithOffsets(pArgs, pErrorCode);
@ -888,7 +888,7 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
sourceIndex=0;
c=0;
/* complete a partial UChar or pair from the last call */
/* complete a partial char16_t or pair from the last call */
if(cnv->toUnicodeStatus!=0) {
/*
* special case: single byte from a previous buffer,
@ -907,7 +907,7 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
++sourceIndex;
--length;
if(count==2) {
c=((UChar)p[1]<<8)|p[0];
c=((char16_t)p[1]<<8)|p[0];
if(U16_IS_SINGLE(c)) {
/* output the BMP code point */
*target++=c;
@ -926,8 +926,8 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
break;
}
} else if(count==4) {
c=((UChar)p[1]<<8)|p[0];
trail=((UChar)p[3]<<8)|p[2];
c=((char16_t)p[1]<<8)|p[0];
trail=((char16_t)p[3]<<8)|p[2];
if(U16_IS_TRAIL(trail)) {
/* output the surrogate pair */
*target++=c;
@ -987,12 +987,12 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
targetCapacity-=count;
if(offsets==nullptr) {
do {
c=((UChar)source[1]<<8)|source[0];
c=((char16_t)source[1]<<8)|source[0];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])
U16_IS_TRAIL(trail=((char16_t)source[1]<<8)|source[0])
) {
source+=2;
--count;
@ -1004,14 +1004,14 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
} while(--count>0);
} else {
do {
c=((UChar)source[1]<<8)|source[0];
c=((char16_t)source[1]<<8)|source[0];
source+=2;
if(U16_IS_SINGLE(c)) {
*target++=c;
*offsets++=sourceIndex;
sourceIndex+=2;
} else if(U16_IS_SURROGATE_LEAD(c) && count>=2 &&
U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])
U16_IS_TRAIL(trail=((char16_t)source[1]<<8)|source[0])
) {
source+=2;
--count;
@ -1048,7 +1048,7 @@ _UTF16LEToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
if(U16_IS_SURROGATE_LEAD(c)) {
if(length>=2) {
if(U16_IS_TRAIL(trail=((UChar)source[1]<<8)|source[0])) {
if(U16_IS_TRAIL(trail=((char16_t)source[1]<<8)|source[0])) {
/* output the surrogate pair, will overflow (see conditions comment above) */
source+=2;
length-=2;
@ -1110,7 +1110,7 @@ _UTF16LEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
}
if(s+2>sourceLimit) {
/* only one byte: truncated UChar */
/* only one byte: truncated char16_t */
pArgs->converter->toUBytes[0]=*s++;
pArgs->converter->toULength=1;
pArgs->source=(const char *)s;
@ -1118,7 +1118,7 @@ _UTF16LEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
return 0xffff;
}
/* get one UChar */
/* get one char16_t */
c=((UChar32)s[1]<<8)|*s;
s+=2;
@ -1126,10 +1126,10 @@ _UTF16LEGetNextUChar(UConverterToUnicodeArgs *pArgs, UErrorCode *err) {
if(U_IS_SURROGATE(c)) {
if(U16_IS_SURROGATE_LEAD(c)) {
if(s+2<=sourceLimit) {
UChar trail;
char16_t trail;
/* get a second UChar and see if it is a trail surrogate */
trail=((UChar)s[1]<<8)|*s;
/* get a second char16_t and see if it is a trail surrogate */
trail=((char16_t)s[1]<<8)|*s;
if(U16_IS_TRAIL(trail)) {
c=U16_GET_SUPPLEMENTARY(c, trail);
s+=2;

56
icu4c/source/common/ucnv_u32.cpp
View file

@ -48,9 +48,9 @@ T_UConverter_toUnicode_UTF32_BE(UConverterToUnicodeArgs * args,
UErrorCode * err)
{
const unsigned char *mySource = (unsigned char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit;
const UChar *targetLimit = args->targetLimit;
const char16_t *targetLimit = args->targetLimit;
unsigned char *toUBytes = args->converter->toUBytes;
uint32_t ch, i;
@ -87,18 +87,18 @@ morebytes:
if (ch <= MAXIMUM_UCS2)
{
/* fits in 16 bits */
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
}
else {
/* write out the surrogates */
*(myTarget++) = U16_LEAD(ch);
ch = U16_TRAIL(ch);
if (myTarget < targetLimit) {
*(myTarget++) = (UChar)ch;
*(myTarget++) = (char16_t)ch;
}
else {
/* Put in overflow buffer (not handled here) */
args->converter->UCharErrorBuffer[0] = (UChar) ch;
args->converter->UCharErrorBuffer[0] = (char16_t) ch;
args->converter->UCharErrorBufferLength = 1;
*err = U_BUFFER_OVERFLOW_ERROR;
break;
@ -127,10 +127,10 @@ T_UConverter_toUnicode_UTF32_BE_OFFSET_LOGIC(UConverterToUnicodeArgs * args,
UErrorCode * err)
{
const unsigned char *mySource = (unsigned char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
int32_t *myOffsets = args->offsets;
const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit;
const UChar *targetLimit = args->targetLimit;
const char16_t *targetLimit = args->targetLimit;
unsigned char *toUBytes = args->converter->toUBytes;
uint32_t ch, i;
int32_t offsetNum = 0;
@ -167,7 +167,7 @@ morebytes:
/* Normal valid byte when the loop has not prematurely terminated (i < inBytes) */
if (ch <= MAXIMUM_UCS2) {
/* fits in 16 bits */
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
*(myOffsets++) = offsetNum;
}
else {
@ -177,12 +177,12 @@ morebytes:
ch = U16_TRAIL(ch);
if (myTarget < targetLimit)
{
*(myTarget++) = (UChar)ch;
*(myTarget++) = (char16_t)ch;
*(myOffsets++) = offsetNum;
}
else {
/* Put in overflow buffer (not handled here) */
args->converter->UCharErrorBuffer[0] = (UChar) ch;
args->converter->UCharErrorBuffer[0] = (char16_t) ch;
args->converter->UCharErrorBufferLength = 1;
*err = U_BUFFER_OVERFLOW_ERROR;
break;
@ -213,9 +213,9 @@ static void U_CALLCONV
T_UConverter_fromUnicode_UTF32_BE(UConverterFromUnicodeArgs * args,
UErrorCode * err)
{
const UChar *mySource = args->source;
const char16_t *mySource = args->source;
unsigned char *myTarget;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *sourceLimit = args->sourceLimit;
const unsigned char *targetLimit = (unsigned char *) args->targetLimit;
UChar32 ch, ch2;
unsigned int indexToWrite;
@ -314,10 +314,10 @@ static void U_CALLCONV
T_UConverter_fromUnicode_UTF32_BE_OFFSET_LOGIC(UConverterFromUnicodeArgs * args,
UErrorCode * err)
{
const UChar *mySource = args->source;
const char16_t *mySource = args->source;
unsigned char *myTarget;
int32_t *myOffsets;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *sourceLimit = args->sourceLimit;
const unsigned char *targetLimit = (unsigned char *) args->targetLimit;
UChar32 ch, ch2;
int32_t offsetNum = 0;
@ -510,9 +510,9 @@ T_UConverter_toUnicode_UTF32_LE(UConverterToUnicodeArgs * args,
UErrorCode * err)
{
const unsigned char *mySource = (unsigned char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit;
const UChar *targetLimit = args->targetLimit;
const char16_t *targetLimit = args->targetLimit;
unsigned char *toUBytes = args->converter->toUBytes;
uint32_t ch, i;
@ -554,18 +554,18 @@ morebytes:
/* Normal valid byte when the loop has not prematurely terminated (i < inBytes) */
if (ch <= MAXIMUM_UCS2) {
/* fits in 16 bits */
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
}
else {
/* write out the surrogates */
*(myTarget++) = U16_LEAD(ch);
ch = U16_TRAIL(ch);
if (myTarget < targetLimit) {
*(myTarget++) = (UChar)ch;
*(myTarget++) = (char16_t)ch;
}
else {
/* Put in overflow buffer (not handled here) */
args->converter->UCharErrorBuffer[0] = (UChar) ch;
args->converter->UCharErrorBuffer[0] = (char16_t) ch;
args->converter->UCharErrorBufferLength = 1;
*err = U_BUFFER_OVERFLOW_ERROR;
break;
@ -595,10 +595,10 @@ T_UConverter_toUnicode_UTF32_LE_OFFSET_LOGIC(UConverterToUnicodeArgs * args,
UErrorCode * err)
{
const unsigned char *mySource = (unsigned char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
int32_t *myOffsets = args->offsets;
const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit;
const UChar *targetLimit = args->targetLimit;
const char16_t *targetLimit = args->targetLimit;
unsigned char *toUBytes = args->converter->toUBytes;
uint32_t ch, i;
int32_t offsetNum = 0;
@ -643,7 +643,7 @@ morebytes:
if (ch <= MAXIMUM_UCS2)
{
/* fits in 16 bits */
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
*(myOffsets++) = offsetNum;
}
else {
@ -653,13 +653,13 @@ morebytes:
ch = U16_TRAIL(ch);
if (myTarget < targetLimit)
{
*(myTarget++) = (UChar)ch;
*(myTarget++) = (char16_t)ch;
*(myOffsets++) = offsetNum;
}
else
{
/* Put in overflow buffer (not handled here) */
args->converter->UCharErrorBuffer[0] = (UChar) ch;
args->converter->UCharErrorBuffer[0] = (char16_t) ch;
args->converter->UCharErrorBufferLength = 1;
*err = U_BUFFER_OVERFLOW_ERROR;
break;
@ -691,9 +691,9 @@ static void U_CALLCONV
T_UConverter_fromUnicode_UTF32_LE(UConverterFromUnicodeArgs * args,
UErrorCode * err)
{
const UChar *mySource = args->source;
const char16_t *mySource = args->source;
unsigned char *myTarget;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *sourceLimit = args->sourceLimit;
const unsigned char *targetLimit = (unsigned char *) args->targetLimit;
UChar32 ch, ch2;
unsigned int indexToWrite;
@ -800,10 +800,10 @@ static void U_CALLCONV
T_UConverter_fromUnicode_UTF32_LE_OFFSET_LOGIC(UConverterFromUnicodeArgs * args,
UErrorCode * err)
{
const UChar *mySource = args->source;
const char16_t *mySource = args->source;
unsigned char *myTarget;
int32_t *myOffsets;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *sourceLimit = args->sourceLimit;
const unsigned char *targetLimit = (unsigned char *) args->targetLimit;
UChar32 ch, ch2;
unsigned int indexToWrite;

42
icu4c/source/common/ucnv_u7.cpp
View file

@ -212,8 +212,8 @@ _UTF7ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t *offsets;
uint8_t *bytes;
@ -320,10 +320,10 @@ unicodeMode:
* base64Value==-1 for any legal character except base64 and minus sign, or
* base64Value==-3 for illegal characters:
* 1. In either case, leave Unicode mode.
* 2.1. If we ended with an incomplete UChar or none after the +, then
* 2.1. If we ended with an incomplete char16_t or none after the +, then
* generate an error for the preceding erroneous sequence and deal with
* the current (possibly illegal) character next time through.
* 2.2. Else the current char comes after a complete UChar, which was already
* 2.2. Else the current char comes after a complete char16_t, which was already
* pushed to the output buf, so:
* 2.2.1. If the current char is legal, just save it for processing next time.
* It may be for example, a plus which we need to deal with in direct mode.
@ -339,14 +339,14 @@ unicodeMode:
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
break;
} else if(bits!=0) {
/* bits are illegally left over, a UChar is incomplete */
/* bits are illegally left over, a char16_t is incomplete */
/* don't include current char (legal or illegal) in error seq */
--source;
--byteIndex;
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
break;
} else {
/* previous UChar was complete */
/* previous char16_t was complete */
if(base64Value==-3) {
/* current character is illegal, deal with it here */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
@ -374,7 +374,7 @@ unicodeMode:
++base64Counter;
break;
case 2:
*target++=(UChar)((bits<<4)|(base64Value>>2));
*target++=(char16_t)((bits<<4)|(base64Value>>2));
if(offsets!=nullptr) {
*offsets++=sourceIndex;
sourceIndex=nextSourceIndex-1;
@ -385,7 +385,7 @@ unicodeMode:
base64Counter=3;
break;
case 5:
*target++=(UChar)((bits<<2)|(base64Value>>4));
*target++=(char16_t)((bits<<2)|(base64Value>>4));
if(offsets!=nullptr) {
*offsets++=sourceIndex;
sourceIndex=nextSourceIndex-1;
@ -396,7 +396,7 @@ unicodeMode:
base64Counter=6;
break;
case 7:
*target++=(UChar)((bits<<6)|base64Value);
*target++=(char16_t)((bits<<6)|base64Value);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
sourceIndex=nextSourceIndex;
@ -421,7 +421,7 @@ unicodeMode:
} else {
/* absorb the minus and leave the Unicode Mode */
if(bits!=0) {
/* bits are illegally left over, a UChar is incomplete */
/* bits are illegally left over, a char16_t is incomplete */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
break;
}
@ -462,12 +462,12 @@ static void U_CALLCONV
_UTF7FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target, *targetLimit;
int32_t *offsets;
int32_t length, targetCapacity, sourceIndex;
UChar c;
char16_t c;
/* UTF-7 state */
const UBool *encodeDirectly;
@ -896,8 +896,8 @@ _IMAPToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t *offsets;
uint8_t *bytes;
@ -914,7 +914,7 @@ _IMAPToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
int32_t sourceIndex, nextSourceIndex;
UChar c;
char16_t c;
uint8_t b;
/* set up the local pointers */
@ -1021,7 +1021,7 @@ unicodeMode:
++base64Counter;
break;
case 2:
c=(UChar)((bits<<4)|(base64Value>>2));
c=(char16_t)((bits<<4)|(base64Value>>2));
if(isLegalIMAP(c)) {
/* illegal */
inDirectMode=true;
@ -1039,7 +1039,7 @@ unicodeMode:
base64Counter=3;
break;
case 5:
c=(UChar)((bits<<2)|(base64Value>>4));
c=(char16_t)((bits<<2)|(base64Value>>4));
if(isLegalIMAP(c)) {
/* illegal */
inDirectMode=true;
@ -1057,7 +1057,7 @@ unicodeMode:
base64Counter=6;
break;
case 7:
c=(UChar)((bits<<6)|base64Value);
c=(char16_t)((bits<<6)|base64Value);
if(isLegalIMAP(c)) {
/* illegal */
inDirectMode=true;
@ -1089,7 +1089,7 @@ unicodeMode:
} else {
/* absorb the minus and leave the Unicode Mode */
if(bits!=0 || (base64Counter!=0 && base64Counter!=3 && base64Counter!=6)) {
/* bits are illegally left over, a UChar is incomplete */
/* bits are illegally left over, a char16_t is incomplete */
/* base64Counter other than 0, 3, 6 means non-minimal zero-padding, also illegal */
*pErrorCode=U_ILLEGAL_CHAR_FOUND;
break;
@ -1163,12 +1163,12 @@ static void U_CALLCONV
_IMAPFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target, *targetLimit;
int32_t *offsets;
int32_t length, targetCapacity, sourceIndex;
UChar c;
char16_t c;
uint8_t b;
/* UTF-7 state */

34
icu4c/source/common/ucnv_u8.cpp
View file

@ -67,9 +67,9 @@ static void U_CALLCONV ucnv_toUnicode_UTF8 (UConverterToUnicodeArgs * args,
{
UConverter *cnv = args->converter;
const unsigned char *mySource = (unsigned char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit;
const UChar *targetLimit = args->targetLimit;
const char16_t *targetLimit = args->targetLimit;
unsigned char *toUBytes = cnv->toUBytes;
UBool isCESU8 = hasCESU8Data(cnv);
uint32_t ch, ch2 = 0;
@ -93,7 +93,7 @@ static void U_CALLCONV ucnv_toUnicode_UTF8 (UConverterToUnicodeArgs * args,
ch = *(mySource++);
if (U8_IS_SINGLE(ch)) /* Simple case */
{
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
}
else
{
@ -137,7 +137,7 @@ morebytes:
if (ch <= MAXIMUM_UCS2)
{
/* fits in 16 bits */
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
}
else
{
@ -146,12 +146,12 @@ morebytes:
ch = U16_TRAIL(ch);
if (myTarget < targetLimit)
{
*(myTarget++) = (UChar)ch;
*(myTarget++) = (char16_t)ch;
}
else
{
/* Put in overflow buffer (not handled here) */
cnv->UCharErrorBuffer[0] = (UChar) ch;
cnv->UCharErrorBuffer[0] = (char16_t) ch;
cnv->UCharErrorBufferLength = 1;
*err = U_BUFFER_OVERFLOW_ERROR;
break;
@ -183,11 +183,11 @@ static void U_CALLCONV ucnv_toUnicode_UTF8_OFFSETS_LOGIC (UConverterToUnicodeAr
{
UConverter *cnv = args->converter;
const unsigned char *mySource = (unsigned char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
int32_t *myOffsets = args->offsets;
int32_t offsetNum = 0;
const unsigned char *sourceLimit = (unsigned char *) args->sourceLimit;
const UChar *targetLimit = args->targetLimit;
const char16_t *targetLimit = args->targetLimit;
unsigned char *toUBytes = cnv->toUBytes;
UBool isCESU8 = hasCESU8Data(cnv);
uint32_t ch, ch2 = 0;
@ -210,7 +210,7 @@ static void U_CALLCONV ucnv_toUnicode_UTF8_OFFSETS_LOGIC (UConverterToUnicodeAr
ch = *(mySource++);
if (U8_IS_SINGLE(ch)) /* Simple case */
{
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
*(myOffsets++) = offsetNum++;
}
else
@ -253,7 +253,7 @@ morebytes:
if (ch <= MAXIMUM_UCS2)
{
/* fits in 16 bits */
*(myTarget++) = (UChar) ch;
*(myTarget++) = (char16_t) ch;
*(myOffsets++) = offsetNum;
}
else
@ -264,12 +264,12 @@ morebytes:
ch = U16_TRAIL(ch);
if (myTarget < targetLimit)
{
*(myTarget++) = (UChar)ch;
*(myTarget++) = (char16_t)ch;
*(myOffsets++) = offsetNum;
}
else
{
cnv->UCharErrorBuffer[0] = (UChar) ch;
cnv->UCharErrorBuffer[0] = (char16_t) ch;
cnv->UCharErrorBufferLength = 1;
*err = U_BUFFER_OVERFLOW_ERROR;
}
@ -301,8 +301,8 @@ U_CFUNC void U_CALLCONV ucnv_fromUnicode_UTF8 (UConverterFromUnicodeArgs * args
UErrorCode * err)
{
UConverter *cnv = args->converter;
const UChar *mySource = args->source;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *mySource = args->source;
const char16_t *sourceLimit = args->sourceLimit;
uint8_t *myTarget = (uint8_t *) args->target;
const uint8_t *targetLimit = (uint8_t *) args->targetLimit;
uint8_t *tempPtr;
@ -415,9 +415,9 @@ U_CFUNC void U_CALLCONV ucnv_fromUnicode_UTF8_OFFSETS_LOGIC (UConverterFromUnic
UErrorCode * err)
{
UConverter *cnv = args->converter;
const UChar *mySource = args->source;
const char16_t *mySource = args->source;
int32_t *myOffsets = args->offsets;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *sourceLimit = args->sourceLimit;
uint8_t *myTarget = (uint8_t *) args->target;
const uint8_t *targetLimit = (uint8_t *) args->targetLimit;
uint8_t *tempPtr;
@ -887,7 +887,7 @@ static const UConverterStaticData _UTF8StaticData={
sizeof(UConverterStaticData),
"UTF-8",
1208, UCNV_IBM, UCNV_UTF8,
1, 3, /* max 3 bytes per UChar from UTF-8 (4 bytes from surrogate _pair_) */
1, 3, /* max 3 bytes per char16_t from UTF-8 (4 bytes from surrogate _pair_) */
{ 0xef, 0xbf, 0xbd, 0 },3,false,false,
0,
0,

38
icu4c/source/common/ucnvbocu.cpp
View file

@ -392,7 +392,7 @@ static void U_CALLCONV
_Bocu1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
int32_t *offsets;
@ -485,7 +485,7 @@ fastSingle:
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
++nextSourceIndex;
@ -653,7 +653,7 @@ static void U_CALLCONV
_Bocu1FromUnicode(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
@ -729,7 +729,7 @@ fastSingle:
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
c=U16_GET_SUPPLEMENTARY(c, trail);
@ -957,8 +957,8 @@ _Bocu1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t *offsets;
int32_t prev, count, diff, c;
@ -1009,7 +1009,7 @@ fastSingle:
if(BOCU1_START_NEG_2<=(c=*source) && c<BOCU1_START_POS_2) {
c=prev+(c-BOCU1_MIDDLE);
if(c<0x3000) {
*target++=(UChar)c;
*target++=(char16_t)c;
*offsets++=nextSourceIndex++;
prev=BOCU1_SIMPLE_PREV(c);
} else {
@ -1019,7 +1019,7 @@ fastSingle:
if(c!=0x20) {
prev=BOCU1_ASCII_PREV;
}
*target++=(UChar)c;
*target++=(char16_t)c;
*offsets++=nextSourceIndex++;
} else {
break;
@ -1043,7 +1043,7 @@ fastSingle:
/* Write a code point directly from a single-byte difference. */
c=prev+(c-BOCU1_MIDDLE);
if(c<0x3000) {
*target++=(UChar)c;
*target++=(char16_t)c;
*offsets++=sourceIndex;
prev=BOCU1_SIMPLE_PREV(c);
sourceIndex=nextSourceIndex;
@ -1057,7 +1057,7 @@ fastSingle:
if(c!=0x20) {
prev=BOCU1_ASCII_PREV;
}
*target++=(UChar)c;
*target++=(char16_t)c;
*offsets++=sourceIndex;
sourceIndex=nextSourceIndex;
continue;
@ -1128,7 +1128,7 @@ getTrail:
/* calculate the next prev and output c */
prev=BOCU1_PREV(c);
if(c<=0xffff) {
*target++=(UChar)c;
*target++=(char16_t)c;
*offsets++=sourceIndex;
} else {
/* output surrogate pair */
@ -1180,8 +1180,8 @@ _Bocu1ToUnicode(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t prev, count, diff, c;
@ -1224,7 +1224,7 @@ fastSingle:
if(BOCU1_START_NEG_2<=(c=*source) && c<BOCU1_START_POS_2) {
c=prev+(c-BOCU1_MIDDLE);
if(c<0x3000) {
*target++=(UChar)c;
*target++=(char16_t)c;
prev=BOCU1_SIMPLE_PREV(c);
} else {
break;
@ -1233,7 +1233,7 @@ fastSingle:
if(c!=0x20) {
prev=BOCU1_ASCII_PREV;
}
*target++=(UChar)c;
*target++=(char16_t)c;
} else {
break;
}
@ -1254,7 +1254,7 @@ fastSingle:
/* Write a code point directly from a single-byte difference. */
c=prev+(c-BOCU1_MIDDLE);
if(c<0x3000) {
*target++=(UChar)c;
*target++=(char16_t)c;
prev=BOCU1_SIMPLE_PREV(c);
goto fastSingle;
}
@ -1266,7 +1266,7 @@ fastSingle:
if(c!=0x20) {
prev=BOCU1_ASCII_PREV;
}
*target++=(UChar)c;
*target++=(char16_t)c;
continue;
} else if(BOCU1_START_NEG_3<=c && c<BOCU1_START_POS_3 && source<sourceLimit) {
/* Optimize two-byte case. */
@ -1332,7 +1332,7 @@ getTrail:
/* calculate the next prev and output c */
prev=BOCU1_PREV(c);
if(c<=0xffff) {
*target++=(UChar)c;
*target++=(char16_t)c;
} else {
/* output surrogate pair */
*target++=U16_LEAD(c);
@ -1399,7 +1399,7 @@ static const UConverterStaticData _Bocu1StaticData={
"BOCU-1",
1214, /* CCSID for BOCU-1 */
UCNV_IBM, UCNV_BOCU1,
1, 4, /* one UChar generates at least 1 byte and at most 4 bytes */
1, 4, /* one char16_t generates at least 1 byte and at most 4 bytes */
{ 0x1a, 0, 0, 0 }, 1, /* BOCU-1 never needs to write a subchar */
false, false,
0,

4
icu4c/source/common/ucnvdisp.cpp
View file

@ -35,10 +35,10 @@
U_CAPI int32_t U_EXPORT2
ucnv_getDisplayName(const UConverter *cnv,
const char *displayLocale,
UChar *displayName, int32_t displayNameCapacity,
char16_t *displayName, int32_t displayNameCapacity,
UErrorCode *pErrorCode) {
UResourceBundle *rb;
const UChar *name;
const char16_t *name;
int32_t length;
UErrorCode localStatus = U_ZERO_ERROR;

14
icu4c/source/common/ucnvhz.cpp
View file

@ -157,7 +157,7 @@ UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
UErrorCode* err){
char tempBuf[2];
const char *mySource = ( char *) args->source;
UChar *myTarget = args->target;
char16_t *myTarget = args->target;
const char *mySourceLimit = args->sourceLimit;
UChar32 targetUniChar = 0x0000;
int32_t mySourceChar = 0x0000;
@ -188,7 +188,7 @@ UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
if(args->offsets) {
args->offsets[myTarget - args->target]=(int32_t)(mySource - args->source - 2);
}
*(myTarget++)=(UChar)mySourceChar;
*(myTarget++)=(char16_t)mySourceChar;
myData->isEmptySegment = false;
continue;
case UCNV_OPEN_BRACE:
@ -288,7 +288,7 @@ UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
args->converter->mode = UCNV_TILDE;
continue;
} else if(mySourceChar <= 0x7f) {
targetUniChar = (UChar)mySourceChar; /* ASCII */
targetUniChar = (char16_t)mySourceChar; /* ASCII */
myData->isEmptySegment = false; /* the segment has something valid */
} else {
targetUniChar = 0xffff;
@ -300,7 +300,7 @@ UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
args->offsets[myTarget - args->target]=(int32_t)(mySource - args->source - 1-(myData->isStateDBCS));
}
*(myTarget++)=(UChar)targetUniChar;
*(myTarget++)=(char16_t)targetUniChar;
}
else /* targetUniChar>=0xfffe */ {
if(targetUniChar == 0xfffe){
@ -335,7 +335,7 @@ UConverter_toUnicode_HZ_OFFSETS_LOGIC(UConverterToUnicodeArgs *args,
static void U_CALLCONV
UConverter_fromUnicode_HZ_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args,
UErrorCode * err){
const UChar *mySource = args->source;
const char16_t *mySource = args->source;
char *myTarget = args->target;
int32_t* offsets = args->offsets;
int32_t mySourceIndex = 0;
@ -363,7 +363,7 @@ UConverter_fromUnicode_HZ_OFFSETS_LOGIC (UConverterFromUnicodeArgs * args,
targetUniChar = missingCharMarker;
if (myTargetIndex < targetLength){
mySourceChar = (UChar) mySource[mySourceIndex++];
mySourceChar = (char16_t) mySource[mySourceIndex++];
oldIsTargetUCharDBCS = isTargetUCharDBCS;
@ -453,7 +453,7 @@ getTrail:
/*look ahead to find the trail surrogate*/
if(mySourceIndex < mySourceLength) {
/* test the following code unit */
UChar trail=(UChar) args->source[mySourceIndex];
char16_t trail=(char16_t) args->source[mySourceIndex];
if(U16_IS_TRAIL(trail)) {
++mySourceIndex;
mySourceChar=U16_GET_SUPPLEMENTARY(args->converter->fromUChar32, trail);

26
icu4c/source/common/ucnvisci.cpp
View file

@ -119,8 +119,8 @@ typedef enum {
#define ISCII_CNV_PREFIX "ISCII,version="
typedef struct {
UChar contextCharToUnicode; /* previous Unicode codepoint for contextual analysis */
UChar contextCharFromUnicode; /* previous Unicode codepoint for contextual analysis */
char16_t contextCharToUnicode; /* previous Unicode codepoint for contextual analysis */
char16_t contextCharFromUnicode; /* previous Unicode codepoint for contextual analysis */
uint16_t defDeltaToUnicode; /* delta for switching to default state when DEF is encountered */
uint16_t currentDeltaFromUnicode; /* current delta in Indic block */
uint16_t currentDeltaToUnicode; /* current delta in Indic block */
@ -895,8 +895,8 @@ static const uint16_t nuktaSpecialCases[][2]={
static void U_CALLCONV
UConverter_fromUnicode_ISCII_OFFSETS_LOGIC(
UConverterFromUnicodeArgs * args, UErrorCode * err) {
const UChar *source = args->source;
const UChar *sourceLimit = args->sourceLimit;
const char16_t *source = args->source;
const char16_t *sourceLimit = args->sourceLimit;
unsigned char *target = (unsigned char *) args->target;
unsigned char *targetLimit = (unsigned char *) args->targetLimit;
int32_t* offsets = args->offsets;
@ -1052,7 +1052,7 @@ UConverter_fromUnicode_ISCII_OFFSETS_LOGIC(
}
} else if (targetByteUnit != missingCharMarker) {
if (targetByteUnit==ISCII_HALANT) {
converterData->contextCharFromUnicode = (UChar)targetByteUnit;
converterData->contextCharFromUnicode = (char16_t)targetByteUnit;
}
/* write targetByteUnit to target*/
WRITE_TO_TARGET_FROM_U(args,offsets,source,target,targetLimit,targetByteUnit,err);
@ -1068,7 +1068,7 @@ getTrail:
/*look ahead to find the trail surrogate*/
if (source < sourceLimit) {
/* test the following code unit */
UChar trail= (*source);
char16_t trail= (*source);
if (U16_IS_TRAIL(trail)) {
source++;
sourceChar=U16_GET_SUPPLEMENTARY(sourceChar, trail);
@ -1131,13 +1131,13 @@ static const uint16_t lookupTable[][2]={
} \
/* now write the targetUniChar */ \
if(target<args->targetLimit){ \
*(target)++ = (UChar)targetUniChar; \
*(target)++ = (char16_t)targetUniChar; \
if(offsets){ \
*(offsets)++ = (int32_t)(offset); \
} \
}else{ \
args->converter->UCharErrorBuffer[args->converter->UCharErrorBufferLength++] = \
(UChar)targetUniChar; \
(char16_t)targetUniChar; \
*err = U_BUFFER_OVERFLOW_ERROR; \
} \
} UPRV_BLOCK_MACRO_END
@ -1179,15 +1179,15 @@ static const uint16_t lookupTable[][2]={
static void U_CALLCONV
UConverter_toUnicode_ISCII_OFFSETS_LOGIC(UConverterToUnicodeArgs *args, UErrorCode* err) {
const char *source = ( char *) args->source;
UChar *target = args->target;
char16_t *target = args->target;
const char *sourceLimit = args->sourceLimit;
const UChar* targetLimit = args->targetLimit;
const char16_t* targetLimit = args->targetLimit;
uint32_t targetUniChar = 0x0000;
uint8_t sourceChar = 0x0000;
UConverterDataISCII* data;
UChar32* toUnicodeStatus=nullptr;
UChar32 tempTargetUniChar = 0x0000;
UChar* contextCharToUnicode= nullptr;
char16_t* contextCharToUnicode= nullptr;
UBool found;
int i;
int offset = 0;
@ -1293,7 +1293,7 @@ UConverter_toUnicode_ISCII_OFFSETS_LOGIC(UConverterToUnicodeArgs *args, UErrorCo
case ISCII_INV:
case EXT:
case ATR:
*contextCharToUnicode = (UChar)sourceChar;
*contextCharToUnicode = (char16_t)sourceChar;
if (*toUnicodeStatus != missingCharMarker) {
/* Write the previous toUnicodeStatus, this was delayed to handle consonant clustering for Gurmukhi script. */
@ -1471,7 +1471,7 @@ UConverter_toUnicode_ISCII_OFFSETS_LOGIC(UConverterToUnicodeArgs *args, UErrorCo
if (targetUniChar != missingCharMarker) {
/* now save the targetUniChar for delayed write */
*toUnicodeStatus = (UChar) targetUniChar;
*toUnicodeStatus = (char16_t) targetUniChar;
if (data->resetToDefaultToUnicode) {
data->currentDeltaToUnicode = data->defDeltaToUnicode;
data->currentMaskToUnicode = data->defMaskToUnicode;

20
icu4c/source/common/ucnvlat1.cpp
View file

@ -36,7 +36,7 @@ static void U_CALLCONV
_Latin1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
const uint8_t *source;
UChar *target;
char16_t *target;
int32_t targetCapacity, length;
int32_t *offsets;
@ -51,7 +51,7 @@ _Latin1ToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
sourceIndex=0;
/*
* since the conversion here is 1:1 UChar:uint8_t, we need only one counter
* since the conversion here is 1:1 char16_t:uint8_t, we need only one counter
* for the minimum of the sourceLength and targetCapacity
*/
length=(int32_t)((const uint8_t *)pArgs->sourceLimit-source);
@ -137,13 +137,13 @@ static void U_CALLCONV
_Latin1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target, *oldTarget;
int32_t targetCapacity, length;
int32_t *offsets;
UChar32 cp;
UChar c, max;
char16_t c, max;
int32_t sourceIndex;
@ -168,7 +168,7 @@ _Latin1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
sourceIndex= cp==0 ? 0 : -1;
/*
* since the conversion here is 1:1 UChar:uint8_t, we need only one counter
* since the conversion here is 1:1 char16_t:uint8_t, we need only one counter
* for the minimum of the sourceLength and targetCapacity
*/
length=(int32_t)(sourceLimit-source);
@ -185,7 +185,7 @@ _Latin1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
/* unroll the loop with the most common case */
if(targetCapacity>=16) {
int32_t count, loops;
UChar u, oredChars;
char16_t u, oredChars;
loops=count=targetCapacity>>4;
do {
@ -274,7 +274,7 @@ _Latin1FromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
cp=U16_GET_SUPPLEMENTARY(cp, trail);
@ -482,7 +482,7 @@ static void U_CALLCONV
_ASCIIToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
const uint8_t *source, *sourceLimit;
UChar *target, *oldTarget;
char16_t *target, *oldTarget;
int32_t targetCapacity, length;
int32_t *offsets;
@ -501,7 +501,7 @@ _ASCIIToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
sourceIndex=0;
/*
* since the conversion here is 1:1 UChar:uint8_t, we need only one counter
* since the conversion here is 1:1 char16_t:uint8_t, we need only one counter
* for the minimum of the sourceLength and targetCapacity
*/
length=(int32_t)(sourceLimit-source);
@ -512,7 +512,7 @@ _ASCIIToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
if(targetCapacity>=8) {
/* This loop is unrolled for speed and improved pipelining. */
int32_t count, loops;
UChar oredChars;
char16_t oredChars;
loops=count=targetCapacity>>3;
do {

134
icu4c/source/common/ucnvmbcs.cpp
View file

@ -683,7 +683,7 @@ enumToU(UConverterMBCSTable *mbcsTable, int8_t stateProps[],
action=MBCS_ENTRY_FINAL_ACTION(entry);
if(action==MBCS_STATE_VALID_DIRECT_16) {
/* output BMP code point */
c=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
c=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
} else if(action==MBCS_STATE_VALID_16) {
int32_t finalOffset=offset+MBCS_ENTRY_FINAL_VALUE_16(entry);
c=unicodeCodeUnits[finalOffset];
@ -1104,7 +1104,7 @@ ucnv_MBCSGetUnicodeSet(const UConverter *cnv,
static UChar32
_extFromU(UConverter *cnv, const UConverterSharedData *sharedData,
UChar32 cp,
const UChar **source, const UChar *sourceLimit,
const char16_t **source, const char16_t *sourceLimit,
uint8_t **target, const uint8_t *targetLimit,
int32_t **offsets, int32_t sourceIndex,
UBool flush,
@ -1172,7 +1172,7 @@ static int8_t
_extToU(UConverter *cnv, const UConverterSharedData *sharedData,
int8_t length,
const uint8_t **source, const uint8_t *sourceLimit,
UChar **target, const UChar *targetLimit,
char16_t **target, const char16_t *targetLimit,
int32_t **offsets, int32_t sourceIndex,
UBool flush,
UErrorCode *pErrorCode) {
@ -1828,7 +1828,7 @@ ucnv_MBCSLoad(UConverterSharedData *sharedData,
mbcsTable->mbcsIndex=(const uint16_t *)
(mbcsTable->fromUnicodeBytes+
(noFromU ? 0 : mbcsTable->fromUBytesLength));
mbcsTable->maxFastUChar=(((UChar)header->version[2])<<8)|0xff;
mbcsTable->maxFastUChar=(((char16_t)header->version[2])<<8)|0xff;
}
}
@ -2034,8 +2034,8 @@ ucnv_MBCSSingleToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t *offsets;
const int32_t (*stateTable)[256];
@ -2043,7 +2043,7 @@ ucnv_MBCSSingleToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
int32_t sourceIndex;
int32_t entry;
UChar c;
char16_t c;
uint8_t action;
/* set up the local pointers */
@ -2085,7 +2085,7 @@ ucnv_MBCSSingleToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
/* test the most common case first */
if(MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(entry)) {
/* output BMP code point */
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -2105,11 +2105,11 @@ ucnv_MBCSSingleToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
) {
entry=MBCS_ENTRY_FINAL_VALUE(entry);
/* output surrogate pair */
*target++=(UChar)(0xd800|(UChar)(entry>>10));
*target++=(char16_t)(0xd800|(char16_t)(entry>>10));
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
c=(UChar)(0xdc00|(UChar)(entry&0x3ff));
c=(char16_t)(0xdc00|(char16_t)(entry&0x3ff));
if(target<targetLimit) {
*target++=c;
if(offsets!=nullptr) {
@ -2128,7 +2128,7 @@ ucnv_MBCSSingleToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
} else if(action==MBCS_STATE_FALLBACK_DIRECT_16) {
if(UCNV_TO_U_USE_FALLBACK(cnv)) {
/* output BMP code point */
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -2186,7 +2186,7 @@ ucnv_MBCSSingleToBMPWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit, *lastSource;
UChar *target;
char16_t *target;
int32_t targetCapacity, length;
int32_t *offsets;
@ -2216,7 +2216,7 @@ ucnv_MBCSSingleToBMPWithOffsets(UConverterToUnicodeArgs *pArgs,
lastSource=source;
/*
* since the conversion here is 1:1 UChar:uint8_t, we need only one counter
* since the conversion here is 1:1 char16_t:uint8_t, we need only one counter
* for the minimum of the sourceLength and targetCapacity
*/
length=(int32_t)(sourceLimit-source);
@ -2234,37 +2234,37 @@ unrolled:
loops=count=targetCapacity>>4;
do {
oredEntries=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
oredEntries|=entry=stateTable[0][*source++];
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
/* were all 16 entries really valid? */
if(!MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(oredEntries)) {
@ -2310,7 +2310,7 @@ unrolled:
/* test the most common case first */
if(MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(entry)) {
/* output BMP code point */
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
--targetCapacity;
continue;
}
@ -2323,7 +2323,7 @@ unrolled:
if(action==MBCS_STATE_FALLBACK_DIRECT_16) {
if(UCNV_TO_U_USE_FALLBACK(cnv)) {
/* output BMP code point */
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
--targetCapacity;
continue;
}
@ -2466,8 +2466,8 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t *offsets;
const int32_t (*stateTable)[256];
@ -2481,7 +2481,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
int32_t sourceIndex, nextSourceIndex;
int32_t entry;
UChar c;
char16_t c;
uint8_t action;
/* use optimized function if possible */
@ -2585,7 +2585,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
if(MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(entry)) {
/* output BMP code point */
++source;
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
state=(uint8_t)MBCS_ENTRY_FINAL_STATE(entry); /* typically 0 */
} else {
/* leave the optimized loop */
@ -2625,7 +2625,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
if(MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(entry)) {
/* output BMP code point */
++source;
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
sourceIndex=++nextSourceIndex;
@ -2689,7 +2689,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
} else if(c==0xfffe) {
if(UCNV_TO_U_USE_FALLBACK(cnv) && (entry=(int32_t)ucnv_MBCSGetFallback(&cnv->sharedData->mbcs, offset))!=0xfffe) {
/* output fallback BMP code point */
*target++=(UChar)entry;
*target++=(char16_t)entry;
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -2701,7 +2701,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
}
} else if(action==MBCS_STATE_VALID_DIRECT_16) {
/* output BMP code point */
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -2718,7 +2718,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
byteIndex=0;
} else if(UCNV_TO_U_USE_FALLBACK(cnv) ? c<=0xdfff : c<=0xdbff) {
/* output roundtrip or fallback surrogate pair */
*target++=(UChar)(c&0xdbff);
*target++=(char16_t)(c&0xdbff);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -2753,12 +2753,12 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
) {
entry=MBCS_ENTRY_FINAL_VALUE(entry);
/* output surrogate pair */
*target++=(UChar)(0xd800|(UChar)(entry>>10));
*target++=(char16_t)(0xd800|(char16_t)(entry>>10));
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
byteIndex=0;
c=(UChar)(0xdc00|(UChar)(entry&0x3ff));
c=(char16_t)(0xdc00|(char16_t)(entry&0x3ff));
if(target<targetLimit) {
*target++=c;
if(offsets!=nullptr) {
@ -2793,7 +2793,7 @@ ucnv_MBCSToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
} else if(action==MBCS_STATE_FALLBACK_DIRECT_16) {
if(UCNV_TO_U_USE_FALLBACK(cnv)) {
/* output BMP code point */
*target++=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
*target++=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -2908,7 +2908,7 @@ ucnv_MBCSSingleGetNextUChar(UConverterToUnicodeArgs *pArgs,
if(MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(entry)) {
/* output BMP code point */
return (UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
return (char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
}
/*
@ -2924,7 +2924,7 @@ ucnv_MBCSSingleGetNextUChar(UConverterToUnicodeArgs *pArgs,
} else if(action==MBCS_STATE_FALLBACK_DIRECT_16) {
if(UCNV_TO_U_USE_FALLBACK(cnv)) {
/* output BMP code point */
return (UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
return (char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
}
} else if(action==MBCS_STATE_UNASSIGNED) {
/* just fall through */
@ -3054,7 +3054,7 @@ ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
action=(uint8_t)(MBCS_ENTRY_FINAL_ACTION(entry));
if(action==MBCS_STATE_VALID_DIRECT_16) {
/* output BMP code point */
c=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
c=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
break;
} else if(action==MBCS_STATE_VALID_16) {
offset+=MBCS_ENTRY_FINAL_VALUE_16(entry);
@ -3112,7 +3112,7 @@ ucnv_MBCSGetNextUChar(UConverterToUnicodeArgs *pArgs,
} else if(action==MBCS_STATE_FALLBACK_DIRECT_16) {
if(UCNV_TO_U_USE_FALLBACK(cnv)) {
/* output BMP code point */
c=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
c=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
break;
}
} else if(action==MBCS_STATE_UNASSIGNED) {
@ -3213,7 +3213,7 @@ ucnv_MBCSSingleSimpleGetNextUChar(UConverterSharedData *sharedData,
if(MBCS_ENTRY_FINAL_IS_VALID_DIRECT_16(entry)) {
/* output BMP code point */
return (UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
return (char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
}
/*
@ -3229,7 +3229,7 @@ ucnv_MBCSSingleSimpleGetNextUChar(UConverterSharedData *sharedData,
return 0xfffe;
}
/* output BMP code point */
return (UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
return (char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
} else if(action==MBCS_STATE_FALLBACK_DIRECT_20) {
if(!TO_U_USE_FALLBACK(useFallback)) {
return 0xfffe;
@ -3331,7 +3331,7 @@ ucnv_MBCSSimpleGetNextUChar(UConverterSharedData *sharedData,
break;
} else if(action==MBCS_STATE_VALID_DIRECT_16) {
/* output BMP code point */
c=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
c=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
break;
} else if(action==MBCS_STATE_VALID_16_PAIR) {
offset+=MBCS_ENTRY_FINAL_VALUE_16(entry);
@ -3360,7 +3360,7 @@ ucnv_MBCSSimpleGetNextUChar(UConverterSharedData *sharedData,
break;
}
/* output BMP code point */
c=(UChar)MBCS_ENTRY_FINAL_VALUE_16(entry);
c=(char16_t)MBCS_ENTRY_FINAL_VALUE_16(entry);
break;
} else if(action==MBCS_STATE_FALLBACK_DIRECT_20) {
if(!TO_U_USE_FALLBACK(useFallback)) {
@ -3406,7 +3406,7 @@ static void
ucnv_MBCSDoubleFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
int32_t *offsets;
@ -3468,7 +3468,7 @@ ucnv_MBCSDoubleFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
if(targetCapacity>0) {
/*
* Get a correct Unicode code point:
* a single UChar for a BMP code point or
* a single char16_t for a BMP code point or
* a matched surrogate pair for a "supplementary code point".
*/
c=*source++;
@ -3506,7 +3506,7 @@ ucnv_MBCSDoubleFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
++nextSourceIndex;
@ -3638,7 +3638,7 @@ static void
ucnv_MBCSSingleFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
int32_t *offsets;
@ -3701,7 +3701,7 @@ ucnv_MBCSSingleFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
if(targetCapacity>0) {
/*
* Get a correct Unicode code point:
* a single UChar for a BMP code point or
* a single char16_t for a BMP code point or
* a matched surrogate pair for a "supplementary code point".
*/
c=*source++;
@ -3711,7 +3711,7 @@ ucnv_MBCSSingleFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
++nextSourceIndex;
@ -3814,7 +3814,7 @@ static void
ucnv_MBCSSingleFromBMPWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit, *lastSource;
const char16_t *source, *sourceLimit, *lastSource;
uint8_t *target;
int32_t targetCapacity, length;
int32_t *offsets;
@ -3861,7 +3861,7 @@ ucnv_MBCSSingleFromBMPWithOffsets(UConverterFromUnicodeArgs *pArgs,
lastSource=source;
/*
* since the conversion here is 1:1 UChar:uint8_t, we need only one counter
* since the conversion here is 1:1 char16_t:uint8_t, we need only one counter
* for the minimum of the sourceLength and targetCapacity
*/
length=(int32_t)(sourceLimit-source);
@ -3926,7 +3926,7 @@ unrolled:
while(targetCapacity>0) {
/*
* Get a correct Unicode code point:
* a single UChar for a BMP code point or
* a single char16_t for a BMP code point or
* a matched surrogate pair for a "supplementary code point".
*/
c=*source++;
@ -3960,7 +3960,7 @@ unrolled:
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
c=U16_GET_SUPPLEMENTARY(c, trail);
@ -4071,7 +4071,7 @@ U_CFUNC void
ucnv_MBCSFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
int32_t *offsets;
@ -4197,7 +4197,7 @@ ucnv_MBCSFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
if(targetCapacity>0) {
/*
* Get a correct Unicode code point:
* a single UChar for a BMP code point or
* a single char16_t for a BMP code point or
* a matched surrogate pair for a "supplementary code point".
*/
c=*source++;
@ -4390,7 +4390,7 @@ ucnv_MBCSFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
getTrail:
if(source<sourceLimit) {
/* test the following code unit */
UChar trail=*source;
char16_t trail=*source;
if(U16_IS_TRAIL(trail)) {
++source;
++nextSourceIndex;
@ -5257,8 +5257,8 @@ moreBytes:
* If we have a partial match on c, we will return and revert
* to UTF-8->UTF-16->charset conversion.
*/
static const UChar nul=0;
const UChar *noSource=&nul;
static const char16_t nul=0;
const char16_t *noSource=&nul;
c=_extFromU(cnv, cnv->sharedData,
c, &noSource, noSource,
&target, target+targetCapacity,
@ -5560,8 +5560,8 @@ unassigned:
* If we have a partial match on c, we will return and revert
* to UTF-8->UTF-16->charset conversion.
*/
static const UChar nul=0;
const UChar *noSource=&nul;
static const char16_t nul=0;
const char16_t *noSource=&nul;
c=_extFromU(cnv, cnv->sharedData,
c, &noSource, noSource,
&target, target+targetCapacity,

82
icu4c/source/common/ucnvscsu.cpp
View file

@ -234,8 +234,8 @@ _SCSUToUnicodeWithOffsets(UConverterToUnicodeArgs *pArgs,
UConverter *cnv;
SCSUData *scsu;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
int32_t *offsets;
UBool isSingleByteMode;
uint8_t state, byteOne;
@ -294,7 +294,7 @@ fastSingle:
++nextSourceIndex;
if(b<=0x7f) {
/* write US-ASCII graphic character or DEL */
*target++=(UChar)b;
*target++=(char16_t)b;
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -302,15 +302,15 @@ fastSingle:
/* write from dynamic window */
uint32_t c=scsu->toUDynamicOffsets[dynamicWindow]+(b&0x7f);
if(c<=0xffff) {
*target++=(UChar)c;
*target++=(char16_t)c;
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
} else {
/* output surrogate pair */
*target++=(UChar)(0xd7c0+(c>>10));
*target++=(char16_t)(0xd7c0+(c>>10));
if(target<targetLimit) {
*target++=(UChar)(0xdc00|(c&0x3ff));
*target++=(char16_t)(0xdc00|(c&0x3ff));
if(offsets!=nullptr) {
*offsets++=sourceIndex;
*offsets++=sourceIndex;
@ -320,7 +320,7 @@ fastSingle:
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
cnv->UCharErrorBuffer[0]=(char16_t)(0xdc00|(c&0x3ff));
cnv->UCharErrorBufferLength=1;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
goto endloop;
@ -347,7 +347,7 @@ singleByteMode:
/* here: b<0x20 because otherwise we would be in fastSingle */
if((1UL<<b)&0x2601 /* binary 0010 0110 0000 0001, check for b==0xd || b==0xa || b==9 || b==0 */) {
/* CR/LF/TAB/NUL */
*target++=(UChar)b;
*target++=(char16_t)b;
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -392,7 +392,7 @@ singleByteMode:
state=quotePairTwo;
break;
case quotePairTwo:
*target++=(UChar)((byteOne<<8)|b);
*target++=(char16_t)((byteOne<<8)|b);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -402,7 +402,7 @@ singleByteMode:
case quoteOne:
if(b<0x80) {
/* all static offsets are in the BMP */
*target++=(UChar)(staticOffsets[quoteWindow]+b);
*target++=(char16_t)(staticOffsets[quoteWindow]+b);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -410,15 +410,15 @@ singleByteMode:
/* write from dynamic window */
uint32_t c=scsu->toUDynamicOffsets[quoteWindow]+(b&0x7f);
if(c<=0xffff) {
*target++=(UChar)c;
*target++=(char16_t)c;
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
} else {
/* output surrogate pair */
*target++=(UChar)(0xd7c0+(c>>10));
*target++=(char16_t)(0xd7c0+(c>>10));
if(target<targetLimit) {
*target++=(UChar)(0xdc00|(c&0x3ff));
*target++=(char16_t)(0xdc00|(c&0x3ff));
if(offsets!=nullptr) {
*offsets++=sourceIndex;
*offsets++=sourceIndex;
@ -428,7 +428,7 @@ singleByteMode:
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
cnv->UCharErrorBuffer[0]=(char16_t)(0xdc00|(c&0x3ff));
cnv->UCharErrorBufferLength=1;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
goto endloop;
@ -478,7 +478,7 @@ singleByteMode:
if(state==readCommand) {
fastUnicode:
while(source+1<sourceLimit && target<targetLimit && (uint8_t)((b=*source)-UC0)>(Urs-UC0)) {
*target++=(UChar)((b<<8)|source[1]);
*target++=(char16_t)((b<<8)|source[1]);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -542,7 +542,7 @@ fastUnicode:
state=quotePairTwo;
break;
case quotePairTwo:
*target++=(UChar)((byteOne<<8)|b);
*target++=(char16_t)((byteOne<<8)|b);
if(offsets!=nullptr) {
*offsets++=sourceIndex;
}
@ -588,8 +588,8 @@ _SCSUToUnicode(UConverterToUnicodeArgs *pArgs,
UConverter *cnv;
SCSUData *scsu;
const uint8_t *source, *sourceLimit;
UChar *target;
const UChar *targetLimit;
char16_t *target;
const char16_t *targetLimit;
UBool isSingleByteMode;
uint8_t state, byteOne;
int8_t quoteWindow, dynamicWindow;
@ -639,20 +639,20 @@ fastSingle:
++source;
if(b<=0x7f) {
/* write US-ASCII graphic character or DEL */
*target++=(UChar)b;
*target++=(char16_t)b;
} else {
/* write from dynamic window */
uint32_t c=scsu->toUDynamicOffsets[dynamicWindow]+(b&0x7f);
if(c<=0xffff) {
*target++=(UChar)c;
*target++=(char16_t)c;
} else {
/* output surrogate pair */
*target++=(UChar)(0xd7c0+(c>>10));
*target++=(char16_t)(0xd7c0+(c>>10));
if(target<targetLimit) {
*target++=(UChar)(0xdc00|(c&0x3ff));
*target++=(char16_t)(0xdc00|(c&0x3ff));
} else {
/* target overflow */
cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
cnv->UCharErrorBuffer[0]=(char16_t)(0xdc00|(c&0x3ff));
cnv->UCharErrorBufferLength=1;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
goto endloop;
@ -677,7 +677,7 @@ singleByteMode:
/* here: b<0x20 because otherwise we would be in fastSingle */
if((1UL<<b)&0x2601 /* binary 0010 0110 0000 0001, check for b==0xd || b==0xa || b==9 || b==0 */) {
/* CR/LF/TAB/NUL */
*target++=(UChar)b;
*target++=(char16_t)b;
goto fastSingle;
} else if(SC0<=b) {
if(b<=SC7) {
@ -716,26 +716,26 @@ singleByteMode:
state=quotePairTwo;
break;
case quotePairTwo:
*target++=(UChar)((byteOne<<8)|b);
*target++=(char16_t)((byteOne<<8)|b);
state=readCommand;
goto fastSingle;
case quoteOne:
if(b<0x80) {
/* all static offsets are in the BMP */
*target++=(UChar)(staticOffsets[quoteWindow]+b);
*target++=(char16_t)(staticOffsets[quoteWindow]+b);
} else {
/* write from dynamic window */
uint32_t c=scsu->toUDynamicOffsets[quoteWindow]+(b&0x7f);
if(c<=0xffff) {
*target++=(UChar)c;
*target++=(char16_t)c;
} else {
/* output surrogate pair */
*target++=(UChar)(0xd7c0+(c>>10));
*target++=(char16_t)(0xd7c0+(c>>10));
if(target<targetLimit) {
*target++=(UChar)(0xdc00|(c&0x3ff));
*target++=(char16_t)(0xdc00|(c&0x3ff));
} else {
/* target overflow */
cnv->UCharErrorBuffer[0]=(UChar)(0xdc00|(c&0x3ff));
cnv->UCharErrorBuffer[0]=(char16_t)(0xdc00|(c&0x3ff));
cnv->UCharErrorBufferLength=1;
*pErrorCode=U_BUFFER_OVERFLOW_ERROR;
goto endloop;
@ -782,7 +782,7 @@ singleByteMode:
if(state==readCommand) {
fastUnicode:
while(source+1<sourceLimit && target<targetLimit && (uint8_t)((b=*source)-UC0)>(Urs-UC0)) {
*target++=(UChar)((b<<8)|source[1]);
*target++=(char16_t)((b<<8)|source[1]);
source+=2;
}
}
@ -839,7 +839,7 @@ fastUnicode:
state=quotePairTwo;
break;
case quotePairTwo:
*target++=(UChar)((byteOne<<8)|b);
*target++=(char16_t)((byteOne<<8)|b);
state=readCommand;
goto fastUnicode;
}
@ -1012,7 +1012,7 @@ _SCSUFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
SCSUData *scsu;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
int32_t *offsets;
@ -1029,7 +1029,7 @@ _SCSUFromUnicodeWithOffsets(UConverterFromUnicodeArgs *pArgs,
/* variables for compression heuristics */
uint32_t offset;
UChar lead, trail;
char16_t lead, trail;
int code;
int8_t window;
@ -1104,7 +1104,7 @@ loop:
} else if(U16_IS_SURROGATE(c)) {
if(U16_IS_SURROGATE_LEAD(c)) {
getTrailSingle:
lead=(UChar)c;
lead=(char16_t)c;
if(source<sourceLimit) {
/* test the following code unit */
trail=*source;
@ -1301,7 +1301,7 @@ getTrailSingle:
/* c is a surrogate */
if(U16_IS_SURROGATE_LEAD(c)) {
getTrailUnicode:
lead=(UChar)c;
lead=(char16_t)c;
if(source<sourceLimit) {
/* test the following code unit */
trail=*source;
@ -1520,7 +1520,7 @@ _SCSUFromUnicode(UConverterFromUnicodeArgs *pArgs,
UErrorCode *pErrorCode) {
UConverter *cnv;
SCSUData *scsu;
const UChar *source, *sourceLimit;
const char16_t *source, *sourceLimit;
uint8_t *target;
int32_t targetCapacity;
@ -1534,7 +1534,7 @@ _SCSUFromUnicode(UConverterFromUnicodeArgs *pArgs,
/* variables for compression heuristics */
uint32_t offset;
UChar lead, trail;
char16_t lead, trail;
int code;
int8_t window;
@ -1594,7 +1594,7 @@ loop:
} else if(U16_IS_SURROGATE(c)) {
if(U16_IS_SURROGATE_LEAD(c)) {
getTrailSingle:
lead=(UChar)c;
lead=(char16_t)c;
if(source<sourceLimit) {
/* test the following code unit */
trail=*source;
@ -1778,7 +1778,7 @@ getTrailSingle:
/* c is a surrogate */
if(U16_IS_SURROGATE_LEAD(c)) {
getTrailUnicode:
lead=(UChar)c;
lead=(char16_t)c;
if(source<sourceLimit) {
/* test the following code unit */
trail=*source;
@ -2027,7 +2027,7 @@ static const UConverterStaticData _SCSUStaticData={
"SCSU",
1212, /* CCSID for SCSU */
UCNV_IBM, UCNV_SCSU,
1, 3, /* one UChar generates at least 1 byte and at most 3 bytes */
1, 3, /* one char16_t generates at least 1 byte and at most 3 bytes */
/*
* The subchar here is ignored because _SCSUOpen() sets U+fffd as a Unicode
* substitution string.

4
icu4c/source/common/ucnvsel.cpp
View file

@ -741,7 +741,7 @@ static UEnumeration *selectForMask(const UConverterSelector* sel,
/* check a string against the selector - UTF16 version */
U_CAPI UEnumeration * U_EXPORT2
ucnvsel_selectForString(const UConverterSelector* sel,
const UChar *s, int32_t length, UErrorCode *status) {
const char16_t *s, int32_t length, UErrorCode *status) {
// check if already failed
if (U_FAILURE(*status)) {
return nullptr;
@ -761,7 +761,7 @@ ucnvsel_selectForString(const UConverterSelector* sel,
uprv_memset(mask, ~0, columns *4);
if(s!=nullptr) {
const UChar *limit;
const char16_t *limit;
if (length >= 0) {
limit = s + length;
} else {

4
icu4c/source/common/ucol_data.h
View file

@ -43,7 +43,7 @@ typedef struct {
uint32_t magic; /* magic number - lets us know whether reserved data is reset or junked */
uint32_t mappingPosition; /* const uint8_t *mappingPosition; */
uint32_t expansion; /* uint32_t *expansion; */
uint32_t contractionIndex; /* UChar *contractionIndex; */
uint32_t contractionIndex; /* char16_t *contractionIndex; */
uint32_t contractionCEs; /* uint32_t *contractionCEs; */
uint32_t contractionSize; /* needed for various closures */
/*int32_t latinOneMapping;*/ /* this is now handled in the trie itself *//* fast track to latin1 chars */
@ -60,7 +60,7 @@ typedef struct {
/* in contractions. */
int32_t contractionUCACombosSize; /* number of UCA contraction items. */
/*Length is contractionUCACombosSize*contractionUCACombosWidth*sizeof(UChar) */
/*Length is contractionUCACombosSize*contractionUCACombosWidth*sizeof(char16_t) */
UBool jamoSpecial; /* is jamoSpecial */
UBool isBigEndian; /* is this data big endian? from the UDataInfo header*/
uint8_t charSetFamily; /* what is the charset family of this data from the UDataInfo header*/

2
icu4c/source/common/ucol_swp.cpp
View file

@ -204,7 +204,7 @@ swapFormatVersion3(const UDataSwapper *ds,
/* swap the contractions */
if(header.contractionSize!=0) {
/* contractionIndex: UChar[] */
/* contractionIndex: char16_t[] */
ds->swapArray16(ds, inBytes+header.contractionIndex, header.contractionSize*2,
outBytes+header.contractionIndex, pErrorCode);

104
icu4c/source/common/ucurr.cpp
View file

@ -49,7 +49,7 @@ using namespace icu;
#endif
typedef struct IsoCodeEntry {
const UChar *isoCode; /* const because it's a reference to a resource bundle string. */
const char16_t *isoCode; /* const because it's a reference to a resource bundle string. */
UDate from;
UDate to;
} IsoCodeEntry;
@ -272,11 +272,11 @@ deleteUnicode(void *obj) {
}
/**
* Unfortunately, we have to convert the UChar* currency code to char*
* Unfortunately, we have to convert the char16_t* currency code to char*
* to use it as a resource key.
*/
static inline char*
myUCharsToChars(char* resultOfLen4, const UChar* currency) {
myUCharsToChars(char* resultOfLen4, const char16_t* currency) {
u_UCharsToChars(currency, resultOfLen4, ISO_CURRENCY_CODE_LENGTH);
resultOfLen4[ISO_CURRENCY_CODE_LENGTH] = 0;
return resultOfLen4;
@ -291,7 +291,7 @@ myUCharsToChars(char* resultOfLen4, const UChar* currency) {
* and cashRounding ).
*/
static const int32_t*
_findMetaData(const UChar* currency, UErrorCode& ec) {
_findMetaData(const char16_t* currency, UErrorCode& ec) {
if (currency == 0 || *currency == 0) {
if (U_SUCCESS(ec)) {
@ -372,10 +372,10 @@ static CReg* gCRegHead = 0;
struct CReg : public icu::UMemory {
CReg *next;
UChar iso[ISO_CURRENCY_CODE_LENGTH+1];
char16_t iso[ISO_CURRENCY_CODE_LENGTH+1];
char id[ULOC_FULLNAME_CAPACITY];
CReg(const UChar* _iso, const char* _id)
CReg(const char16_t* _iso, const char* _id)
: next(0)
{
int32_t len = (int32_t)uprv_strlen(_id);
@ -388,7 +388,7 @@ struct CReg : public icu::UMemory {
iso[ISO_CURRENCY_CODE_LENGTH] = 0;
}
static UCurrRegistryKey reg(const UChar* _iso, const char* _id, UErrorCode* status)
static UCurrRegistryKey reg(const char16_t* _iso, const char* _id, UErrorCode* status)
{
if (status && U_SUCCESS(*status) && _iso && _id) {
CReg* n = new CReg(_iso, _id);
@ -427,8 +427,8 @@ struct CReg : public icu::UMemory {
return found;
}
static const UChar* get(const char* id) {
const UChar* result = nullptr;
static const char16_t* get(const char* id) {
const char16_t* result = nullptr;
umtx_lock(&gCRegLock);
CReg* p = gCRegHead;
@ -458,7 +458,7 @@ struct CReg : public icu::UMemory {
// -------------------------------------
U_CAPI UCurrRegistryKey U_EXPORT2
ucurr_register(const UChar* isoCode, const char* locale, UErrorCode *status)
ucurr_register(const char16_t* isoCode, const char* locale, UErrorCode *status)
{
if (status && U_SUCCESS(*status)) {
char id[ULOC_FULLNAME_CAPACITY];
@ -511,7 +511,7 @@ U_CDECL_END
U_CAPI int32_t U_EXPORT2
ucurr_forLocale(const char* locale,
UChar* buff,
char16_t* buff,
int32_t buffCapacity,
UErrorCode* ec) {
if (U_FAILURE(*ec)) { return 0; }
@ -540,7 +540,7 @@ ucurr_forLocale(const char* locale,
}
#if !UCONFIG_NO_SERVICE
const UChar* result = CReg::get(id);
const char16_t* result = CReg::get(id);
if (result) {
if(buffCapacity > u_strlen(result)) {
u_strcpy(buff, result);
@ -555,7 +555,7 @@ ucurr_forLocale(const char* locale,
idDelim[0] = 0;
}
const UChar* s = nullptr; // Currency code from data file.
const char16_t* s = nullptr; // Currency code from data file.
if (id[0] == 0) {
// No point looking in the data for an empty string.
// This is what we would get.
@ -575,7 +575,7 @@ ucurr_forLocale(const char* locale,
ures_getByIndex(countryArray, i, nullptr, &localStatus));
// The currency is legal tender if it is *not* marked with tender{"false"}.
UErrorCode tenderStatus = localStatus;
const UChar *tender =
const char16_t *tender =
ures_getStringByKey(currencyReq.getAlias(), "tender", nullptr, &tenderStatus);
bool isTender = U_FAILURE(tenderStatus) || u_strcmp(tender, u"false") != 0;
if (!isTender && s != nullptr) {
@ -650,8 +650,8 @@ static UBool fallback(char *loc) {
}
U_CAPI const UChar* U_EXPORT2
ucurr_getName(const UChar* currency,
U_CAPI const char16_t* U_EXPORT2
ucurr_getName(const char16_t* currency,
const char* locale,
UCurrNameStyle nameStyle,
UBool* isChoiceFormat, // fillin
@ -705,7 +705,7 @@ ucurr_getName(const UChar* currency,
/* Normalize the keyword value to uppercase */
T_CString_toUpperCase(buf);
const UChar* s = nullptr;
const char16_t* s = nullptr;
ec2 = U_ZERO_ERROR;
LocalUResourceBundlePointer rb(ures_open(U_ICUDATA_CURR, loc, &ec2));
@ -765,8 +765,8 @@ ucurr_getName(const UChar* currency,
return currency;
}
U_CAPI const UChar* U_EXPORT2
ucurr_getPluralName(const UChar* currency,
U_CAPI const char16_t* U_EXPORT2
ucurr_getPluralName(const char16_t* currency,
const char* locale,
UBool* isChoiceFormat,
const char* pluralCount,
@ -801,7 +801,7 @@ ucurr_getPluralName(const UChar* currency,
char buf[ISO_CURRENCY_CODE_LENGTH+1];
myUCharsToChars(buf, currency);
const UChar* s = nullptr;
const char16_t* s = nullptr;
ec2 = U_ZERO_ERROR;
UResourceBundle* rb = ures_open(U_ICUDATA_CURR, loc, &ec2);
@ -852,7 +852,7 @@ ucurr_getPluralName(const UChar* currency,
typedef struct {
const char* IsoCode; // key
UChar* currencyName; // value
char16_t* currencyName; // value
int32_t currencyNameLen; // value length
int32_t flag; // flags
} CurrencyNameStruct;
@ -903,7 +903,7 @@ getCurrencyNameCount(const char* loc, int32_t* total_currency_name_count, int32_
U_NAMESPACE_USE
*total_currency_name_count = 0;
*total_currency_symbol_count = 0;
const UChar* s = nullptr;
const char16_t* s = nullptr;
char locale[ULOC_FULLNAME_CAPACITY] = "";
uprv_strcpy(locale, loc);
const icu::Hashtable *currencySymbolsEquiv = getCurrSymbolsEquiv();
@ -945,14 +945,14 @@ getCurrencyNameCount(const char* loc, int32_t* total_currency_name_count, int32_
}
}
static UChar*
toUpperCase(const UChar* source, int32_t len, const char* locale) {
UChar* dest = nullptr;
static char16_t*
toUpperCase(const char16_t* source, int32_t len, const char* locale) {
char16_t* dest = nullptr;
UErrorCode ec = U_ZERO_ERROR;
int32_t destLen = u_strToUpper(dest, 0, source, len, locale, &ec);
ec = U_ZERO_ERROR;
dest = (UChar*)uprv_malloc(sizeof(UChar) * MAX(destLen, len));
dest = (char16_t*)uprv_malloc(sizeof(char16_t) * MAX(destLen, len));
u_strToUpper(dest, destLen, source, len, locale, &ec);
if (U_FAILURE(ec)) {
u_memcpy(dest, source, len);
@ -999,7 +999,7 @@ collectCurrencyNames(const char* locale,
if (U_FAILURE(ec)) return;
const UChar* s = nullptr; // currency name
const char16_t* s = nullptr; // currency name
char* iso = nullptr; // currency ISO code
*total_currency_name_count = 0;
@ -1035,7 +1035,7 @@ collectCurrencyNames(const char* locale,
}
// Add currency symbol.
(*currencySymbols)[*total_currency_symbol_count].IsoCode = iso;
(*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*)s;
(*currencySymbols)[*total_currency_symbol_count].currencyName = (char16_t*)s;
(*currencySymbols)[*total_currency_symbol_count].flag = 0;
(*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = len;
// Add equivalent symbols
@ -1046,7 +1046,7 @@ collectCurrencyNames(const char* locale,
while ((symbol = iter.next()) != nullptr) {
(*currencySymbols)[*total_currency_symbol_count].IsoCode = iso;
(*currencySymbols)[*total_currency_symbol_count].currencyName =
const_cast<UChar*>(symbol->getBuffer());
const_cast<char16_t*>(symbol->getBuffer());
(*currencySymbols)[*total_currency_symbol_count].flag = 0;
(*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = symbol->length();
}
@ -1055,7 +1055,7 @@ collectCurrencyNames(const char* locale,
// Add currency long name.
s = ures_getStringByIndex(names, UCURR_LONG_NAME, &len, &ec2);
(*currencyNames)[*total_currency_name_count].IsoCode = iso;
UChar* upperName = toUpperCase(s, len, locale);
char16_t* upperName = toUpperCase(s, len, locale);
(*currencyNames)[*total_currency_name_count].currencyName = upperName;
(*currencyNames)[*total_currency_name_count].flag = NEED_TO_BE_DELETED;
(*currencyNames)[(*total_currency_name_count)++].currencyNameLen = len;
@ -1063,7 +1063,7 @@ collectCurrencyNames(const char* locale,
// put (iso, 3, and iso) in to array
// Add currency ISO code.
(*currencySymbols)[*total_currency_symbol_count].IsoCode = iso;
(*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*)uprv_malloc(sizeof(UChar)*3);
(*currencySymbols)[*total_currency_symbol_count].currencyName = (char16_t*)uprv_malloc(sizeof(char16_t)*3);
// Must convert iso[] into Unicode
u_charsToUChars(iso, (*currencySymbols)[*total_currency_symbol_count].currencyName, 3);
(*currencySymbols)[*total_currency_symbol_count].flag = NEED_TO_BE_DELETED;
@ -1097,7 +1097,7 @@ collectCurrencyNames(const char* locale,
// currency long name?
s = ures_getStringByIndex(names, j, &len, &ec5);
(*currencyNames)[*total_currency_name_count].IsoCode = iso;
UChar* upperName = toUpperCase(s, len, locale);
char16_t* upperName = toUpperCase(s, len, locale);
(*currencyNames)[*total_currency_name_count].currencyName = upperName;
(*currencyNames)[*total_currency_name_count].flag = NEED_TO_BE_DELETED;
(*currencyNames)[(*total_currency_name_count)++].currencyNameLen = len;
@ -1164,7 +1164,7 @@ collectCurrencyNames(const char* locale,
static int32_t
binarySearch(const CurrencyNameStruct* currencyNames,
int32_t indexInCurrencyNames,
const UChar key,
const char16_t key,
int32_t* begin, int32_t* end) {
#ifdef UCURR_DEBUG
printf("key = %x\n", key);
@ -1278,14 +1278,14 @@ binarySearch(const CurrencyNameStruct* currencyNames,
static void
linearSearch(const CurrencyNameStruct* currencyNames,
int32_t begin, int32_t end,
const UChar* text, int32_t textLen,
const char16_t* text, int32_t textLen,
int32_t *partialMatchLen,
int32_t *maxMatchLen, int32_t* maxMatchIndex) {
int32_t initialPartialMatchLen = *partialMatchLen;
for (int32_t index = begin; index <= end; ++index) {
int32_t len = currencyNames[index].currencyNameLen;
if (len > *maxMatchLen && len <= textLen &&
uprv_memcmp(currencyNames[index].currencyName, text, len * sizeof(UChar)) == 0) {
uprv_memcmp(currencyNames[index].currencyName, text, len * sizeof(char16_t)) == 0) {
*partialMatchLen = MAX(*partialMatchLen, len);
*maxMatchIndex = index;
*maxMatchLen = len;
@ -1317,7 +1317,7 @@ linearSearch(const CurrencyNameStruct* currencyNames,
static void
searchCurrencyName(const CurrencyNameStruct* currencyNames,
int32_t total_currency_count,
const UChar* text, int32_t textLen,
const char16_t* text, int32_t textLen,
int32_t *partialMatchLen,
int32_t* maxMatchLen, int32_t* maxMatchIndex) {
*maxMatchIndex = -1;
@ -1523,7 +1523,7 @@ uprv_parseCurrency(const char* locale,
icu::ParsePosition& pos,
int8_t type,
int32_t* partialMatchLen,
UChar* result,
char16_t* result,
UErrorCode& ec) {
U_NAMESPACE_USE
if (U_FAILURE(ec)) {
@ -1541,8 +1541,8 @@ uprv_parseCurrency(const char* locale,
int32_t start = pos.getIndex();
UChar inputText[MAX_CURRENCY_NAME_LEN];
UChar upperText[MAX_CURRENCY_NAME_LEN];
char16_t inputText[MAX_CURRENCY_NAME_LEN];
char16_t upperText[MAX_CURRENCY_NAME_LEN];
int32_t textLen = MIN(MAX_CURRENCY_NAME_LEN, text.length() - start);
text.extract(start, textLen, inputText);
UErrorCode ec1 = U_ZERO_ERROR;
@ -1630,13 +1630,13 @@ void uprv_currencyLeads(const char* locale, icu::UnicodeSet& result, UErrorCode&
* DecimalFormat and DecimalFormatSymbols.
*/
U_CAPI void
uprv_getStaticCurrencyName(const UChar* iso, const char* loc,
uprv_getStaticCurrencyName(const char16_t* iso, const char* loc,
icu::UnicodeString& result, UErrorCode& ec)
{
U_NAMESPACE_USE
int32_t len;
const UChar* currname = ucurr_getName(iso, loc, UCURR_SYMBOL_NAME,
const char16_t* currname = ucurr_getName(iso, loc, UCURR_SYMBOL_NAME,
nullptr /* isChoiceFormat */, &len, &ec);
if (U_SUCCESS(ec)) {
result.setTo(currname, len);
@ -1644,12 +1644,12 @@ uprv_getStaticCurrencyName(const UChar* iso, const char* loc,
}
U_CAPI int32_t U_EXPORT2
ucurr_getDefaultFractionDigits(const UChar* currency, UErrorCode* ec) {
ucurr_getDefaultFractionDigits(const char16_t* currency, UErrorCode* ec) {
return ucurr_getDefaultFractionDigitsForUsage(currency,UCURR_USAGE_STANDARD,ec);
}
U_CAPI int32_t U_EXPORT2
ucurr_getDefaultFractionDigitsForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) {
ucurr_getDefaultFractionDigitsForUsage(const char16_t* currency, const UCurrencyUsage usage, UErrorCode* ec) {
int32_t fracDigits = 0;
if (U_SUCCESS(*ec)) {
switch (usage) {
@ -1667,12 +1667,12 @@ ucurr_getDefaultFractionDigitsForUsage(const UChar* currency, const UCurrencyUsa
}
U_CAPI double U_EXPORT2
ucurr_getRoundingIncrement(const UChar* currency, UErrorCode* ec) {
ucurr_getRoundingIncrement(const char16_t* currency, UErrorCode* ec) {
return ucurr_getRoundingIncrementForUsage(currency, UCURR_USAGE_STANDARD, ec);
}
U_CAPI double U_EXPORT2
ucurr_getRoundingIncrementForUsage(const UChar* currency, const UCurrencyUsage usage, UErrorCode* ec) {
ucurr_getRoundingIncrementForUsage(const char16_t* currency, const UCurrencyUsage usage, UErrorCode* ec) {
double result = 0.0;
const int32_t *data = _findMetaData(currency, *ec);
@ -2119,7 +2119,7 @@ ucurr_createCurrencyList(UHashtable *isoCodes, UErrorCode* status){
if (idRes == nullptr) {
continue;
}
const UChar *isoCode = ures_getString(idRes, &isoLength, &localStatus);
const char16_t *isoCode = ures_getString(idRes, &isoLength, &localStatus);
// get from date
UDate fromDate = U_DATE_MIN;
@ -2156,7 +2156,7 @@ ucurr_createCurrencyList(UHashtable *isoCodes, UErrorCode* status){
entry->to = toDate;
localStatus = U_ZERO_ERROR;
uhash_put(isoCodes, (UChar *)isoCode, entry, &localStatus);
uhash_put(isoCodes, (char16_t *)isoCode, entry, &localStatus);
}
} else {
*status = localStatus;
@ -2242,7 +2242,7 @@ static void U_CALLCONV initCurrSymbolsEquiv() {
}
U_CAPI UBool U_EXPORT2
ucurr_isAvailable(const UChar* isoCode, UDate from, UDate to, UErrorCode* eErrorCode) {
ucurr_isAvailable(const char16_t* isoCode, UDate from, UDate to, UErrorCode* eErrorCode) {
umtx_initOnce(gIsoCodesInitOnce, &initIsoCodes, *eErrorCode);
if (U_FAILURE(*eErrorCode)) {
return false;
@ -2399,13 +2399,13 @@ U_CAPI int32_t U_EXPORT2
ucurr_forLocaleAndDate(const char* locale,
UDate date,
int32_t index,
UChar* buff,
char16_t* buff,
int32_t buffCapacity,
UErrorCode* ec)
{
int32_t resLen = 0;
int32_t currIndex = 0;
const UChar* s = nullptr;
const char16_t* s = nullptr;
if (ec != nullptr && U_SUCCESS(*ec))
{
@ -2624,7 +2624,7 @@ U_CAPI UEnumeration *U_EXPORT2 ucurr_getKeywordValuesForLocale(const char *key,
/* optimize - use the utf-8 string */
#else
{
const UChar* defString = ures_getStringByKey(&curbndl, "id", &curIDLength, status);
const char16_t* defString = ures_getStringByKey(&curbndl, "id", &curIDLength, status);
if(U_SUCCESS(*status)) {
if(curIDLength+1 > ULOC_KEYWORDS_CAPACITY) {
*status = U_BUFFER_OVERFLOW_ERROR;
@ -2701,7 +2701,7 @@ U_CAPI UEnumeration *U_EXPORT2 ucurr_getKeywordValuesForLocale(const char *key,
U_CAPI int32_t U_EXPORT2
ucurr_getNumericCode(const UChar* currency) {
ucurr_getNumericCode(const char16_t* currency) {
int32_t code = 0;
if (currency && u_strlen(currency) == ISO_CURRENCY_CODE_LENGTH) {
UErrorCode status = U_ZERO_ERROR;

10
icu4c/source/common/uenum.cpp
View file

@ -85,17 +85,17 @@ uenum_count(UEnumeration* en, UErrorCode* status)
}
/* Don't call this directly. Only uenum_unext should be calling this. */
U_CAPI const UChar* U_EXPORT2
U_CAPI const char16_t* U_EXPORT2
uenum_unextDefault(UEnumeration* en,
int32_t* resultLength,
UErrorCode* status)
{
UChar *ustr = nullptr;
char16_t *ustr = nullptr;
int32_t len = 0;
if (en->next != nullptr) {
const char *cstr = en->next(en, &len, status);
if (cstr != nullptr) {
ustr = (UChar*) _getBuffer(en, (len+1) * sizeof(UChar));
ustr = (char16_t*) _getBuffer(en, (len+1) * sizeof(char16_t));
if (ustr == nullptr) {
*status = U_MEMORY_ALLOCATION_ERROR;
} else {
@ -119,7 +119,7 @@ uenum_nextDefault(UEnumeration* en,
{
if (en->uNext != nullptr) {
char *tempCharVal;
const UChar *tempUCharVal = en->uNext(en, resultLength, status);
const char16_t *tempUCharVal = en->uNext(en, resultLength, status);
if (tempUCharVal == nullptr) {
return nullptr;
}
@ -137,7 +137,7 @@ uenum_nextDefault(UEnumeration* en,
}
}
U_CAPI const UChar* U_EXPORT2
U_CAPI const char16_t* U_EXPORT2
uenum_unext(UEnumeration* en,
int32_t* resultLength,
UErrorCode* status)

6
icu4c/source/common/uhash.cpp
View file

@ -928,7 +928,7 @@ uhash_tokp(void* p) {
U_CAPI int32_t U_EXPORT2
uhash_hashUChars(const UHashTok key) {
const UChar *s = (const UChar *)key.pointer;
const char16_t *s = (const char16_t *)key.pointer;
return s == nullptr ? 0 : ustr_hashUCharsN(s, u_strlen(s));
}
@ -1002,8 +1002,8 @@ uhash_equals(const UHashtable* hash1, const UHashtable* hash2){
U_CAPI UBool U_EXPORT2
uhash_compareUChars(const UHashTok key1, const UHashTok key2) {
const UChar *p1 = (const UChar*) key1.pointer;
const UChar *p2 = (const UChar*) key2.pointer;
const char16_t *p1 = (const char16_t*) key1.pointer;
const char16_t *p2 = (const char16_t*) key2.pointer;
if (p1 == p2) {
return true;
}

92
icu4c/source/common/uidna.cpp
View file

@ -30,7 +30,7 @@
#include "sprpimpl.h"
/* it is official IDNA ACE Prefix is "xn--" */
static const UChar ACE_PREFIX[] ={ 0x0078,0x006E,0x002d,0x002d } ;
static const char16_t ACE_PREFIX[] ={ 0x0078,0x006E,0x002d,0x002d } ;
#define ACE_PREFIX_LENGTH 4
#define MAX_LABEL_LENGTH 63
@ -47,8 +47,8 @@ static const UChar ACE_PREFIX[] ={ 0x0078,0x006E,0x002d,0x002d } ;
#define CAPITAL_A 0x0041
#define CAPITAL_Z 0x005A
inline static UChar
toASCIILower(UChar ch){
inline static char16_t
toASCIILower(char16_t ch){
if(CAPITAL_A <= ch && ch <= CAPITAL_Z){
return ch + LOWER_CASE_DELTA;
}
@ -56,7 +56,7 @@ toASCIILower(UChar ch){
}
inline static UBool
startsWithPrefix(const UChar* src , int32_t srcLength){
startsWithPrefix(const char16_t* src , int32_t srcLength){
if(srcLength < ACE_PREFIX_LENGTH){
return false;
}
@ -71,8 +71,8 @@ startsWithPrefix(const UChar* src , int32_t srcLength){
inline static int32_t
compareCaseInsensitiveASCII(const UChar* s1, int32_t s1Len,
const UChar* s2, int32_t s2Len){
compareCaseInsensitiveASCII(const char16_t* s1, int32_t s1Len,
const char16_t* s2, int32_t s2Len){
int32_t minLength;
int32_t lengthResult;
@ -92,7 +92,7 @@ compareCaseInsensitiveASCII(const UChar* s1, int32_t s1Len,
lengthResult = 0;
}
UChar c1,c2;
char16_t c1,c2;
int32_t rc;
for(int32_t i =0;/* no condition */;i++) {
@ -126,7 +126,7 @@ compareCaseInsensitiveASCII(const UChar* s1, int32_t s1Len,
* @return true if the char is a label separator
* @stable ICU 2.8
*/
static inline UBool isLabelSeparator(UChar ch){
static inline UBool isLabelSeparator(char16_t ch){
switch(ch){
case 0x002e:
case 0x3002:
@ -142,8 +142,8 @@ static inline UBool isLabelSeparator(UChar ch){
// if *limit == separator then the length returned does not include
// the separtor.
static inline int32_t
getNextSeparator(UChar *src, int32_t srcLength,
UChar **limit, UBool *done){
getNextSeparator(char16_t *src, int32_t srcLength,
char16_t **limit, UBool *done){
if(srcLength == -1){
int32_t i;
for(i=0 ; ;i++){
@ -174,7 +174,7 @@ getNextSeparator(UChar *src, int32_t srcLength,
return i;
}
}
static inline UBool isLDHChar(UChar ch){
static inline UBool isLDHChar(char16_t ch){
// high runner case
if(ch>0x007A){
return false;
@ -191,8 +191,8 @@ static inline UBool isLDHChar(UChar ch){
}
static int32_t
_internal_toASCII(const UChar* src, int32_t srcLength,
UChar* dest, int32_t destCapacity,
_internal_toASCII(const char16_t* src, int32_t srcLength,
char16_t* dest, int32_t destCapacity,
int32_t options,
UStringPrepProfile* nameprep,
UParseError* parseError,
@ -200,9 +200,9 @@ _internal_toASCII(const UChar* src, int32_t srcLength,
{
// TODO Revisit buffer handling. The label should not be over 63 ASCII characters. ICU4J may need to be updated too.
UChar b1Stack[MAX_LABEL_BUFFER_SIZE], b2Stack[MAX_LABEL_BUFFER_SIZE];
char16_t b1Stack[MAX_LABEL_BUFFER_SIZE], b2Stack[MAX_LABEL_BUFFER_SIZE];
//initialize pointers to stack buffers
UChar *b1 = b1Stack, *b2 = b2Stack;
char16_t *b1 = b1Stack, *b2 = b2Stack;
int32_t b1Len=0, b2Len,
b1Capacity = MAX_LABEL_BUFFER_SIZE,
b2Capacity = MAX_LABEL_BUFFER_SIZE ,
@ -228,7 +228,7 @@ _internal_toASCII(const UChar* src, int32_t srcLength,
}
if(srcLength > b1Capacity){
b1 = (UChar*) uprv_malloc(srcLength * U_SIZEOF_UCHAR);
b1 = (char16_t*) uprv_malloc(srcLength * U_SIZEOF_UCHAR);
if(b1==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -256,7 +256,7 @@ _internal_toASCII(const UChar* src, int32_t srcLength,
if(b1 != b1Stack){
uprv_free(b1);
}
b1 = (UChar*) uprv_malloc(b1Len * U_SIZEOF_UCHAR);
b1 = (char16_t*) uprv_malloc(b1Len * U_SIZEOF_UCHAR);
if(b1==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -338,7 +338,7 @@ _internal_toASCII(const UChar* src, int32_t srcLength,
if(*status == U_BUFFER_OVERFLOW_ERROR){
// redo processing of string
/* we do not have enough room so grow the buffer*/
b2 = (UChar*) uprv_malloc(b2Len * U_SIZEOF_UCHAR);
b2 = (char16_t*) uprv_malloc(b2Len * U_SIZEOF_UCHAR);
if(b2 == nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -391,8 +391,8 @@ CLEANUP:
}
static int32_t
_internal_toUnicode(const UChar* src, int32_t srcLength,
UChar* dest, int32_t destCapacity,
_internal_toUnicode(const char16_t* src, int32_t srcLength,
char16_t* dest, int32_t destCapacity,
int32_t options,
UStringPrepProfile* nameprep,
UParseError* parseError,
@ -404,10 +404,10 @@ _internal_toUnicode(const UChar* src, int32_t srcLength,
int32_t namePrepOptions = ((options & UIDNA_ALLOW_UNASSIGNED) != 0) ? USPREP_ALLOW_UNASSIGNED: 0;
// TODO Revisit buffer handling. The label should not be over 63 ASCII characters. ICU4J may need to be updated too.
UChar b1Stack[MAX_LABEL_BUFFER_SIZE], b2Stack[MAX_LABEL_BUFFER_SIZE], b3Stack[MAX_LABEL_BUFFER_SIZE];
char16_t b1Stack[MAX_LABEL_BUFFER_SIZE], b2Stack[MAX_LABEL_BUFFER_SIZE], b3Stack[MAX_LABEL_BUFFER_SIZE];
//initialize pointers to stack buffers
UChar *b1 = b1Stack, *b2 = b2Stack, *b1Prime=nullptr, *b3=b3Stack;
char16_t *b1 = b1Stack, *b2 = b2Stack, *b1Prime=nullptr, *b3=b3Stack;
int32_t b1Len = 0, b2Len, b1PrimeLen, b3Len,
b1Capacity = MAX_LABEL_BUFFER_SIZE,
b2Capacity = MAX_LABEL_BUFFER_SIZE,
@ -458,7 +458,7 @@ _internal_toUnicode(const UChar* src, int32_t srcLength,
if(*status == U_BUFFER_OVERFLOW_ERROR){
// redo processing of string
/* we do not have enough room so grow the buffer*/
b1 = (UChar*) uprv_malloc(b1Len * U_SIZEOF_UCHAR);
b1 = (char16_t*) uprv_malloc(b1Len * U_SIZEOF_UCHAR);
if(b1==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -475,7 +475,7 @@ _internal_toUnicode(const UChar* src, int32_t srcLength,
}else{
//just point src to b1
b1 = (UChar*) src;
b1 = (char16_t*) src;
b1Len = srcLength;
}
@ -498,7 +498,7 @@ _internal_toUnicode(const UChar* src, int32_t srcLength,
if(*status == U_BUFFER_OVERFLOW_ERROR){
// redo processing of string
/* we do not have enough room so grow the buffer*/
b2 = (UChar*) uprv_malloc(b2Len * U_SIZEOF_UCHAR);
b2 = (char16_t*) uprv_malloc(b2Len * U_SIZEOF_UCHAR);
if(b2==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -516,7 +516,7 @@ _internal_toUnicode(const UChar* src, int32_t srcLength,
if(*status == U_BUFFER_OVERFLOW_ERROR){
// redo processing of string
/* we do not have enough room so grow the buffer*/
b3 = (UChar*) uprv_malloc(b3Len * U_SIZEOF_UCHAR);
b3 = (char16_t*) uprv_malloc(b3Len * U_SIZEOF_UCHAR);
if(b3==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -608,8 +608,8 @@ CLEANUP:
}
U_CAPI int32_t U_EXPORT2
uidna_toASCII(const UChar* src, int32_t srcLength,
UChar* dest, int32_t destCapacity,
uidna_toASCII(const char16_t* src, int32_t srcLength,
char16_t* dest, int32_t destCapacity,
int32_t options,
UParseError* parseError,
UErrorCode* status){
@ -637,8 +637,8 @@ uidna_toASCII(const UChar* src, int32_t srcLength,
}
U_CAPI int32_t U_EXPORT2
uidna_toUnicode(const UChar* src, int32_t srcLength,
UChar* dest, int32_t destCapacity,
uidna_toUnicode(const char16_t* src, int32_t srcLength,
char16_t* dest, int32_t destCapacity,
int32_t options,
UParseError* parseError,
UErrorCode* status){
@ -666,8 +666,8 @@ uidna_toUnicode(const UChar* src, int32_t srcLength,
U_CAPI int32_t U_EXPORT2
uidna_IDNToASCII( const UChar *src, int32_t srcLength,
UChar* dest, int32_t destCapacity,
uidna_IDNToASCII( const char16_t *src, int32_t srcLength,
char16_t* dest, int32_t destCapacity,
int32_t options,
UParseError *parseError,
UErrorCode *status){
@ -689,9 +689,9 @@ uidna_IDNToASCII( const UChar *src, int32_t srcLength,
}
//initialize pointers
UChar *delimiter = (UChar*)src;
UChar *labelStart = (UChar*)src;
UChar *currentDest = (UChar*) dest;
char16_t *delimiter = (char16_t*)src;
char16_t *labelStart = (char16_t*)src;
char16_t *currentDest = (char16_t*) dest;
int32_t remainingLen = srcLength;
int32_t remainingDestCapacity = destCapacity;
int32_t labelLen = 0, labelReqLength = 0;
@ -759,8 +759,8 @@ uidna_IDNToASCII( const UChar *src, int32_t srcLength,
}
U_CAPI int32_t U_EXPORT2
uidna_IDNToUnicode( const UChar* src, int32_t srcLength,
UChar* dest, int32_t destCapacity,
uidna_IDNToUnicode( const char16_t* src, int32_t srcLength,
char16_t* dest, int32_t destCapacity,
int32_t options,
UParseError* parseError,
UErrorCode* status){
@ -782,9 +782,9 @@ uidna_IDNToUnicode( const UChar* src, int32_t srcLength,
}
//initialize pointers
UChar *delimiter = (UChar*)src;
UChar *labelStart = (UChar*)src;
UChar *currentDest = (UChar*) dest;
char16_t *delimiter = (char16_t*)src;
char16_t *labelStart = (char16_t*)src;
char16_t *currentDest = (char16_t*) dest;
int32_t remainingLen = srcLength;
int32_t remainingDestCapacity = destCapacity;
int32_t labelLen = 0, labelReqLength = 0;
@ -858,8 +858,8 @@ uidna_IDNToUnicode( const UChar* src, int32_t srcLength,
}
U_CAPI int32_t U_EXPORT2
uidna_compare( const UChar *s1, int32_t length1,
const UChar *s2, int32_t length2,
uidna_compare( const char16_t *s1, int32_t length1,
const char16_t *s2, int32_t length2,
int32_t options,
UErrorCode* status){
@ -867,8 +867,8 @@ uidna_compare( const UChar *s1, int32_t length1,
return -1;
}
UChar b1Stack[MAX_IDN_BUFFER_SIZE], b2Stack[MAX_IDN_BUFFER_SIZE];
UChar *b1 = b1Stack, *b2 = b2Stack;
char16_t b1Stack[MAX_IDN_BUFFER_SIZE], b2Stack[MAX_IDN_BUFFER_SIZE];
char16_t *b1 = b1Stack, *b2 = b2Stack;
int32_t b1Len, b2Len, b1Capacity = MAX_IDN_BUFFER_SIZE, b2Capacity = MAX_IDN_BUFFER_SIZE;
int32_t result=-1;
@ -877,7 +877,7 @@ uidna_compare( const UChar *s1, int32_t length1,
b1Len = uidna_IDNToASCII(s1, length1, b1, b1Capacity, options, &parseError, status);
if(*status == U_BUFFER_OVERFLOW_ERROR){
// redo processing of string
b1 = (UChar*) uprv_malloc(b1Len * U_SIZEOF_UCHAR);
b1 = (char16_t*) uprv_malloc(b1Len * U_SIZEOF_UCHAR);
if(b1==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;
@ -892,7 +892,7 @@ uidna_compare( const UChar *s1, int32_t length1,
b2Len = uidna_IDNToASCII(s2,length2, b2,b2Capacity, options, &parseError, status);
if(*status == U_BUFFER_OVERFLOW_ERROR){
// redo processing of string
b2 = (UChar*) uprv_malloc(b2Len * U_SIZEOF_UCHAR);
b2 = (char16_t*) uprv_malloc(b2Len * U_SIZEOF_UCHAR);
if(b2==nullptr){
*status = U_MEMORY_ALLOCATION_ERROR;
goto CLEANUP;

18
icu4c/source/common/uinvchar.cpp
View file

@ -182,8 +182,8 @@ static const uint32_t invariantChars[4]={
U_CAPI void U_EXPORT2
u_charsToUChars(const char *cs, UChar *us, int32_t length) {
UChar u;
u_charsToUChars(const char *cs, char16_t *us, int32_t length) {
char16_t u;
uint8_t c;
/*
@ -193,7 +193,7 @@ u_charsToUChars(const char *cs, UChar *us, int32_t length) {
*/
while(length>0) {
c=(uint8_t)(*cs++);
u=(UChar)CHAR_TO_UCHAR(c);
u=(char16_t)CHAR_TO_UCHAR(c);
U_ASSERT((u!=0 || c==0)); /* only invariant chars converted? */
*us++=u;
--length;
@ -201,8 +201,8 @@ u_charsToUChars(const char *cs, UChar *us, int32_t length) {
}
U_CAPI void U_EXPORT2
u_UCharsToChars(const UChar *us, char *cs, int32_t length) {
UChar u;
u_UCharsToChars(const char16_t *us, char *cs, int32_t length) {
char16_t u;
while(length>0) {
u=*us++;
@ -260,8 +260,8 @@ uprv_isInvariantString(const char *s, int32_t length) {
}
U_CAPI UBool U_EXPORT2
uprv_isInvariantUString(const UChar *s, int32_t length) {
UChar c;
uprv_isInvariantUString(const char16_t *s, int32_t length) {
char16_t c;
for(;;) {
if(length<0) {
@ -457,7 +457,7 @@ uprv_isEbcdicAtSign(char c) {
U_CFUNC int32_t
uprv_compareInvAscii(const UDataSwapper *ds,
const char *outString, int32_t outLength,
const UChar *localString, int32_t localLength) {
const char16_t *localString, int32_t localLength) {
(void)ds;
int32_t minLength;
UChar32 c1, c2;
@ -503,7 +503,7 @@ uprv_compareInvAscii(const UDataSwapper *ds,
U_CFUNC int32_t
uprv_compareInvEbcdic(const UDataSwapper *ds,
const char *outString, int32_t outLength,
const UChar *localString, int32_t localLength) {
const char16_t *localString, int32_t localLength) {
(void)ds;
int32_t minLength;
UChar32 c1, c2;

38
icu4c/source/common/uiter.cpp
View file

@ -82,8 +82,8 @@ static const UCharIterator noopIterator={
/* UCharIterator implementation for simple strings -------------------------- */
/*
* This is an implementation of a code unit (UChar) iterator
* for UChar * strings.
* This is an implementation of a code unit (char16_t) iterator
* for char16_t * strings.
*
* The UCharIterator.context field holds a pointer to the string.
*/
@ -154,7 +154,7 @@ stringIteratorHasPrevious(UCharIterator *iter) {
static UChar32 U_CALLCONV
stringIteratorCurrent(UCharIterator *iter) {
if(iter->index<iter->limit) {
return ((const UChar *)(iter->context))[iter->index];
return ((const char16_t *)(iter->context))[iter->index];
} else {
return U_SENTINEL;
}
@ -163,7 +163,7 @@ stringIteratorCurrent(UCharIterator *iter) {
static UChar32 U_CALLCONV
stringIteratorNext(UCharIterator *iter) {
if(iter->index<iter->limit) {
return ((const UChar *)(iter->context))[iter->index++];
return ((const char16_t *)(iter->context))[iter->index++];
} else {
return U_SENTINEL;
}
@ -172,7 +172,7 @@ stringIteratorNext(UCharIterator *iter) {
static UChar32 U_CALLCONV
stringIteratorPrevious(UCharIterator *iter) {
if(iter->index>iter->start) {
return ((const UChar *)(iter->context))[--iter->index];
return ((const char16_t *)(iter->context))[--iter->index];
} else {
return U_SENTINEL;
}
@ -211,7 +211,7 @@ static const UCharIterator stringIterator={
};
U_CAPI void U_EXPORT2
uiter_setString(UCharIterator *iter, const UChar *s, int32_t length) {
uiter_setString(UCharIterator *iter, const char16_t *s, int32_t length) {
if(iter!=0) {
if(s!=0 && length>=-1) {
*iter=stringIterator;
@ -231,12 +231,12 @@ uiter_setString(UCharIterator *iter, const UChar *s, int32_t length) {
/* UCharIterator implementation for UTF-16BE strings ------------------------ */
/*
* This is an implementation of a code unit (UChar) iterator
* This is an implementation of a code unit (char16_t) iterator
* for UTF-16BE strings, i.e., strings in byte-vectors where
* each UChar is stored as a big-endian pair of bytes.
* each char16_t is stored as a big-endian pair of bytes.
*
* The UCharIterator.context field holds a pointer to the string.
* Everything works just like with a normal UChar iterator (uiter_setString),
* Everything works just like with a normal char16_t iterator (uiter_setString),
* except that UChars are assembled from byte pairs.
*/
@ -244,7 +244,7 @@ uiter_setString(UCharIterator *iter, const UChar *s, int32_t length) {
static inline UChar32
utf16BEIteratorGet(UCharIterator *iter, int32_t index) {
const uint8_t *p=(const uint8_t *)iter->context;
return ((UChar)p[2*index]<<8)|(UChar)p[2*index+1];
return ((char16_t)p[2*index]<<8)|(char16_t)p[2*index+1];
}
static UChar32 U_CALLCONV
@ -297,7 +297,7 @@ static const UCharIterator utf16BEIterator={
};
/*
* Count the number of UChars in a UTF-16BE string before a terminating UChar NUL,
* Count the number of UChars in a UTF-16BE string before a terminating char16_t NUL,
* i.e., before a pair of 0 bytes where the first 0 byte is at an even
* offset from s.
*/
@ -306,10 +306,10 @@ utf16BE_strlen(const char *s) {
if(IS_POINTER_EVEN(s)) {
/*
* even-aligned, call u_strlen(s)
* we are probably on a little-endian machine, but searching for UChar NUL
* we are probably on a little-endian machine, but searching for char16_t NUL
* does not care about endianness
*/
return u_strlen((const UChar *)s);
return u_strlen((const char16_t *)s);
} else {
/* odd-aligned, search for pair of 0 bytes */
const char *p=s;
@ -330,8 +330,8 @@ uiter_setUTF16BE(UCharIterator *iter, const char *s, int32_t length) {
length>>=1;
if(U_IS_BIG_ENDIAN && IS_POINTER_EVEN(s)) {
/* big-endian machine and 2-aligned UTF-16BE string: use normal UChar iterator */
uiter_setString(iter, (const UChar *)s, length);
/* big-endian machine and 2-aligned UTF-16BE string: use normal char16_t iterator */
uiter_setString(iter, (const char16_t *)s, length);
return;
}
@ -485,7 +485,7 @@ uiter_setCharacterIterator(UCharIterator *iter, CharacterIterator *charIter) {
/* UCharIterator wrapper around Replaceable --------------------------------- */
/*
* This is an implementation of a code unit (UChar) iterator
* This is an implementation of a code unit (char16_t) iterator
* based on a Replaceable object.
*
* The UCharIterator.context field holds a pointer to the Replaceable.
@ -561,7 +561,7 @@ uiter_setReplaceable(UCharIterator *iter, const Replaceable *rep) {
/*
* Minimal implementation:
* Maintain a single-UChar buffer for an additional surrogate.
* Maintain a single-char16_t buffer for an additional surrogate.
* The caller must not modify start and limit because they are used internally.
*
* Use UCharIterator fields as follows:
@ -873,7 +873,7 @@ utf8IteratorNext(UCharIterator *iter) {
int32_t index;
if(iter->reservedField!=0) {
UChar trail=U16_TRAIL(iter->reservedField);
char16_t trail=U16_TRAIL(iter->reservedField);
iter->reservedField=0;
if((index=iter->index)>=0) {
iter->index=index+1;
@ -908,7 +908,7 @@ utf8IteratorPrevious(UCharIterator *iter) {
int32_t index;
if(iter->reservedField!=0) {
UChar lead=U16_LEAD(iter->reservedField);
char16_t lead=U16_LEAD(iter->reservedField);
iter->reservedField=0;
iter->start-=4; /* we stayed behind the supplementary code point; go before it now */
if((index=iter->index)>0) {

4
icu4c/source/common/uloc_keytype.cpp
View file

@ -269,7 +269,7 @@ initFromResourceBundle(UErrorCode& sts) {
while (ures_hasNext(typeAliasResByKey.getAlias()) && U_SUCCESS(sts)) {
int32_t toLen;
typeAliasDataEntry.adoptInstead(ures_getNextResource(typeAliasResByKey.getAlias(), typeAliasDataEntry.orphan(), &sts));
const UChar* to = ures_getString(typeAliasDataEntry.getAlias(), &toLen, &sts);
const char16_t* to = ures_getString(typeAliasDataEntry.getAlias(), &toLen, &sts);
if (U_FAILURE(sts)) {
break;
}
@ -310,7 +310,7 @@ initFromResourceBundle(UErrorCode& sts) {
while (ures_hasNext(bcpTypeAliasResByKey.getAlias()) && U_SUCCESS(sts)) {
int32_t toLen;
bcpTypeAliasDataEntry.adoptInstead(ures_getNextResource(bcpTypeAliasResByKey.getAlias(), bcpTypeAliasDataEntry.orphan(), &sts));
const UChar* to = ures_getString(bcpTypeAliasDataEntry.getAlias(), &toLen, &sts);
const char16_t* to = ures_getString(bcpTypeAliasDataEntry.getAlias(), &toLen, &sts);
if (U_FAILURE(sts)) {
break;
}

2
icu4c/source/common/umapfile.cpp
View file

@ -147,7 +147,7 @@ typedef HANDLE MemoryMap;
// Convert from UTF-8 string to UTF-16 string.
wchar_t utf16Path[MAX_PATH];
int32_t pathUtf16Len = 0;
u_strFromUTF8(reinterpret_cast<UChar*>(utf16Path), static_cast<int32_t>(UPRV_LENGTHOF(utf16Path)), &pathUtf16Len, path, -1, status);
u_strFromUTF8(reinterpret_cast<char16_t*>(utf16Path), static_cast<int32_t>(UPRV_LENGTHOF(utf16Path)), &pathUtf16Len, path, -1, status);
if (U_FAILURE(*status)) {
return false;

8
icu4c/source/common/unames.cpp
View file

@ -1716,7 +1716,7 @@ uprv_getMaxCharNameLength() {
*/
static void
charSetToUSet(uint32_t cset[8], const USetAdder *sa) {
UChar us[256];
char16_t us[256];
char cs[256];
int32_t i, length;
@ -1736,12 +1736,12 @@ charSetToUSet(uint32_t cset[8], const USetAdder *sa) {
}
}
/* convert the char string to a UChar string */
/* convert the char string to a char16_t string */
u_charsToUChars(cs, us, length);
/* add each UChar to the USet */
/* add each char16_t to the USet */
for(i=0; i<length; ++i) {
if(us[i]!=0 || cs[i]==0) { /* non-invariant chars become (UChar)0 */
if(us[i]!=0 || cs[i]==0) { /* non-invariant chars become (char16_t)0 */
sa->add(sa->set, us[i]);
}
}

8
icu4c/source/common/unicode/ures.h
View file

@ -812,7 +812,7 @@ inline UnicodeString
ures_getUnicodeString(const UResourceBundle *resB, UErrorCode* status) {
UnicodeString result;
int32_t len = 0;
const UChar *r = ures_getString(resB, &len, status);
const char16_t *r = ures_getString(resB, &len, status);
if(U_SUCCESS(*status)) {
result.setTo(true, r, len);
} else {
@ -837,7 +837,7 @@ inline UnicodeString
ures_getNextUnicodeString(UResourceBundle *resB, const char ** key, UErrorCode* status) {
UnicodeString result;
int32_t len = 0;
const UChar* r = ures_getNextString(resB, &len, key, status);
const char16_t* r = ures_getNextString(resB, &len, key, status);
if(U_SUCCESS(*status)) {
result.setTo(true, r, len);
} else {
@ -859,7 +859,7 @@ inline UnicodeString
ures_getUnicodeStringByIndex(const UResourceBundle *resB, int32_t indexS, UErrorCode* status) {
UnicodeString result;
int32_t len = 0;
const UChar* r = ures_getStringByIndex(resB, indexS, &len, status);
const char16_t* r = ures_getStringByIndex(resB, indexS, &len, status);
if(U_SUCCESS(*status)) {
result.setTo(true, r, len);
} else {
@ -882,7 +882,7 @@ inline UnicodeString
ures_getUnicodeStringByKey(const UResourceBundle *resB, const char* key, UErrorCode* status) {
UnicodeString result;
int32_t len = 0;
const UChar* r = ures_getStringByKey(resB, key, &len, status);
const char16_t* r = ures_getStringByKey(resB, key, &len, status);
if(U_SUCCESS(*status)) {
result.setTo(true, r, len);
} else {

10
icu4c/source/common/uniset.cpp
View file

@ -582,7 +582,7 @@ UMatchDegree UnicodeSet::matches(const Replaceable& text,
// firstChar is the leftmost char to match in the
// forward direction or the rightmost char to match in
// the reverse direction.
UChar firstChar = text.charAt(offset);
char16_t firstChar = text.charAt(offset);
// If there are multiple strings that can match we
// return the longest match.
@ -594,7 +594,7 @@ UMatchDegree UnicodeSet::matches(const Replaceable& text,
continue; // skip the empty string
}
UChar c = trial.charAt(forward ? 0 : trial.length() - 1);
char16_t c = trial.charAt(forward ? 0 : trial.length() - 1);
// Strings are sorted, so we can optimize in the
// forward direction.
@ -2161,7 +2161,7 @@ void UnicodeSet::releasePattern() {
*/
void UnicodeSet::setPattern(const char16_t *newPat, int32_t newPatLen) {
releasePattern();
pat = (UChar *)uprv_malloc((newPatLen + 1) * sizeof(UChar));
pat = (char16_t *)uprv_malloc((newPatLen + 1) * sizeof(char16_t));
if (pat) {
patLen = newPatLen;
u_memcpy(pat, newPat, patLen);
@ -2202,7 +2202,7 @@ UnicodeSet *UnicodeSet::freeze() {
return this;
}
int32_t UnicodeSet::span(const UChar *s, int32_t length, USetSpanCondition spanCondition) const {
int32_t UnicodeSet::span(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const {
if(length>0 && bmpSet!=nullptr) {
return (int32_t)(bmpSet->span(s, s+length, spanCondition)-s);
}
@ -2239,7 +2239,7 @@ int32_t UnicodeSet::span(const UChar *s, int32_t length, USetSpanCondition spanC
return prev;
}
int32_t UnicodeSet::spanBack(const UChar *s, int32_t length, USetSpanCondition spanCondition) const {
int32_t UnicodeSet::spanBack(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const {
if(length>0 && bmpSet!=nullptr) {
return (int32_t)(bmpSet->spanBack(s, s+length, spanCondition)-s);
}

6
icu4c/source/common/uniset_closure.cpp
View file

@ -123,7 +123,7 @@ _set_addRange(USet *set, UChar32 start, UChar32 end) {
}
static void U_CALLCONV
_set_addString(USet *set, const UChar *str, int32_t length) {
_set_addString(USet *set, const char16_t *str, int32_t length) {
((UnicodeSet *)set)->add(UnicodeString((UBool)(length<0), str, length));
}
@ -134,7 +134,7 @@ _set_addString(USet *set, const UChar *str, int32_t length) {
// add the result of a full case mapping to the set
// use str as a temporary string to avoid constructing one
static inline void
addCaseMapping(UnicodeSet &set, int32_t result, const UChar *full, UnicodeString &str) {
addCaseMapping(UnicodeSet &set, int32_t result, const char16_t *full, UnicodeString &str) {
if(result >= 0) {
if(result > UCASE_MAX_STRING_LENGTH) {
// add a single-code point case mapping
@ -175,7 +175,7 @@ UnicodeSet& UnicodeSet::closeOver(int32_t attribute) {
int32_t n = getRangeCount();
UChar32 result;
const UChar *full;
const char16_t *full;
for (int32_t i=0; i<n; ++i) {
UChar32 start = getRangeStart(i);

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

@ -108,7 +108,7 @@ uniset_getUnicode32Instance(UErrorCode &errorCode) {
static inline UBool
isPerlOpen(const UnicodeString &pattern, int32_t pos) {
UChar c;
char16_t c;
return pattern.charAt(pos)==u'\\' && ((c=pattern.charAt(pos+1))==u'p' || c==u'P');
}
@ -209,7 +209,7 @@ UnicodeSet::applyPatternIgnoreSpace(const UnicodeString& pattern,
*/
UBool UnicodeSet::resemblesPattern(const UnicodeString& pattern, int32_t pos) {
return ((pos+1) < pattern.length() &&
pattern.charAt(pos) == (UChar)91/*[*/) ||
pattern.charAt(pos) == (char16_t)91/*[*/) ||
resemblesPropertyPattern(pattern, pos);
}
@ -287,7 +287,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
// lastItem: 0=none, 1=char, 2=set
int8_t lastItem = 0, mode = 0;
UChar32 lastChar = 0;
UChar op = 0;
char16_t op = 0;
UBool invert = false;
@ -471,7 +471,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
case u'-':
if (op == 0) {
if (lastItem != 0) {
op = (UChar) c;
op = (char16_t) c;
continue;
} else {
// Treat final trailing '-' as a literal
@ -490,7 +490,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
return;
case u'&':
if (lastItem == 2 && op == 0) {
op = (UChar) c;
op = (char16_t) c;
continue;
}
// syntaxError(chars, "'&' not after set");
@ -561,7 +561,7 @@ void UnicodeSet::applyPattern(RuleCharacterIterator& chars,
}
add(U_ETHER);
usePat = true;
patLocal.append((UChar) SymbolTable::SYMBOL_REF);
patLocal.append((char16_t) SymbolTable::SYMBOL_REF);
patLocal.append(u']');
mode = 2;
continue;
@ -1044,7 +1044,7 @@ UnicodeSet& UnicodeSet::applyPropertyPattern(const UnicodeString& pattern,
invert = true;
}
} else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) {
UChar c = pattern.charAt(pos+1);
char16_t c = pattern.charAt(pos+1);
invert = (c == u'P');
isName = (c == u'N');
pos += 2;

40
icu4c/source/common/unisetspan.cpp
View file

@ -165,7 +165,7 @@ private:
// Get the number of UTF-8 bytes for a UTF-16 (sub)string.
static int32_t
getUTF8Length(const UChar *s, int32_t length) {
getUTF8Length(const char16_t *s, int32_t length) {
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length8=0;
u_strToUTF8(nullptr, 0, &length8, s, length, &errorCode);
@ -180,7 +180,7 @@ getUTF8Length(const UChar *s, int32_t length) {
// Append the UTF-8 version of the string to t and return the appended UTF-8 length.
static int32_t
appendUTF8(const UChar *s, int32_t length, uint8_t *t, int32_t capacity) {
appendUTF8(const char16_t *s, int32_t length, uint8_t *t, int32_t capacity) {
UErrorCode errorCode=U_ZERO_ERROR;
int32_t length8=0;
u_strToUTF8((char *)t, capacity, &length8, s, length, &errorCode);
@ -229,7 +229,7 @@ UnicodeSetStringSpan::UnicodeSetStringSpan(const UnicodeSet &set,
UBool someRelevant=false;
for(i=0; i<stringsLength; ++i) {
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
if (length16==0) {
continue; // skip the empty string
@ -312,7 +312,7 @@ UnicodeSetStringSpan::UnicodeSetStringSpan(const UnicodeSet &set,
for(i=0; i<stringsLength; ++i) {
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
spanLength=spanSet.span(s16, length16, USET_SPAN_CONTAINED);
if(spanLength<length16 && length16>0) { // Relevant string.
@ -451,7 +451,7 @@ void UnicodeSetStringSpan::addToSpanNotSet(UChar32 c) {
// Compare strings without any argument checks. Requires length>0.
static inline UBool
matches16(const UChar *s, const UChar *t, int32_t length) {
matches16(const char16_t *s, const char16_t *t, int32_t length) {
do {
if(*s++!=*t++) {
return false;
@ -474,7 +474,7 @@ matches8(const uint8_t *s, const uint8_t *t, int32_t length) {
// at code point boundaries.
// That is, each edge of a match must not be in the middle of a surrogate pair.
static inline UBool
matches16CPB(const UChar *s, int32_t start, int32_t limit, const UChar *t, int32_t length) {
matches16CPB(const char16_t *s, int32_t start, int32_t limit, const char16_t *t, int32_t length) {
s+=start;
limit-=start;
return matches16(s, t, length) &&
@ -485,8 +485,8 @@ matches16CPB(const UChar *s, int32_t start, int32_t limit, const UChar *t, int32
// Does the set contain the next code point?
// If so, return its length; otherwise return its negative length.
static inline int32_t
spanOne(const UnicodeSet &set, const UChar *s, int32_t length) {
UChar c=*s, c2;
spanOne(const UnicodeSet &set, const char16_t *s, int32_t length) {
char16_t c=*s, c2;
if(c>=0xd800 && c<=0xdbff && length>=2 && U16_IS_TRAIL(c2=s[1])) {
return set.contains(U16_GET_SUPPLEMENTARY(c, c2)) ? 2 : -2;
}
@ -494,8 +494,8 @@ spanOne(const UnicodeSet &set, const UChar *s, int32_t length) {
}
static inline int32_t
spanOneBack(const UnicodeSet &set, const UChar *s, int32_t length) {
UChar c=s[length-1], c2;
spanOneBack(const UnicodeSet &set, const char16_t *s, int32_t length) {
char16_t c=s[length-1], c2;
if(c>=0xdc00 && c<=0xdfff && length>=2 && U16_IS_LEAD(c2=s[length-2])) {
return set.contains(U16_GET_SUPPLEMENTARY(c2, c)) ? 2 : -2;
}
@ -634,7 +634,7 @@ spanOneBackUTF8(const UnicodeSet &set, const uint8_t *s, int32_t length) {
* Stop if spanLength==0, otherwise continue the loop.
*/
int32_t UnicodeSetStringSpan::span(const UChar *s, int32_t length, USetSpanCondition spanCondition) const {
int32_t UnicodeSetStringSpan::span(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const {
if(spanCondition==USET_SPAN_NOT_CONTAINED) {
return spanNot(s, length);
}
@ -659,7 +659,7 @@ int32_t UnicodeSetStringSpan::span(const UChar *s, int32_t length, USetSpanCondi
continue; // Irrelevant string. (Also the empty string.)
}
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
U_ASSERT(length>0);
@ -699,7 +699,7 @@ int32_t UnicodeSetStringSpan::span(const UChar *s, int32_t length, USetSpanCondi
// to find the match from the earliest start.
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
if (length16==0) {
continue; // skip the empty string
@ -798,7 +798,7 @@ int32_t UnicodeSetStringSpan::span(const UChar *s, int32_t length, USetSpanCondi
}
}
int32_t UnicodeSetStringSpan::spanBack(const UChar *s, int32_t length, USetSpanCondition spanCondition) const {
int32_t UnicodeSetStringSpan::spanBack(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const {
if(spanCondition==USET_SPAN_NOT_CONTAINED) {
return spanNotBack(s, length);
}
@ -827,7 +827,7 @@ int32_t UnicodeSetStringSpan::spanBack(const UChar *s, int32_t length, USetSpanC
continue; // Irrelevant string. (Also the empty string.)
}
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
U_ASSERT(length>0);
@ -869,7 +869,7 @@ int32_t UnicodeSetStringSpan::spanBack(const UChar *s, int32_t length, USetSpanC
// to find the match from the latest end.
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
if (length16==0) {
continue; // skip the empty string
@ -1346,7 +1346,7 @@ int32_t UnicodeSetStringSpan::spanBackUTF8(const uint8_t *s, int32_t length, USe
* when there is not actually a match for such a set string.
*/
int32_t UnicodeSetStringSpan::spanNot(const UChar *s, int32_t length) const {
int32_t UnicodeSetStringSpan::spanNot(const char16_t *s, int32_t length) const {
int32_t pos=0, rest=length;
int32_t i, stringsLength=strings.size();
do {
@ -1372,7 +1372,7 @@ int32_t UnicodeSetStringSpan::spanNot(const UChar *s, int32_t length) const {
continue; // Irrelevant string. (Also the empty string.)
}
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
U_ASSERT(length>0);
if(length16<=rest && matches16CPB(s, pos, length, s16, length16)) {
@ -1389,7 +1389,7 @@ int32_t UnicodeSetStringSpan::spanNot(const UChar *s, int32_t length) const {
return length; // Reached the end of the string.
}
int32_t UnicodeSetStringSpan::spanNotBack(const UChar *s, int32_t length) const {
int32_t UnicodeSetStringSpan::spanNotBack(const char16_t *s, int32_t length) const {
int32_t pos=length;
int32_t i, stringsLength=strings.size();
do {
@ -1416,7 +1416,7 @@ int32_t UnicodeSetStringSpan::spanNotBack(const UChar *s, int32_t length) const
continue; // Irrelevant string. (Also the empty string.)
}
const UnicodeString &string=*(const UnicodeString *)strings.elementAt(i);
const UChar *s16=string.getBuffer();
const char16_t *s16=string.getBuffer();
int32_t length16=string.length();
U_ASSERT(length>0);
if(length16<=pos && matches16CPB(s, pos-length16, length, s16, length16)) {

8
icu4c/source/common/unisetspan.h
View file

@ -74,9 +74,9 @@ public:
// For fast UnicodeSet::contains(c).
inline UBool contains(UChar32 c) const;
int32_t span(const UChar *s, int32_t length, USetSpanCondition spanCondition) const;
int32_t span(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const;
int32_t spanBack(const UChar *s, int32_t length, USetSpanCondition spanCondition) const;
int32_t spanBack(const char16_t *s, int32_t length, USetSpanCondition spanCondition) const;
int32_t spanUTF8(const uint8_t *s, int32_t length, USetSpanCondition spanCondition) const;
@ -95,8 +95,8 @@ private:
// so that a character span ends before any string.
void addToSpanNotSet(UChar32 c);
int32_t spanNot(const UChar *s, int32_t length) const;
int32_t spanNotBack(const UChar *s, int32_t length) const;
int32_t spanNot(const char16_t *s, int32_t length) const;
int32_t spanNotBack(const char16_t *s, int32_t length) const;
int32_t spanNotUTF8(const uint8_t *s, int32_t length) const;
int32_t spanNotBackUTF8(const uint8_t *s, int32_t length) const;

180
icu4c/source/common/unistr.cpp
View file

@ -44,7 +44,7 @@ void
print(const UnicodeString& s,
const char *name)
{
UChar c;
char16_t c;
cout << name << ":|";
for(int i = 0; i < s.length(); ++i) {
c = s[i];
@ -57,11 +57,11 @@ print(const UnicodeString& s,
}
void
print(const UChar *s,
print(const char16_t *s,
int32_t len,
const char *name)
{
UChar c;
char16_t c;
cout << name << ":|";
for(int i = 0; i < len; ++i) {
c = s[i];
@ -80,17 +80,17 @@ print(const UChar *s,
// 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)
us_arrayCopy(const char16_t *src, int32_t srcStart,
char16_t *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_unescapeAt() callback to get a char16_t from a UnicodeString
U_CDECL_BEGIN
static UChar U_CALLCONV
static char16_t U_CALLCONV
UnicodeString_charAt(int32_t offset, void *context) {
return ((icu::UnicodeString*) context)->charAt(offset);
}
@ -159,8 +159,8 @@ UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) {
capacity = length;
}
if(allocate(capacity)) {
UChar *array = getArrayStart();
UChar unit = (UChar)c;
char16_t *array = getArrayStart();
char16_t unit = (char16_t)c;
for(int32_t i = 0; i < length; ++i) {
array[i] = unit;
}
@ -177,9 +177,9 @@ UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) {
capacity = length;
}
if(allocate(capacity)) {
UChar *array = getArrayStart();
UChar lead = U16_LEAD(c);
UChar trail = U16_TRAIL(c);
char16_t *array = getArrayStart();
char16_t lead = U16_LEAD(c);
char16_t trail = U16_TRAIL(c);
for(int32_t i = 0; i < length; i += 2) {
array[i] = lead;
array[i + 1] = trail;
@ -189,7 +189,7 @@ UnicodeString::UnicodeString(int32_t capacity, UChar32 c, int32_t count) {
}
}
UnicodeString::UnicodeString(UChar ch) {
UnicodeString::UnicodeString(char16_t ch) {
fUnion.fFields.fLengthAndFlags = kLength1 | kShortString;
fUnion.fStackFields.fBuffer[0] = ch;
}
@ -206,12 +206,12 @@ UnicodeString::UnicodeString(UChar32 ch) {
}
}
UnicodeString::UnicodeString(const UChar *text) {
UnicodeString::UnicodeString(const char16_t *text) {
fUnion.fFields.fLengthAndFlags = kShortString;
doAppend(text, 0, -1);
}
UnicodeString::UnicodeString(const UChar *text,
UnicodeString::UnicodeString(const char16_t *text,
int32_t textLength) {
fUnion.fFields.fLengthAndFlags = kShortString;
doAppend(text, 0, textLength);
@ -221,7 +221,7 @@ UnicodeString::UnicodeString(UBool isTerminated,
ConstChar16Ptr textPtr,
int32_t textLength) {
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
const UChar *text = textPtr;
const char16_t *text = textPtr;
if(text == nullptr) {
// treat as an empty string, do not alias
setToEmpty();
@ -235,12 +235,12 @@ UnicodeString::UnicodeString(UBool isTerminated,
// text is terminated, or else it would have failed the above test
textLength = u_strlen(text);
}
setArray(const_cast<UChar *>(text), textLength,
setArray(const_cast<char16_t *>(text), textLength,
isTerminated ? textLength + 1 : textLength);
}
}
UnicodeString::UnicodeString(UChar *buff,
UnicodeString::UnicodeString(char16_t *buff,
int32_t buffLength,
int32_t buffCapacity) {
fUnion.fFields.fLengthAndFlags = kWritableAlias;
@ -252,7 +252,7 @@ UnicodeString::UnicodeString(UChar *buff,
} else {
if(buffLength == -1) {
// fLength = u_strlen(buff); but do not look beyond buffCapacity
const UChar *p = buff, *limit = buff + buffCapacity;
const char16_t *p = buff, *limit = buff + buffCapacity;
while(p != limit && *p != 0) {
++p;
}
@ -385,8 +385,8 @@ UnicodeString::allocate(int32_t capacity) {
*array++ = 1;
numBytes -= sizeof(int32_t);
// have fArray point to the first UChar
fUnion.fFields.fArray = (UChar *)array;
// have fArray point to the first char16_t
fUnion.fFields.fArray = (char16_t *)array;
fUnion.fFields.fCapacity = (int32_t)(numBytes / U_SIZEOF_UCHAR);
fUnion.fFields.fLengthAndFlags = kLongString;
return true;
@ -460,7 +460,7 @@ UnicodeString UnicodeString::fromUTF32(const UChar32 *utf32, int32_t length) {
capacity = length + (length >> 4) + 4;
}
do {
UChar *utf16 = result.getBuffer(capacity);
char16_t *utf16 = result.getBuffer(capacity);
int32_t length16;
UErrorCode errorCode = U_ZERO_ERROR;
u_strFromUTF32WithSub(utf16, result.getCapacity(), &length16,
@ -626,7 +626,7 @@ UnicodeString UnicodeString::unescape() const {
if (result.isBogus()) {
return result;
}
const UChar *array = getBuffer();
const char16_t *array = getBuffer();
int32_t len = length();
int32_t prev = 0;
for (int32_t i=0;;) {
@ -665,7 +665,7 @@ UnicodeString::doEquals(const UnicodeString &text, int32_t len) const {
int8_t
UnicodeString::doCompare( int32_t start,
int32_t length,
const UChar *srcChars,
const char16_t *srcChars,
int32_t srcStart,
int32_t srcLength) const
{
@ -678,12 +678,12 @@ UnicodeString::doCompare( int32_t start,
pinIndices(start, length);
if(srcChars == nullptr) {
// treat const UChar *srcChars==nullptr as an empty string
// treat const char16_t *srcChars==nullptr as an empty string
return length == 0 ? 0 : 1;
}
// get the correct pointer
const UChar *chars = getArrayStart();
const char16_t *chars = getArrayStart();
chars += start;
srcChars += srcStart;
@ -723,12 +723,12 @@ UnicodeString::doCompare( int32_t start,
# if U_IS_BIG_ENDIAN
// big-endian: byte comparison works
result = uprv_memcmp(chars, srcChars, minLength * sizeof(UChar));
result = uprv_memcmp(chars, srcChars, minLength * sizeof(char16_t));
if(result != 0) {
return (int8_t)(result >> 15 | 1);
}
# else
// little-endian: compare UChar units
// little-endian: compare char16_t units
do {
result = ((int32_t)*(chars++) - (int32_t)*(srcChars++));
if(result != 0) {
@ -744,12 +744,12 @@ UnicodeString::doCompare( int32_t start,
int8_t
UnicodeString::doCompareCodePointOrder(int32_t start,
int32_t length,
const UChar *srcChars,
const char16_t *srcChars,
int32_t srcStart,
int32_t srcLength) const
{
// compare illegal string values
// treat const UChar *srcChars==nullptr as an empty string
// treat const char16_t *srcChars==nullptr as an empty string
if(isBogus()) {
return -1;
}
@ -775,7 +775,7 @@ UnicodeString::getLength() const {
return length();
}
UChar
char16_t
UnicodeString::getCharAt(int32_t offset) const {
return charAt(offset);
}
@ -790,7 +790,7 @@ UnicodeString::char32At(int32_t offset) const
{
int32_t len = length();
if((uint32_t)offset < (uint32_t)len) {
const UChar *array = getArrayStart();
const char16_t *array = getArrayStart();
UChar32 c;
U16_GET(array, 0, offset, len, c);
return c;
@ -802,7 +802,7 @@ UnicodeString::char32At(int32_t offset) const
int32_t
UnicodeString::getChar32Start(int32_t offset) const {
if((uint32_t)offset < (uint32_t)length()) {
const UChar *array = getArrayStart();
const char16_t *array = getArrayStart();
U16_SET_CP_START(array, 0, offset);
return offset;
} else {
@ -814,7 +814,7 @@ int32_t
UnicodeString::getChar32Limit(int32_t offset) const {
int32_t len = length();
if((uint32_t)offset < (uint32_t)len) {
const UChar *array = getArrayStart();
const char16_t *array = getArrayStart();
U16_SET_CP_LIMIT(array, 0, offset, len);
return offset;
} else {
@ -846,7 +846,7 @@ UnicodeString::moveIndex32(int32_t index, int32_t delta) const {
index=len;
}
const UChar *array = getArrayStart();
const char16_t *array = getArrayStart();
if(delta>0) {
U16_FWD_N(array, index, len, delta);
} else {
@ -859,14 +859,14 @@ UnicodeString::moveIndex32(int32_t index, int32_t delta) const {
void
UnicodeString::doExtract(int32_t start,
int32_t length,
UChar *dst,
char16_t *dst,
int32_t dstStart) const
{
// pin indices to legal values
pinIndices(start, length);
// do not copy anything if we alias dst itself
const UChar *array = getArrayStart();
const char16_t *array = getArrayStart();
if(array + start != dst + dstStart) {
us_arrayCopy(array, start, dst, dstStart, length);
}
@ -880,7 +880,7 @@ UnicodeString::extract(Char16Ptr dest, int32_t destCapacity,
if(isBogus() || destCapacity<0 || (destCapacity>0 && dest==0)) {
errorCode=U_ILLEGAL_ARGUMENT_ERROR;
} else {
const UChar *array = getArrayStart();
const char16_t *array = getArrayStart();
if(len>0 && len<=destCapacity && array!=dest) {
u_memcpy(dest, array, len);
}
@ -916,7 +916,7 @@ UnicodeString::extract(int32_t start,
UnicodeString
UnicodeString::tempSubString(int32_t start, int32_t len) const {
pinIndices(start, len);
const UChar *array = getBuffer(); // not getArrayStart() to check kIsBogus & kOpenGetBuffer
const char16_t *array = getBuffer(); // not getArrayStart() to check kIsBogus & kOpenGetBuffer
if(array==nullptr) {
array=fUnion.fStackFields.fBuffer; // anything not nullptr because that would make an empty string
len=-2; // bogus result string
@ -1023,7 +1023,7 @@ UnicodeString::toUTF32(UChar32 *utf32, int32_t capacity, UErrorCode &errorCode)
}
int32_t
UnicodeString::indexOf(const UChar *srcChars,
UnicodeString::indexOf(const char16_t *srcChars,
int32_t srcStart,
int32_t srcLength,
int32_t start,
@ -1042,8 +1042,8 @@ UnicodeString::indexOf(const UChar *srcChars,
pinIndices(start, length);
// find the first occurrence of the substring
const UChar *array = getArrayStart();
const UChar *match = u_strFindFirst(array + start, length, srcChars + srcStart, srcLength);
const char16_t *array = getArrayStart();
const char16_t *match = u_strFindFirst(array + start, length, srcChars + srcStart, srcLength);
if(match == nullptr) {
return -1;
} else {
@ -1052,7 +1052,7 @@ UnicodeString::indexOf(const UChar *srcChars,
}
int32_t
UnicodeString::doIndexOf(UChar c,
UnicodeString::doIndexOf(char16_t c,
int32_t start,
int32_t length) const
{
@ -1060,8 +1060,8 @@ UnicodeString::doIndexOf(UChar c,
pinIndices(start, length);
// find the first occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memchr(array + start, c, length);
const char16_t *array = getArrayStart();
const char16_t *match = u_memchr(array + start, c, length);
if(match == nullptr) {
return -1;
} else {
@ -1077,8 +1077,8 @@ UnicodeString::doIndexOf(UChar32 c,
pinIndices(start, length);
// find the first occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memchr32(array + start, c, length);
const char16_t *array = getArrayStart();
const char16_t *match = u_memchr32(array + start, c, length);
if(match == nullptr) {
return -1;
} else {
@ -1087,7 +1087,7 @@ UnicodeString::doIndexOf(UChar32 c,
}
int32_t
UnicodeString::lastIndexOf(const UChar *srcChars,
UnicodeString::lastIndexOf(const char16_t *srcChars,
int32_t srcStart,
int32_t srcLength,
int32_t start,
@ -1106,8 +1106,8 @@ UnicodeString::lastIndexOf(const UChar *srcChars,
pinIndices(start, length);
// find the last occurrence of the substring
const UChar *array = getArrayStart();
const UChar *match = u_strFindLast(array + start, length, srcChars + srcStart, srcLength);
const char16_t *array = getArrayStart();
const char16_t *match = u_strFindLast(array + start, length, srcChars + srcStart, srcLength);
if(match == nullptr) {
return -1;
} else {
@ -1116,7 +1116,7 @@ UnicodeString::lastIndexOf(const UChar *srcChars,
}
int32_t
UnicodeString::doLastIndexOf(UChar c,
UnicodeString::doLastIndexOf(char16_t c,
int32_t start,
int32_t length) const
{
@ -1128,8 +1128,8 @@ UnicodeString::doLastIndexOf(UChar c,
pinIndices(start, length);
// find the last occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memrchr(array + start, c, length);
const char16_t *array = getArrayStart();
const char16_t *match = u_memrchr(array + start, c, length);
if(match == nullptr) {
return -1;
} else {
@ -1145,8 +1145,8 @@ UnicodeString::doLastIndexOf(UChar32 c,
pinIndices(start, length);
// find the last occurrence of c
const UChar *array = getArrayStart();
const UChar *match = u_memrchr32(array + start, c, length);
const char16_t *array = getArrayStart();
const char16_t *match = u_memrchr32(array + start, c, length);
if(match == nullptr) {
return -1;
} else {
@ -1220,7 +1220,7 @@ UnicodeString::getTerminatedBuffer() {
if(!isWritable()) {
return nullptr;
}
UChar *array = getArrayStart();
char16_t *array = getArrayStart();
int32_t len = length();
if(len < getCapacity()) {
if(fUnion.fFields.fLengthAndFlags & kBufferIsReadonly) {
@ -1264,7 +1264,7 @@ UnicodeString::setTo(UBool isTerminated,
return *this;
}
const UChar *text = textPtr;
const char16_t *text = textPtr;
if(text == nullptr) {
// treat as an empty string, do not alias
releaseArray();
@ -1287,13 +1287,13 @@ UnicodeString::setTo(UBool isTerminated,
textLength = u_strlen(text);
}
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);
setArray((char16_t *)text, textLength, isTerminated ? textLength + 1 : textLength);
return *this;
}
// setTo() analogous to the writable-aliasing constructor with the same signature
UnicodeString &
UnicodeString::setTo(UChar *buffer,
UnicodeString::setTo(char16_t *buffer,
int32_t buffLength,
int32_t buffCapacity) {
if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
@ -1313,7 +1313,7 @@ UnicodeString::setTo(UChar *buffer,
return *this;
} else if(buffLength == -1) {
// buffLength = u_strlen(buff); but do not look beyond buffCapacity
const UChar *p = buffer, *limit = buffer + buffCapacity;
const char16_t *p = buffer, *limit = buffer + buffCapacity;
while(p != limit && *p != 0) {
++p;
}
@ -1337,7 +1337,7 @@ UnicodeString &UnicodeString::setToUTF8(StringPiece utf8) {
} else {
capacity = length + 1; // +1 for the terminating NUL.
}
UChar *utf16 = getBuffer(capacity);
char16_t *utf16 = getBuffer(capacity);
int32_t length16;
UErrorCode errorCode = U_ZERO_ERROR;
u_strFromUTF8WithSub(utf16, getCapacity(), &length16,
@ -1354,7 +1354,7 @@ UnicodeString &UnicodeString::setToUTF8(StringPiece utf8) {
UnicodeString&
UnicodeString::setCharAt(int32_t offset,
UChar c)
char16_t c)
{
int32_t len = length();
if(cloneArrayIfNeeded() && len > 0) {
@ -1373,7 +1373,7 @@ UnicodeString&
UnicodeString::replace(int32_t start,
int32_t _length,
UChar32 srcChar) {
UChar buffer[U16_MAX_LENGTH];
char16_t buffer[U16_MAX_LENGTH];
int32_t count = 0;
UBool isError = false;
U16_APPEND(buffer, count, U16_MAX_LENGTH, srcChar, isError);
@ -1385,7 +1385,7 @@ UnicodeString::replace(int32_t start,
UnicodeString&
UnicodeString::append(UChar32 srcChar) {
UChar buffer[U16_MAX_LENGTH];
char16_t buffer[U16_MAX_LENGTH];
int32_t _length = 0;
UBool isError = false;
U16_APPEND(buffer, _length, U16_MAX_LENGTH, srcChar, isError);
@ -1412,7 +1412,7 @@ UnicodeString::doReplace( int32_t start,
UnicodeString&
UnicodeString::doReplace(int32_t start,
int32_t length,
const UChar *srcChars,
const char16_t *srcChars,
int32_t srcStart,
int32_t srcLength)
{
@ -1471,7 +1471,7 @@ UnicodeString::doReplace(int32_t start,
newLength += srcLength;
// Check for insertion into ourself
const UChar *oldArray = getArrayStart();
const char16_t *oldArray = getArrayStart();
if (isBufferWritable() &&
oldArray < srcChars + srcLength &&
srcChars < oldArray + oldLength) {
@ -1486,7 +1486,7 @@ UnicodeString::doReplace(int32_t start,
// cloneArrayIfNeeded(doCopyArray=false) may change fArray but will not copy the current contents;
// therefore we need to keep the current fArray
UChar oldStackBuffer[US_STACKBUF_SIZE];
char16_t oldStackBuffer[US_STACKBUF_SIZE];
if((fUnion.fFields.fLengthAndFlags&kUsingStackBuffer) && (newLength > US_STACKBUF_SIZE)) {
// copy the stack buffer contents because it will be overwritten with
// fUnion.fFields values
@ -1504,7 +1504,7 @@ UnicodeString::doReplace(int32_t start,
// now do the replace
UChar *newArray = getArrayStart();
char16_t *newArray = getArrayStart();
if(newArray != oldArray) {
// if fArray changed, then we need to copy everything except what will change
us_arrayCopy(oldArray, 0, newArray, 0, start);
@ -1547,7 +1547,7 @@ UnicodeString::doAppend(const UnicodeString& src, int32_t srcStart, int32_t srcL
}
UnicodeString&
UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLength) {
UnicodeString::doAppend(const char16_t *srcChars, int32_t srcStart, int32_t srcLength) {
if(!isWritable() || srcLength == 0 || srcChars == nullptr) {
return *this;
}
@ -1571,7 +1571,7 @@ UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLeng
}
// Check for append onto ourself
const UChar* oldArray = getArrayStart();
const char16_t* oldArray = getArrayStart();
if (isBufferWritable() &&
oldArray < srcChars + srcLength &&
srcChars < oldArray + oldLength) {
@ -1587,9 +1587,9 @@ UnicodeString::doAppend(const UChar *srcChars, int32_t srcStart, int32_t srcLeng
// optimize append() onto a large-enough, owned string
if((newLength <= getCapacity() && isBufferWritable()) ||
cloneArrayIfNeeded(newLength, getGrowCapacity(newLength))) {
UChar *newArray = getArrayStart();
char16_t *newArray = getArrayStart();
// Do not copy characters when
// UChar *buffer=str.getAppendBuffer(...);
// char16_t *buffer=str.getAppendBuffer(...);
// is followed by
// str.append(buffer, length);
// or
@ -1621,7 +1621,7 @@ 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) );
char16_t* text = (char16_t*) uprv_malloc( sizeof(char16_t) * (limit - start) );
// Check to make sure text is not null.
if (text != nullptr) {
extractBetween(start, limit, text, 0);
@ -1659,9 +1659,9 @@ UnicodeString::doReverse(int32_t start, int32_t length) {
return *this;
}
UChar *left = getArrayStart() + start;
UChar *right = left + length - 1; // -1 for inclusive boundary (length>=2)
UChar swap;
char16_t *left = getArrayStart() + start;
char16_t *right = left + length - 1; // -1 for inclusive boundary (length>=2)
char16_t swap;
UBool hasSupplementary = false;
// Before the loop we know left<right because length>=2.
@ -1676,7 +1676,7 @@ UnicodeString::doReverse(int32_t start, int32_t length) {
/* if there are supplementary code points in the reversed range, then re-swap their surrogates */
if(hasSupplementary) {
UChar swap2;
char16_t swap2;
left = getArrayStart() + start;
right = left + length - 1; // -1 so that we can look at *(left+1) if left<right
@ -1695,14 +1695,14 @@ UnicodeString::doReverse(int32_t start, int32_t length) {
UBool
UnicodeString::padLeading(int32_t targetLength,
UChar padChar)
char16_t padChar)
{
int32_t oldLength = length();
if(oldLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
return false;
} else {
// move contents up by padding width
UChar *array = getArrayStart();
char16_t *array = getArrayStart();
int32_t start = targetLength - oldLength;
us_arrayCopy(array, 0, array, start, oldLength);
@ -1717,14 +1717,14 @@ UnicodeString::padLeading(int32_t targetLength,
UBool
UnicodeString::padTrailing(int32_t targetLength,
UChar padChar)
char16_t padChar)
{
int32_t oldLength = length();
if(oldLength >= targetLength || !cloneArrayIfNeeded(targetLength)) {
return false;
} else {
// fill in padding character
UChar *array = getArrayStart();
char16_t *array = getArrayStart();
int32_t length = targetLength;
while(--length >= oldLength) {
array[length] = padChar;
@ -1741,7 +1741,7 @@ int32_t
UnicodeString::doHashCode() const
{
/* Delegate hash computation to uhash. This makes UnicodeString
* hashing consistent with UChar* hashing. */
* hashing consistent with char16_t* hashing. */
int32_t hashCode = ustr_hashUCharsN(getArrayStart(), length());
if (hashCode == kInvalidHashCode) {
hashCode = kEmptyHashCode;
@ -1771,7 +1771,7 @@ UnicodeString::releaseBuffer(int32_t newLength) {
int32_t capacity=getCapacity();
if(newLength==-1) {
// the new length is the string length, capped by fCapacity
const UChar *array=getArrayStart(), *p=array, *limit=array+capacity;
const char16_t *array=getArrayStart(), *p=array, *limit=array+capacity;
while(p<limit && *p!=0) {
++p;
}
@ -1826,8 +1826,8 @@ UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
}
// save old values
UChar oldStackBuffer[US_STACKBUF_SIZE];
UChar *oldArray;
char16_t oldStackBuffer[US_STACKBUF_SIZE];
char16_t *oldArray;
int32_t oldLength = length();
int16_t flags = fUnion.fFields.fLengthAndFlags;
@ -1901,13 +1901,13 @@ UnicodeString::cloneArrayIfNeeded(int32_t newCapacity,
UnicodeStringAppendable::~UnicodeStringAppendable() {}
UBool
UnicodeStringAppendable::appendCodeUnit(UChar c) {
UnicodeStringAppendable::appendCodeUnit(char16_t c) {
return str.doAppend(&c, 0, 1).isWritable();
}
UBool
UnicodeStringAppendable::appendCodePoint(UChar32 c) {
UChar buffer[U16_MAX_LENGTH];
char16_t buffer[U16_MAX_LENGTH];
int32_t cLength = 0;
UBool isError = false;
U16_APPEND(buffer, cLength, U16_MAX_LENGTH, c, isError);
@ -1915,7 +1915,7 @@ UnicodeStringAppendable::appendCodePoint(UChar32 c) {
}
UBool
UnicodeStringAppendable::appendString(const UChar *s, int32_t length) {
UnicodeStringAppendable::appendString(const char16_t *s, int32_t length) {
return str.doAppend(s, 0, length).isWritable();
}
@ -1924,10 +1924,10 @@ UnicodeStringAppendable::reserveAppendCapacity(int32_t appendCapacity) {
return str.cloneArrayIfNeeded(str.length() + appendCapacity);
}
UChar *
char16_t *
UnicodeStringAppendable::getAppendBuffer(int32_t minCapacity,
int32_t desiredCapacityHint,
UChar *scratch, int32_t scratchCapacity,
char16_t *scratch, int32_t scratchCapacity,
int32_t *resultCapacity) {
if(minCapacity < 1 || scratchCapacity < minCapacity) {
*resultCapacity = 0;

14
icu4c/source/common/unistr_case.cpp
View file

@ -41,13 +41,13 @@ U_NAMESPACE_BEGIN
int8_t
UnicodeString::doCaseCompare(int32_t start,
int32_t length,
const UChar *srcChars,
const char16_t *srcChars,
int32_t srcStart,
int32_t srcLength,
uint32_t options) const
{
// compare illegal string values
// treat const UChar *srcChars==nullptr as an empty string
// treat const char16_t *srcChars==nullptr as an empty string
if(isBogus()) {
return -1;
}
@ -60,7 +60,7 @@ UnicodeString::doCaseCompare(int32_t start,
}
// get the correct pointer
const UChar *chars = getArrayStart();
const char16_t *chars = getArrayStart();
chars += start;
if(srcStart!=0) {
@ -98,8 +98,8 @@ UnicodeString::caseMap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITER
return *this;
}
UChar oldBuffer[2 * US_STACKBUF_SIZE];
UChar *oldArray;
char16_t oldBuffer[2 * US_STACKBUF_SIZE];
char16_t *oldArray;
int32_t oldLength = length();
int32_t newLength;
UBool writable = isBufferWritable();
@ -115,7 +115,7 @@ UnicodeString::caseMap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITER
if (writable ? oldLength <= UPRV_LENGTHOF(oldBuffer) : oldLength < US_STACKBUF_SIZE) {
// Short string: Copy the contents into a temporary buffer and
// case-map back into the current array, or into the stack buffer.
UChar *buffer = getArrayStart();
char16_t *buffer = getArrayStart();
int32_t capacity;
oldArray = oldBuffer;
u_memcpy(oldBuffer, buffer, oldLength);
@ -155,7 +155,7 @@ UnicodeString::caseMap(int32_t caseLocale, uint32_t options, UCASEMAP_BREAK_ITER
// and often does not change its length.
oldArray = getArrayStart();
Edits edits;
UChar replacementChars[200];
char16_t replacementChars[200];
#if !UCONFIG_NO_BREAK_ITERATION
if (iter != nullptr) {
oldString.setTo(false, oldArray, oldLength);

8
icu4c/source/common/unistr_cnv.cpp
View file

@ -259,7 +259,7 @@ UnicodeString::doExtract(int32_t start, int32_t length,
return 0;
}
const UChar *src=getArrayStart()+start, *srcLimit=src+length;
const char16_t *src=getArrayStart()+start, *srcLimit=src+length;
char *originalDest=dest;
const char *destLimit;
@ -366,7 +366,7 @@ UnicodeString::doCodepageCreate(const char *codepageData,
// set up the conversion parameters
const char *mySource = codepageData;
const char *mySourceEnd = mySource + dataLength;
UChar *array, *myTarget;
char16_t *array, *myTarget;
// estimate the size needed:
int32_t arraySize;
@ -374,7 +374,7 @@ UnicodeString::doCodepageCreate(const char *codepageData,
// try to use the stack buffer
arraySize = US_STACKBUF_SIZE;
} else {
// 1.25 UChar's per source byte should cover most cases
// 1.25 char16_t's per source byte should cover most cases
arraySize = dataLength + (dataLength >> 2);
}
@ -404,7 +404,7 @@ UnicodeString::doCodepageCreate(const char *codepageData,
doCopyArray = true;
// estimate the new size needed, larger than before
// try 2 UChar's per remaining source byte
// try 2 char16_t's per remaining source byte
arraySize = (int32_t)(length() + 2 * (mySourceEnd - mySource));
} else {
break;

2
icu4c/source/common/unistr_props.cpp
View file

@ -32,7 +32,7 @@ UnicodeString::trim()
return *this;
}
UChar *array = getArrayStart();
char16_t *array = getArrayStart();
UChar32 c;
int32_t oldLength = this->length();
int32_t i = oldLength, length;

Some files were not shown because too many files have changed in this diff Show more