mirror of
https://github.com/unicode-org/icu.git
synced 2025-04-06 22:15:31 +00:00
ICU-12766 merge from trunk
X-SVN-Rev: 39808
This commit is contained in:
Steven R. Loomis
commit
803210153a
83 changed files with 1177 additions and 741 deletions
|
|
@ -311,12 +311,12 @@ void U_EXPORT2 CanonicalIterator::permute(UnicodeString &source, UBool skipZeros
|
|||
|
||||
// see what the permutations of the characters before and after this one are
|
||||
//Hashtable *subpermute = permute(source.substring(0,i) + source.substring(i + UTF16.getCharCount(cp)));
|
||||
permute(subPermuteString.replace(i, U16_LENGTH(cp), NULL, 0), skipZeros, &subpermute, status);
|
||||
permute(subPermuteString.remove(i, U16_LENGTH(cp)), skipZeros, &subpermute, status);
|
||||
/* Test for buffer overflows */
|
||||
if(U_FAILURE(status)) {
|
||||
return;
|
||||
}
|
||||
// The upper replace is destructive. The question is do we have to make a copy, or we don't care about the contents
|
||||
// The upper remove is destructive. The question is do we have to make a copy, or we don't care about the contents
|
||||
// of source at this point.
|
||||
|
||||
// prefix this character to all of them
|
||||
|
|
|
|||
|
|
@ -1530,6 +1530,20 @@
|
|||
</Command>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\..\include\unicode\%(Filename)%(Extension);%(Outputs)</Outputs>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">copy "%(FullPath)" ..\..\include\unicode
|
||||
</Command>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\..\include\unicode\%(Filename)%(Extension);%(Outputs)</Outputs>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="unicode\char16ptr.h">
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">copy "%(FullPath)" ..\..\include\unicode
|
||||
</Command>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">..\..\include\unicode\%(Filename)%(Extension);%(Outputs)</Outputs>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">copy "%(FullPath)" ..\..\include\unicode
|
||||
</Command>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">..\..\include\unicode\%(Filename)%(Extension);%(Outputs)</Outputs>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">copy "%(FullPath)" ..\..\include\unicode
|
||||
</Command>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">..\..\include\unicode\%(Filename)%(Extension);%(Outputs)</Outputs>
|
||||
<Command Condition="'$(Configuration)|$(Platform)'=='Release|x64'">copy "%(FullPath)" ..\..\include\unicode
|
||||
</Command>
|
||||
<Outputs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">..\..\include\unicode\%(Filename)%(Extension);%(Outputs)</Outputs>
|
||||
</CustomBuild>
|
||||
|
|
|
|||
|
|
@ -1105,6 +1105,9 @@
|
|||
<CustomBuild Include="unicode\casemap.h">
|
||||
<Filter>strings</Filter>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="unicode\char16ptr.h">
|
||||
<Filter>strings</Filter>
|
||||
</CustomBuild>
|
||||
<CustomBuild Include="unicode\chariter.h">
|
||||
<Filter>strings</Filter>
|
||||
</CustomBuild>
|
||||
|
|
|
|||
|
|
@ -232,6 +232,7 @@ Normalizer2::getInstance(const char *packageName,
|
|||
}
|
||||
}
|
||||
if(allModes==NULL) {
|
||||
ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
|
||||
LocalPointer<Norm2AllModes> localAllModes(
|
||||
Norm2AllModes::createInstance(packageName, name, errorCode));
|
||||
if(U_SUCCESS(errorCode)) {
|
||||
|
|
|
|||
|
|
@ -176,7 +176,7 @@ public:
|
|||
lastCC=0;
|
||||
}
|
||||
void copyReorderableSuffixTo(UnicodeString &s) const {
|
||||
s.setTo(reorderStart, (int32_t)(limit-reorderStart));
|
||||
s.setTo(ConstChar16Ptr(reorderStart), (int32_t)(limit-reorderStart));
|
||||
}
|
||||
private:
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -40,7 +40,7 @@ Normalizer::Normalizer(const UnicodeString& str, UNormalizationMode mode) :
|
|||
init();
|
||||
}
|
||||
|
||||
Normalizer::Normalizer(const UChar *str, int32_t length, UNormalizationMode mode) :
|
||||
Normalizer::Normalizer(ConstChar16Ptr str, int32_t length, UNormalizationMode mode) :
|
||||
UObject(), fFilteredNorm2(NULL), fNorm2(NULL), fUMode(mode), fOptions(0),
|
||||
text(new UCharCharacterIterator(str, length)),
|
||||
currentIndex(0), nextIndex(0),
|
||||
|
|
@ -435,7 +435,7 @@ Normalizer::setText(const CharacterIterator& newText,
|
|||
}
|
||||
|
||||
void
|
||||
Normalizer::setText(const UChar* newText,
|
||||
Normalizer::setText(ConstChar16Ptr newText,
|
||||
int32_t length,
|
||||
UErrorCode &status)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -175,7 +175,8 @@ UCharsTrie::next(int32_t uchar) {
|
|||
}
|
||||
|
||||
UStringTrieResult
|
||||
UCharsTrie::next(const UChar *s, int32_t sLength) {
|
||||
UCharsTrie::next(ConstChar16Ptr ptr, int32_t sLength) {
|
||||
const UChar *s=ptr;
|
||||
if(sLength<0 ? *s==0 : sLength==0) {
|
||||
// Empty input.
|
||||
return current();
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@
|
|||
|
||||
U_NAMESPACE_BEGIN
|
||||
|
||||
UCharsTrie::Iterator::Iterator(const UChar *trieUChars, int32_t maxStringLength,
|
||||
UCharsTrie::Iterator::Iterator(ConstChar16Ptr trieUChars, int32_t maxStringLength,
|
||||
UErrorCode &errorCode)
|
||||
: uchars_(trieUChars),
|
||||
pos_(uchars_), initialPos_(uchars_),
|
||||
|
|
|
|||
|
|
@ -25,14 +25,14 @@ UCharCharacterIterator::UCharCharacterIterator()
|
|||
// never default construct!
|
||||
}
|
||||
|
||||
UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
|
||||
UCharCharacterIterator::UCharCharacterIterator(ConstChar16Ptr textPtr,
|
||||
int32_t length)
|
||||
: CharacterIterator(textPtr != 0 ? (length>=0 ? length : u_strlen(textPtr)) : 0),
|
||||
text(textPtr)
|
||||
{
|
||||
}
|
||||
|
||||
UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
|
||||
UCharCharacterIterator::UCharCharacterIterator(ConstChar16Ptr textPtr,
|
||||
int32_t length,
|
||||
int32_t position)
|
||||
: CharacterIterator(textPtr != 0 ? (length>=0 ? length : u_strlen(textPtr)) : 0, position),
|
||||
|
|
@ -40,7 +40,7 @@ UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
|
|||
{
|
||||
}
|
||||
|
||||
UCharCharacterIterator::UCharCharacterIterator(const UChar* textPtr,
|
||||
UCharCharacterIterator::UCharCharacterIterator(ConstChar16Ptr textPtr,
|
||||
int32_t length,
|
||||
int32_t textBegin,
|
||||
int32_t textEnd,
|
||||
|
|
@ -349,7 +349,7 @@ UCharCharacterIterator::move32(int32_t delta, CharacterIterator::EOrigin origin)
|
|||
return pos;
|
||||
}
|
||||
|
||||
void UCharCharacterIterator::setText(const UChar* newText,
|
||||
void UCharCharacterIterator::setText(ConstChar16Ptr newText,
|
||||
int32_t newTextLength) {
|
||||
text = newText;
|
||||
if(newText == 0 || newTextLength < 0) {
|
||||
|
|
|
|||
|
|
@ -1030,7 +1030,8 @@ collectCurrencyNames(const char* locale,
|
|||
const UnicodeString *symbol;
|
||||
while ((symbol = iter.next()) != NULL) {
|
||||
(*currencySymbols)[*total_currency_symbol_count].IsoCode = iso;
|
||||
(*currencySymbols)[*total_currency_symbol_count].currencyName = (UChar*) symbol->getBuffer();
|
||||
(*currencySymbols)[*total_currency_symbol_count].currencyName =
|
||||
const_cast<UChar*>(symbol->getBuffer());
|
||||
(*currencySymbols)[*total_currency_symbol_count].flag = 0;
|
||||
(*currencySymbols)[(*total_currency_symbol_count)++].currencyNameLen = symbol->length();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ uprv_isInvariantUString(const UChar *s, int32_t length);
|
|||
*/
|
||||
U_INTERNAL inline UBool U_EXPORT2
|
||||
uprv_isInvariantUnicodeString(const icu::UnicodeString &s) {
|
||||
return uprv_isInvariantUString(s.getBuffer(), s.length());
|
||||
return uprv_isInvariantUString(icu::toUCharPtr(s.getBuffer()), s.length());
|
||||
}
|
||||
|
||||
#endif /* __cplusplus */
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@
|
|||
|
||||
/**
|
||||
* \file
|
||||
* \brief C++ API: Appendable class: Sink for Unicode code points and 16-bit code units (UChars).
|
||||
* \brief C++ API: Appendable class: Sink for Unicode code points and 16-bit code units (char16_ts).
|
||||
*/
|
||||
|
||||
#include "unicode/utypes.h"
|
||||
|
|
@ -34,10 +34,10 @@ class UnicodeString;
|
|||
* Combines elements of Java Appendable and ICU4C ByteSink.
|
||||
*
|
||||
* This class can be used in APIs where it does not matter whether the actual destination is
|
||||
* a UnicodeString, a UChar[] array, a UnicodeSet, or any other object
|
||||
* a UnicodeString, a char16_t[] array, a UnicodeSet, or any other object
|
||||
* that receives and processes characters and/or strings.
|
||||
*
|
||||
* Implementation classes must implement at least appendCodeUnit(UChar).
|
||||
* Implementation classes must implement at least appendCodeUnit(char16_t).
|
||||
* The base class provides default implementations for the other methods.
|
||||
*
|
||||
* The methods do not take UErrorCode parameters.
|
||||
|
|
@ -62,11 +62,11 @@ public:
|
|||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
virtual UBool appendCodeUnit(UChar c) = 0;
|
||||
virtual UBool appendCodeUnit(char16_t c) = 0;
|
||||
|
||||
/**
|
||||
* Appends a code point.
|
||||
* The default implementation calls appendCodeUnit(UChar) once or twice.
|
||||
* The default implementation calls appendCodeUnit(char16_t) once or twice.
|
||||
* @param c code point 0..0x10ffff
|
||||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
|
|
@ -75,20 +75,20 @@ public:
|
|||
|
||||
/**
|
||||
* Appends a string.
|
||||
* The default implementation calls appendCodeUnit(UChar) for each code unit.
|
||||
* The default implementation calls appendCodeUnit(char16_t) for each code unit.
|
||||
* @param s string, must not be NULL if length!=0
|
||||
* @param length string length, or -1 if NUL-terminated
|
||||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
virtual UBool appendString(const UChar *s, int32_t length);
|
||||
virtual UBool appendString(const char16_t *s, int32_t length);
|
||||
|
||||
/**
|
||||
* Tells the object that the caller is going to append roughly
|
||||
* appendCapacity UChars. A subclass might use this to pre-allocate
|
||||
* appendCapacity char16_ts. A subclass might use this to pre-allocate
|
||||
* a larger buffer if necessary.
|
||||
* The default implementation does nothing. (It always returns TRUE.)
|
||||
* @param appendCapacity estimated number of UChars that will be appended
|
||||
* @param appendCapacity estimated number of char16_ts that will be appended
|
||||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
|
|
@ -102,19 +102,19 @@ public:
|
|||
* The returned buffer is only valid until the next operation
|
||||
* on this Appendable.
|
||||
*
|
||||
* After writing at most *resultCapacity UChars, call appendString() with the
|
||||
* pointer returned from this function and the number of UChars written.
|
||||
* Many appendString() implementations will avoid copying UChars if this function
|
||||
* After writing at most *resultCapacity char16_ts, call appendString() with the
|
||||
* pointer returned from this function and the number of char16_ts written.
|
||||
* Many appendString() implementations will avoid copying char16_ts if this function
|
||||
* returned an internal buffer.
|
||||
*
|
||||
* Partial usage example:
|
||||
* \code
|
||||
* int32_t capacity;
|
||||
* UChar* buffer = app.getAppendBuffer(..., &capacity);
|
||||
* ... Write n UChars into buffer, with n <= capacity.
|
||||
* char16_t* buffer = app.getAppendBuffer(..., &capacity);
|
||||
* ... Write n char16_ts into buffer, with n <= capacity.
|
||||
* app.appendString(buffer, n);
|
||||
* \endcode
|
||||
* In many implementations, that call to append will avoid copying UChars.
|
||||
* In many implementations, that call to append will avoid copying char16_ts.
|
||||
*
|
||||
* If the Appendable allocates or reallocates an internal buffer, it should use
|
||||
* the desiredCapacityHint if appropriate.
|
||||
|
|
@ -138,9 +138,9 @@ public:
|
|||
* @return a buffer with *resultCapacity>=minCapacity
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
virtual UChar *getAppendBuffer(int32_t minCapacity,
|
||||
virtual char16_t *getAppendBuffer(int32_t minCapacity,
|
||||
int32_t desiredCapacityHint,
|
||||
UChar *scratch, int32_t scratchCapacity,
|
||||
char16_t *scratch, int32_t scratchCapacity,
|
||||
int32_t *resultCapacity);
|
||||
};
|
||||
|
||||
|
|
@ -171,7 +171,7 @@ public:
|
|||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
virtual UBool appendCodeUnit(UChar c);
|
||||
virtual UBool appendCodeUnit(char16_t c);
|
||||
|
||||
/**
|
||||
* Appends a code point to the string.
|
||||
|
|
@ -188,12 +188,12 @@ public:
|
|||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
virtual UBool appendString(const UChar *s, int32_t length);
|
||||
virtual UBool appendString(const char16_t *s, int32_t length);
|
||||
|
||||
/**
|
||||
* Tells the UnicodeString that the caller is going to append roughly
|
||||
* appendCapacity UChars.
|
||||
* @param appendCapacity estimated number of UChars that will be appended
|
||||
* appendCapacity char16_ts.
|
||||
* @param appendCapacity estimated number of char16_ts that will be appended
|
||||
* @return TRUE if the operation succeeded
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
|
|
@ -220,9 +220,9 @@ public:
|
|||
* @return a buffer with *resultCapacity>=minCapacity
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
virtual UChar *getAppendBuffer(int32_t minCapacity,
|
||||
virtual char16_t *getAppendBuffer(int32_t minCapacity,
|
||||
int32_t desiredCapacityHint,
|
||||
UChar *scratch, int32_t scratchCapacity,
|
||||
char16_t *scratch, int32_t scratchCapacity,
|
||||
int32_t *resultCapacity);
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -127,14 +127,14 @@ private:
|
|||
void buildBytes(UStringTrieBuildOption buildOption, UErrorCode &errorCode);
|
||||
|
||||
virtual int32_t getElementStringLength(int32_t i) const;
|
||||
virtual UChar getElementUnit(int32_t i, int32_t byteIndex) const;
|
||||
virtual char16_t getElementUnit(int32_t i, int32_t byteIndex) const;
|
||||
virtual int32_t getElementValue(int32_t i) const;
|
||||
|
||||
virtual int32_t getLimitOfLinearMatch(int32_t first, int32_t last, int32_t byteIndex) const;
|
||||
|
||||
virtual int32_t countElementUnits(int32_t start, int32_t limit, int32_t byteIndex) const;
|
||||
virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t byteIndex, int32_t count) const;
|
||||
virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, UChar byte) const;
|
||||
virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t byteIndex, char16_t byte) const;
|
||||
|
||||
virtual UBool matchNodesCanHaveValues() const { return FALSE; }
|
||||
|
||||
|
|
|
|||
|
|
@ -187,7 +187,7 @@ private:
|
|||
UnicodeString *getEquivalents(const UnicodeString &segment, int32_t &result_len, UErrorCode &status); //private String[] getEquivalents(String segment)
|
||||
|
||||
//Set getEquivalents2(String segment);
|
||||
Hashtable *getEquivalents2(Hashtable *fillinResult, const UChar *segment, int32_t segLen, UErrorCode &status);
|
||||
Hashtable *getEquivalents2(Hashtable *fillinResult, const char16_t *segment, int32_t segLen, UErrorCode &status);
|
||||
//Hashtable *getEquivalents2(const UnicodeString &segment, int32_t segLen, UErrorCode &status);
|
||||
|
||||
/**
|
||||
|
|
@ -196,7 +196,7 @@ private:
|
|||
* If so, take the remainder, and return the equivalents
|
||||
*/
|
||||
//Set extract(int comp, String segment, int segmentPos, StringBuffer buffer);
|
||||
Hashtable *extract(Hashtable *fillinResult, UChar32 comp, const UChar *segment, int32_t segLen, int32_t segmentPos, UErrorCode &status);
|
||||
Hashtable *extract(Hashtable *fillinResult, UChar32 comp, const char16_t *segment, int32_t segLen, int32_t segmentPos, UErrorCode &status);
|
||||
//Hashtable *extract(UChar32 comp, const UnicodeString &segment, int32_t segLen, int32_t segmentPos, UErrorCode &status);
|
||||
|
||||
void cleanPieces();
|
||||
|
|
|
|||
|
|
@ -42,7 +42,7 @@ public:
|
|||
* @param dest A buffer for the result string. The result will be NUL-terminated if
|
||||
* the buffer is large enough.
|
||||
* The contents is undefined in case of failure.
|
||||
* @param destCapacity The size of the buffer (number of UChars). If it is 0, then
|
||||
* @param destCapacity The size of the buffer (number of char16_ts). If it is 0, then
|
||||
* dest may be NULL and the function will only return the length of the result
|
||||
* without writing any of the result string.
|
||||
* @param edits Records edits for index mapping, working with styled text,
|
||||
|
|
@ -59,8 +59,8 @@ public:
|
|||
*/
|
||||
static int32_t toLower(
|
||||
const char *locale, uint32_t options,
|
||||
const UChar *src, int32_t srcLength,
|
||||
UChar *dest, int32_t destCapacity, Edits *edits,
|
||||
const char16_t *src, int32_t srcLength,
|
||||
char16_t *dest, int32_t destCapacity, Edits *edits,
|
||||
UErrorCode &errorCode);
|
||||
|
||||
/**
|
||||
|
|
@ -76,7 +76,7 @@ public:
|
|||
* @param dest A buffer for the result string. The result will be NUL-terminated if
|
||||
* the buffer is large enough.
|
||||
* The contents is undefined in case of failure.
|
||||
* @param destCapacity The size of the buffer (number of UChars). If it is 0, then
|
||||
* @param destCapacity The size of the buffer (number of char16_ts). If it is 0, then
|
||||
* dest may be NULL and the function will only return the length of the result
|
||||
* without writing any of the result string.
|
||||
* @param edits Records edits for index mapping, working with styled text,
|
||||
|
|
@ -93,8 +93,8 @@ public:
|
|||
*/
|
||||
static int32_t toUpper(
|
||||
const char *locale, uint32_t options,
|
||||
const UChar *src, int32_t srcLength,
|
||||
UChar *dest, int32_t destCapacity, Edits *edits,
|
||||
const char16_t *src, int32_t srcLength,
|
||||
char16_t *dest, int32_t destCapacity, Edits *edits,
|
||||
UErrorCode &errorCode);
|
||||
|
||||
#if !UCONFIG_NO_BREAK_ITERATION
|
||||
|
|
@ -122,7 +122,7 @@ public:
|
|||
* @param dest A buffer for the result string. The result will be NUL-terminated if
|
||||
* the buffer is large enough.
|
||||
* The contents is undefined in case of failure.
|
||||
* @param destCapacity The size of the buffer (number of UChars). If it is 0, then
|
||||
* @param destCapacity The size of the buffer (number of char16_ts). If it is 0, then
|
||||
* dest may be NULL and the function will only return the length of the result
|
||||
* without writing any of the result string.
|
||||
* @param edits Records edits for index mapping, working with styled text,
|
||||
|
|
@ -140,8 +140,8 @@ public:
|
|||
*/
|
||||
static int32_t toTitle(
|
||||
const char *locale, uint32_t options, BreakIterator *iter,
|
||||
const UChar *src, int32_t srcLength,
|
||||
UChar *dest, int32_t destCapacity, Edits *edits,
|
||||
const char16_t *src, int32_t srcLength,
|
||||
char16_t *dest, int32_t destCapacity, Edits *edits,
|
||||
UErrorCode &errorCode);
|
||||
|
||||
#endif // UCONFIG_NO_BREAK_ITERATION
|
||||
|
|
@ -163,7 +163,7 @@ public:
|
|||
* @param dest A buffer for the result string. The result will be NUL-terminated if
|
||||
* the buffer is large enough.
|
||||
* The contents is undefined in case of failure.
|
||||
* @param destCapacity The size of the buffer (number of UChars). If it is 0, then
|
||||
* @param destCapacity The size of the buffer (number of char16_ts). If it is 0, then
|
||||
* dest may be NULL and the function will only return the length of the result
|
||||
* without writing any of the result string.
|
||||
* @param edits Records edits for index mapping, working with styled text,
|
||||
|
|
@ -180,8 +180,8 @@ public:
|
|||
*/
|
||||
static int32_t fold(
|
||||
uint32_t options,
|
||||
const UChar *src, int32_t srcLength,
|
||||
UChar *dest, int32_t destCapacity, Edits *edits,
|
||||
const char16_t *src, int32_t srcLength,
|
||||
char16_t *dest, int32_t destCapacity, Edits *edits,
|
||||
UErrorCode &errorCode);
|
||||
|
||||
private:
|
||||
|
|
|
|||
289
icu4c/source/common/unicode/char16ptr.h
Normal file
289
icu4c/source/common/unicode/char16ptr.h
Normal file
|
|
@ -0,0 +1,289 @@
|
|||
// © 2017 and later: Unicode, Inc. and others.
|
||||
// License & terms of use: http://www.unicode.org/copyright.html
|
||||
|
||||
// char16ptr.h
|
||||
// created: 2017feb28 Markus W. Scherer
|
||||
|
||||
#ifndef __CHAR16PTR_H__
|
||||
#define __CHAR16PTR_H__
|
||||
|
||||
#include <cstddef>
|
||||
#include "unicode/utypes.h"
|
||||
|
||||
/**
|
||||
* \file
|
||||
* \brief C++ API: char16_t pointer wrappers with
|
||||
* implicit conversion to/from bit-compatible raw pointer types.
|
||||
* Also conversion functions from char16_t * to UChar * and OldUChar *.
|
||||
*/
|
||||
|
||||
U_NAMESPACE_BEGIN
|
||||
|
||||
/**
|
||||
* \def U_ALIASING_BARRIER
|
||||
* Barrier for pointer anti-aliasing optimizations even across function boundaries.
|
||||
* @internal
|
||||
*/
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
// Use the predefined value.
|
||||
#elif (defined(__clang__) || defined(__GNUC__)) && U_PLATFORM != U_PF_BROWSER_NATIVE_CLIENT
|
||||
# define U_ALIASING_BARRIER(ptr) asm volatile("" : : "rm"(ptr) : "memory")
|
||||
#endif
|
||||
|
||||
/**
|
||||
* char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types.
|
||||
* @draft ICU 59
|
||||
*/
|
||||
class U_COMMON_API Char16Ptr U_FINAL {
|
||||
public:
|
||||
/**
|
||||
* Copies the pointer.
|
||||
* @param p pointer
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline Char16Ptr(char16_t *p);
|
||||
/**
|
||||
* Converts the pointer to char16_t *.
|
||||
* @param p pointer to be converted
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline Char16Ptr(uint16_t *p);
|
||||
#if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
|
||||
/**
|
||||
* Converts the pointer to char16_t *.
|
||||
* (Only defined if U_SIZEOF_WCHAR_T==2.)
|
||||
* @param p pointer to be converted
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline Char16Ptr(wchar_t *p);
|
||||
#endif
|
||||
/**
|
||||
* nullptr constructor.
|
||||
* @param p nullptr
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline Char16Ptr(std::nullptr_t p);
|
||||
/**
|
||||
* Destructor.
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline ~Char16Ptr();
|
||||
|
||||
/**
|
||||
* Pointer access.
|
||||
* @return the wrapped pointer
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline char16_t *get() const;
|
||||
/**
|
||||
* char16_t pointer access via type conversion (e.g., static_cast).
|
||||
* @return the wrapped pointer
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline operator char16_t *() const { return get(); }
|
||||
|
||||
private:
|
||||
Char16Ptr() = delete;
|
||||
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
template<typename T> static char16_t *cast(T *t) {
|
||||
U_ALIASING_BARRIER(t);
|
||||
return reinterpret_cast<char16_t *>(t);
|
||||
}
|
||||
|
||||
char16_t *p;
|
||||
#else
|
||||
union {
|
||||
char16_t *cp;
|
||||
uint16_t *up;
|
||||
wchar_t *wp;
|
||||
} u;
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
|
||||
Char16Ptr::Char16Ptr(char16_t *p) : p(p) {}
|
||||
Char16Ptr::Char16Ptr(uint16_t *p) : p(cast(p)) {}
|
||||
#if U_SIZEOF_WCHAR_T==2
|
||||
Char16Ptr::Char16Ptr(wchar_t *p) : p(cast(p)) {}
|
||||
#endif
|
||||
Char16Ptr::Char16Ptr(std::nullptr_t p) : p(p) {}
|
||||
Char16Ptr::~Char16Ptr() {
|
||||
U_ALIASING_BARRIER(p);
|
||||
}
|
||||
|
||||
char16_t *Char16Ptr::get() const { return p; }
|
||||
|
||||
#else
|
||||
|
||||
Char16Ptr::Char16Ptr(char16_t *p) { u.cp = p; }
|
||||
Char16Ptr::Char16Ptr(uint16_t *p) { u.up = p; }
|
||||
#if U_SIZEOF_WCHAR_T==2
|
||||
Char16Ptr::Char16Ptr(wchar_t *p) { u.wp = p; }
|
||||
#endif
|
||||
Char16Ptr::Char16Ptr(std::nullptr_t p) { u.cp = p; }
|
||||
Char16Ptr::~Char16Ptr() {}
|
||||
|
||||
char16_t *Char16Ptr::get() const { return u.cp; }
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* const char16_t * wrapper with implicit conversion from distinct but bit-compatible pointer types.
|
||||
* @draft ICU 59
|
||||
*/
|
||||
class U_COMMON_API ConstChar16Ptr U_FINAL {
|
||||
public:
|
||||
/**
|
||||
* Copies the pointer.
|
||||
* @param p pointer
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline ConstChar16Ptr(const char16_t *p);
|
||||
/**
|
||||
* Converts the pointer to char16_t *.
|
||||
* @param p pointer to be converted
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline ConstChar16Ptr(const uint16_t *p);
|
||||
#if U_SIZEOF_WCHAR_T==2 || defined(U_IN_DOXYGEN)
|
||||
/**
|
||||
* Converts the pointer to char16_t *.
|
||||
* (Only defined if U_SIZEOF_WCHAR_T==2.)
|
||||
* @param p pointer to be converted
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline ConstChar16Ptr(const wchar_t *p);
|
||||
#endif
|
||||
/**
|
||||
* nullptr constructor.
|
||||
* @param p nullptr
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline ConstChar16Ptr(const std::nullptr_t p);
|
||||
/**
|
||||
* Destructor.
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline ~ConstChar16Ptr();
|
||||
|
||||
/**
|
||||
* Pointer access.
|
||||
* @return the wrapped pointer
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline const char16_t *get() const;
|
||||
/**
|
||||
* char16_t pointer access via type conversion (e.g., static_cast).
|
||||
* @return the wrapped pointer
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline operator const char16_t *() const { return get(); }
|
||||
|
||||
private:
|
||||
ConstChar16Ptr() = delete;
|
||||
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
template<typename T> static const char16_t *cast(const T *t) {
|
||||
U_ALIASING_BARRIER(t);
|
||||
return reinterpret_cast<const char16_t *>(t);
|
||||
}
|
||||
|
||||
const char16_t *p;
|
||||
#else
|
||||
union {
|
||||
const char16_t *cp;
|
||||
const uint16_t *up;
|
||||
const wchar_t *wp;
|
||||
} u;
|
||||
#endif
|
||||
};
|
||||
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
|
||||
ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) : p(p) {}
|
||||
ConstChar16Ptr::ConstChar16Ptr(const uint16_t *p) : p(cast(p)) {}
|
||||
#if U_SIZEOF_WCHAR_T==2
|
||||
ConstChar16Ptr::ConstChar16Ptr(const wchar_t *p) : p(cast(p)) {}
|
||||
#endif
|
||||
ConstChar16Ptr::ConstChar16Ptr(const std::nullptr_t p) : p(p) {}
|
||||
ConstChar16Ptr::~ConstChar16Ptr() {
|
||||
U_ALIASING_BARRIER(p);
|
||||
}
|
||||
|
||||
const char16_t *ConstChar16Ptr::get() const { return p; }
|
||||
|
||||
#else
|
||||
|
||||
ConstChar16Ptr::ConstChar16Ptr(const char16_t *p) { u.cp = p; }
|
||||
ConstChar16Ptr::ConstChar16Ptr(const uint16_t *p) { u.up = p; }
|
||||
#if U_SIZEOF_WCHAR_T==2
|
||||
ConstChar16Ptr::ConstChar16Ptr(const wchar_t *p) { u.wp = p; }
|
||||
#endif
|
||||
ConstChar16Ptr::ConstChar16Ptr(const std::nullptr_t p) { u.cp = p; }
|
||||
ConstChar16Ptr::~ConstChar16Ptr() {}
|
||||
|
||||
const char16_t *ConstChar16Ptr::get() const { return u.cp; }
|
||||
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Converts from const char16_t * to const UChar *.
|
||||
* Includes an aliasing barrier if available.
|
||||
* @param p pointer
|
||||
* @return p as const UChar *
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline U_COMMON_API const UChar *toUCharPtr(const char16_t *p) {
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
U_ALIASING_BARRIER(p);
|
||||
#endif
|
||||
return reinterpret_cast<const UChar *>(p);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts from char16_t * to UChar *.
|
||||
* Includes an aliasing barrier if available.
|
||||
* @param p pointer
|
||||
* @return p as UChar *
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline U_COMMON_API UChar *toUCharPtr(char16_t *p) {
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
U_ALIASING_BARRIER(p);
|
||||
#endif
|
||||
return reinterpret_cast<UChar *>(p);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts from const char16_t * to const OldUChar *.
|
||||
* Includes an aliasing barrier if available.
|
||||
* @param p pointer
|
||||
* @return p as const OldUChar *
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline U_COMMON_API const OldUChar *toOldUCharPtr(const char16_t *p) {
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
U_ALIASING_BARRIER(p);
|
||||
#endif
|
||||
return reinterpret_cast<const OldUChar *>(p);
|
||||
}
|
||||
|
||||
/**
|
||||
* Converts from char16_t * to OldUChar *.
|
||||
* Includes an aliasing barrier if available.
|
||||
* @param p pointer
|
||||
* @return p as OldUChar *
|
||||
* @draft ICU 59
|
||||
*/
|
||||
inline U_COMMON_API OldUChar *toOldUCharPtr(char16_t *p) {
|
||||
#ifdef U_ALIASING_BARRIER
|
||||
U_ALIASING_BARRIER(p);
|
||||
#endif
|
||||
return reinterpret_cast<OldUChar *>(p);
|
||||
}
|
||||
|
||||
U_NAMESPACE_END
|
||||
|
||||
#endif // __CHAR16PTR_H__
|
||||
|
|
@ -78,7 +78,7 @@ U_NAMESPACE_BEGIN
|
|||
* }
|
||||
*
|
||||
* void function1(ForwardCharacterIterator &it) {
|
||||
* UChar c;
|
||||
* char16_t c;
|
||||
* while((c=it.nextPostInc())!=ForwardCharacterIterator::DONE) {
|
||||
* // use c
|
||||
* }
|
||||
|
|
@ -149,7 +149,7 @@ public:
|
|||
* @return the current code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar nextPostInc(void) = 0;
|
||||
virtual char16_t nextPostInc(void) = 0;
|
||||
|
||||
/**
|
||||
* Gets the current code point for returning and advances to the next code point
|
||||
|
|
@ -230,7 +230,7 @@ protected:
|
|||
* showing a way to convert simple for() loops:
|
||||
* \code
|
||||
* void forward2(CharacterIterator &it) {
|
||||
* UChar c;
|
||||
* char16_t c;
|
||||
* for(c=it.firstPostInc(); c!=CharacterIterator::DONE; c=it.nextPostInc()) {
|
||||
* // use c
|
||||
* }
|
||||
|
|
@ -249,7 +249,7 @@ protected:
|
|||
* Backward iteration with a more traditional for() loop:
|
||||
* \code
|
||||
* void backward2(CharacterIterator &it) {
|
||||
* UChar c;
|
||||
* char16_t c;
|
||||
* for(c=it.last(); c!=CharacterIterator::DONE; c=it.previous()) {
|
||||
* // use c
|
||||
* }
|
||||
|
|
@ -266,7 +266,7 @@ protected:
|
|||
* // get the position
|
||||
* int32_t pos=it.getIndex();
|
||||
* // get the previous code unit
|
||||
* UChar u=it.previous();
|
||||
* char16_t u=it.previous();
|
||||
* // move back one more code unit
|
||||
* it.move(-1, CharacterIterator::kCurrent);
|
||||
* // set the position back to where it was
|
||||
|
|
@ -283,7 +283,7 @@ protected:
|
|||
* Function processing characters, in this example simple output
|
||||
* <pre>
|
||||
* \code
|
||||
* void processChar( UChar c )
|
||||
* void processChar( char16_t c )
|
||||
* {
|
||||
* cout << " " << c;
|
||||
* }
|
||||
|
|
@ -294,7 +294,7 @@ protected:
|
|||
* \code
|
||||
* void traverseForward(CharacterIterator& iter)
|
||||
* {
|
||||
* for(UChar c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
|
||||
* for(char16_t c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
|
||||
* processChar(c);
|
||||
* }
|
||||
* }
|
||||
|
|
@ -305,7 +305,7 @@ protected:
|
|||
* \code
|
||||
* void traverseBackward(CharacterIterator& iter)
|
||||
* {
|
||||
* for(UChar c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) {
|
||||
* for(char16_t c = iter.last(); c != CharacterIterator.DONE; c = iter.previous()) {
|
||||
* processChar(c);
|
||||
* }
|
||||
* }
|
||||
|
|
@ -317,7 +317,7 @@ protected:
|
|||
* \code
|
||||
* void traverseOut(CharacterIterator& iter, int32_t pos)
|
||||
* {
|
||||
* UChar c;
|
||||
* char16_t c;
|
||||
* for (c = iter.setIndex(pos);
|
||||
* c != CharacterIterator.DONE && (Unicode::isLetter(c) || Unicode::isDigit(c));
|
||||
* c = iter.next()) {}
|
||||
|
|
@ -386,7 +386,7 @@ public:
|
|||
* @return the first code unit in its iteration range.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar first(void) = 0;
|
||||
virtual char16_t first(void) = 0;
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the first code unit in its
|
||||
|
|
@ -396,7 +396,7 @@ public:
|
|||
* @return the first code unit in its iteration range.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar firstPostInc(void);
|
||||
virtual char16_t firstPostInc(void);
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the first code point in its
|
||||
|
|
@ -435,7 +435,7 @@ public:
|
|||
* @return the last code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar last(void) = 0;
|
||||
virtual char16_t last(void) = 0;
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the last code point in its
|
||||
|
|
@ -463,7 +463,7 @@ public:
|
|||
* @return the "position"-th code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar setIndex(int32_t position) = 0;
|
||||
virtual char16_t setIndex(int32_t position) = 0;
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the beginning of the code point
|
||||
|
|
@ -483,7 +483,7 @@ public:
|
|||
* @return the current code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar current(void) const = 0;
|
||||
virtual char16_t current(void) const = 0;
|
||||
|
||||
/**
|
||||
* Returns the code point the iterator currently refers to.
|
||||
|
|
@ -499,7 +499,7 @@ public:
|
|||
* @return the next code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar next(void) = 0;
|
||||
virtual char16_t next(void) = 0;
|
||||
|
||||
/**
|
||||
* Advances to the next code point in the iteration range
|
||||
|
|
@ -520,7 +520,7 @@ public:
|
|||
* @return the previous code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar previous(void) = 0;
|
||||
virtual char16_t previous(void) = 0;
|
||||
|
||||
/**
|
||||
* Advances to the previous code point in the iteration range
|
||||
|
|
|
|||
|
|
@ -174,9 +174,9 @@ private:
|
|||
* \code
|
||||
* LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
|
||||
* int32_t length=s->length(); // 2
|
||||
* UChar lead=s->charAt(0); // 0xd900
|
||||
* char16_t lead=s->charAt(0); // 0xd900
|
||||
* if(some condition) { return; } // no need to explicitly delete the pointer
|
||||
* s.adoptInstead(new UnicodeString((UChar)0xfffc));
|
||||
* s.adoptInstead(new UnicodeString((char16_t)0xfffc));
|
||||
* length=s->length(); // 1
|
||||
* // no need to explicitly delete the pointer
|
||||
* \endcode
|
||||
|
|
@ -323,10 +323,10 @@ public:
|
|||
* Usage example:
|
||||
* \code
|
||||
* LocalArray<UnicodeString> a(new UnicodeString[2]);
|
||||
* a[0].append((UChar)0x61);
|
||||
* a[0].append((char16_t)0x61);
|
||||
* if(some condition) { return; } // no need to explicitly delete the array
|
||||
* a.adoptInstead(new UnicodeString[4]);
|
||||
* a[3].append((UChar)0x62).append((UChar)0x63).reverse();
|
||||
* a[3].append((char16_t)0x62).append((char16_t)0x63).reverse();
|
||||
* // no need to explicitly delete the array
|
||||
* \endcode
|
||||
*
|
||||
|
|
|
|||
|
|
@ -282,7 +282,7 @@ public:
|
|||
*
|
||||
* When used on a standard NFC Normalizer2 instance,
|
||||
* it returns the Decomposition_Mapping only if the Decomposition_Type (dt) is Canonical (Can);
|
||||
* in this case, the result contains either one or two code points (=1..4 UChars).
|
||||
* in this case, the result contains either one or two code points (=1..4 char16_ts).
|
||||
*
|
||||
* This function is independent of the mode of the Normalizer2.
|
||||
* The default implementation returns FALSE.
|
||||
|
|
|
|||
|
|
@ -168,7 +168,7 @@ public:
|
|||
* @param mode The normalization mode.
|
||||
* @deprecated ICU 56 Use Normalizer2 instead.
|
||||
*/
|
||||
Normalizer(const UChar* str, int32_t length, UNormalizationMode mode);
|
||||
Normalizer(ConstChar16Ptr str, int32_t length, UNormalizationMode mode);
|
||||
|
||||
/**
|
||||
* Creates a new <code>Normalizer</code> object for iterating over the
|
||||
|
|
@ -704,7 +704,7 @@ public:
|
|||
* @param status a UErrorCode
|
||||
* @deprecated ICU 56 Use Normalizer2 instead.
|
||||
*/
|
||||
void setText(const UChar* newText,
|
||||
void setText(ConstChar16Ptr newText,
|
||||
int32_t length,
|
||||
UErrorCode &status);
|
||||
/**
|
||||
|
|
@ -796,8 +796,8 @@ Normalizer::compare(const UnicodeString &s1, const UnicodeString &s2,
|
|||
uint32_t options,
|
||||
UErrorCode &errorCode) {
|
||||
// all argument checking is done in unorm_compare
|
||||
return unorm_compare(s1.getBuffer(), s1.length(),
|
||||
s2.getBuffer(), s2.length(),
|
||||
return unorm_compare(toUCharPtr(s1.getBuffer()), s1.length(),
|
||||
toUCharPtr(s2.getBuffer()), s2.length(),
|
||||
options,
|
||||
&errorCode);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -150,7 +150,7 @@
|
|||
# define U_PLATFORM U_PF_ANDROID
|
||||
/* Android wchar_t support depends on the API level. */
|
||||
# include <android/api-level.h>
|
||||
#elif defined(__native_client__)
|
||||
#elif defined(__pnacl__) || defined(__native_client__)
|
||||
# define U_PLATFORM U_PF_BROWSER_NATIVE_CLIENT
|
||||
#elif defined(linux) || defined(__linux__) || defined(__linux)
|
||||
# define U_PLATFORM U_PF_LINUX
|
||||
|
|
|
|||
|
|
@ -93,7 +93,7 @@ public:
|
|||
* @return 16-bit code unit of text at given offset
|
||||
* @stable ICU 1.8
|
||||
*/
|
||||
inline UChar charAt(int32_t offset) const;
|
||||
inline char16_t charAt(int32_t offset) const;
|
||||
|
||||
/**
|
||||
* Returns the 32-bit code point at the given 16-bit offset into
|
||||
|
|
@ -230,7 +230,7 @@ protected:
|
|||
* Virtual version of charAt().
|
||||
* @stable ICU 2.4
|
||||
*/
|
||||
virtual UChar getCharAt(int32_t offset) const = 0;
|
||||
virtual char16_t getCharAt(int32_t offset) const = 0;
|
||||
|
||||
/**
|
||||
* Virtual version of char32At().
|
||||
|
|
@ -246,7 +246,7 @@ Replaceable::length() const {
|
|||
return getLength();
|
||||
}
|
||||
|
||||
inline UChar
|
||||
inline char16_t
|
||||
Replaceable::charAt(int32_t offset) const {
|
||||
return getCharAt(offset);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -216,7 +216,7 @@ public:
|
|||
* could be <TT>U_MISSING_RESOURCE_ERROR</TT> if the key is not found
|
||||
* could be a warning
|
||||
* e.g.: <TT>U_USING_FALLBACK_WARNING</TT>,<TT>U_USING_DEFAULT_WARNING </TT>
|
||||
* @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
|
||||
* @return a pointer to a zero-terminated char16_t array which lives in a memory mapped/DLL file.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
UnicodeString
|
||||
|
|
|
|||
|
|
@ -175,7 +175,7 @@ protected:
|
|||
* @param newTextLength The length of the String
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
void setText(const UChar* newText, int32_t newTextLength);
|
||||
void setText(const char16_t* newText, int32_t newTextLength);
|
||||
|
||||
/**
|
||||
* Copy of the iterated string object.
|
||||
|
|
|
|||
|
|
@ -57,7 +57,7 @@ public:
|
|||
* Default constructor.
|
||||
* @draft ICU 57
|
||||
*/
|
||||
SimpleFormatter() : compiledPattern((UChar)0) {}
|
||||
SimpleFormatter() : compiledPattern((char16_t)0) {}
|
||||
|
||||
/**
|
||||
* Constructs a formatter from the pattern string.
|
||||
|
|
@ -275,15 +275,15 @@ private:
|
|||
*/
|
||||
UnicodeString compiledPattern;
|
||||
|
||||
static inline int32_t getArgumentLimit(const UChar *compiledPattern,
|
||||
static inline int32_t getArgumentLimit(const char16_t *compiledPattern,
|
||||
int32_t compiledPatternLength) {
|
||||
return compiledPatternLength == 0 ? 0 : compiledPattern[0];
|
||||
}
|
||||
|
||||
static UnicodeString getTextWithNoArguments(const UChar *compiledPattern, int32_t compiledPatternLength);
|
||||
static UnicodeString getTextWithNoArguments(const char16_t *compiledPattern, int32_t compiledPatternLength);
|
||||
|
||||
static UnicodeString &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,
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ U_NAMESPACE_BEGIN
|
|||
* call, so the returned string still might not be 'valid' on
|
||||
* subsequent use.</p>
|
||||
*
|
||||
* <p>Strings may take the form of const char*, const UChar*, or const
|
||||
* <p>Strings may take the form of const char*, const char16_t*, or const
|
||||
* UnicodeString*. The type you get is determine by the variant of
|
||||
* 'next' that you call. In general the StringEnumeration is
|
||||
* optimized for one of these types, but all StringEnumerations can
|
||||
|
|
@ -112,7 +112,7 @@ public:
|
|||
* <p>If the iterator is out of sync with its service, status is set
|
||||
* to U_ENUM_OUT_OF_SYNC_ERROR and NULL is returned.</p>
|
||||
*
|
||||
* <p>If the native service string is a UChar* string, it is
|
||||
* <p>If the native service string is a char16_t* string, it is
|
||||
* converted to char* with the invariant converter. If the
|
||||
* conversion fails (because a character cannot be converted) then
|
||||
* status is set to U_INVARIANT_CONVERSION_ERROR and the return
|
||||
|
|
@ -131,7 +131,7 @@ public:
|
|||
virtual const char* next(int32_t *resultLength, UErrorCode& status);
|
||||
|
||||
/**
|
||||
* <p>Returns the next element as a NUL-terminated UChar*. If there
|
||||
* <p>Returns the next element as a NUL-terminated char16_t*. If there
|
||||
* are no more elements, returns NULL. If the resultLength pointer
|
||||
* is not NULL, the length of the string (not counting the
|
||||
* terminating NUL) is returned at that address. If an error
|
||||
|
|
@ -153,7 +153,7 @@ public:
|
|||
*
|
||||
* @stable ICU 2.4
|
||||
*/
|
||||
virtual const UChar* unext(int32_t *resultLength, UErrorCode& status);
|
||||
virtual const char16_t* unext(int32_t *resultLength, UErrorCode& status);
|
||||
|
||||
/**
|
||||
* <p>Returns the next element a UnicodeString*. If there are no
|
||||
|
|
|
|||
|
|
@ -105,7 +105,7 @@ protected:
|
|||
/** @internal */
|
||||
virtual int32_t getElementStringLength(int32_t i) const = 0;
|
||||
/** @internal */
|
||||
virtual UChar getElementUnit(int32_t i, int32_t unitIndex) const = 0;
|
||||
virtual char16_t getElementUnit(int32_t i, int32_t unitIndex) const = 0;
|
||||
/** @internal */
|
||||
virtual int32_t getElementValue(int32_t i) const = 0;
|
||||
|
||||
|
|
@ -120,7 +120,7 @@ protected:
|
|||
/** @internal */
|
||||
virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t count) const = 0;
|
||||
/** @internal */
|
||||
virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, UChar unit) const = 0;
|
||||
virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const = 0;
|
||||
|
||||
/** @internal */
|
||||
virtual UBool matchNodesCanHaveValues() const = 0;
|
||||
|
|
@ -137,7 +137,7 @@ protected:
|
|||
/** @internal */
|
||||
static const int32_t kMaxBranchLinearSubNodeLength=5;
|
||||
|
||||
// Maximum number of nested split-branch levels for a branch on all 2^16 possible UChar units.
|
||||
// Maximum number of nested split-branch levels for a branch on all 2^16 possible char16_t units.
|
||||
// log2(2^16/kMaxBranchLinearSubNodeLength) rounded up.
|
||||
/** @internal */
|
||||
static const int32_t kMaxSplitBranchLevels=14;
|
||||
|
|
@ -338,7 +338,7 @@ protected:
|
|||
virtual void write(StringTrieBuilder &builder);
|
||||
// Adds a unit with a final value.
|
||||
void add(int32_t c, int32_t value) {
|
||||
units[length]=(UChar)c;
|
||||
units[length]=(char16_t)c;
|
||||
equal[length]=NULL;
|
||||
values[length]=value;
|
||||
++length;
|
||||
|
|
@ -346,7 +346,7 @@ protected:
|
|||
}
|
||||
// Adds a unit which leads to another match node.
|
||||
void add(int32_t c, Node *node) {
|
||||
units[length]=(UChar)c;
|
||||
units[length]=(char16_t)c;
|
||||
equal[length]=node;
|
||||
values[length]=0;
|
||||
++length;
|
||||
|
|
@ -356,7 +356,7 @@ protected:
|
|||
Node *equal[kMaxBranchLinearSubNodeLength]; // NULL means "has final value".
|
||||
int32_t length;
|
||||
int32_t values[kMaxBranchLinearSubNodeLength];
|
||||
UChar units[kMaxBranchLinearSubNodeLength];
|
||||
char16_t units[kMaxBranchLinearSubNodeLength];
|
||||
};
|
||||
|
||||
/**
|
||||
|
|
@ -364,7 +364,7 @@ protected:
|
|||
*/
|
||||
class SplitBranchNode : public BranchNode {
|
||||
public:
|
||||
SplitBranchNode(UChar middleUnit, Node *lessThanNode, Node *greaterOrEqualNode)
|
||||
SplitBranchNode(char16_t middleUnit, Node *lessThanNode, Node *greaterOrEqualNode)
|
||||
: BranchNode(((0x555555*37+middleUnit)*37+
|
||||
hashCode(lessThanNode))*37+hashCode(greaterOrEqualNode)),
|
||||
unit(middleUnit), lessThan(lessThanNode), greaterOrEqual(greaterOrEqualNode) {}
|
||||
|
|
@ -372,7 +372,7 @@ protected:
|
|||
virtual int32_t markRightEdgesFirst(int32_t edgeNumber);
|
||||
virtual void write(StringTrieBuilder &builder);
|
||||
protected:
|
||||
UChar unit;
|
||||
char16_t unit;
|
||||
Node *lessThan;
|
||||
Node *greaterOrEqual;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@ class UVector32;
|
|||
|
||||
/**
|
||||
* Light-weight, non-const reader class for a UCharsTrie.
|
||||
* Traverses a UChar-serialized data structure with minimal state,
|
||||
* Traverses a char16_t-serialized data structure with minimal state,
|
||||
* for mapping strings (16-bit-unit sequences) to non-negative integer values.
|
||||
*
|
||||
* This class owns the serialized trie data only if it was constructed by
|
||||
|
|
@ -52,18 +52,18 @@ public:
|
|||
/**
|
||||
* Constructs a UCharsTrie reader instance.
|
||||
*
|
||||
* The trieUChars must contain a copy of a UChar sequence from the UCharsTrieBuilder,
|
||||
* starting with the first UChar of that sequence.
|
||||
* The UCharsTrie object will not read more UChars than
|
||||
* The trieUChars must contain a copy of a char16_t sequence from the UCharsTrieBuilder,
|
||||
* starting with the first char16_t of that sequence.
|
||||
* The UCharsTrie object will not read more char16_ts than
|
||||
* the UCharsTrieBuilder generated in the corresponding build() call.
|
||||
*
|
||||
* The array is not copied/cloned and must not be modified while
|
||||
* the UCharsTrie object is in use.
|
||||
*
|
||||
* @param trieUChars The UChar array that contains the serialized trie.
|
||||
* @param trieUChars The char16_t array that contains the serialized trie.
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
UCharsTrie(const UChar *trieUChars)
|
||||
UCharsTrie(ConstChar16Ptr trieUChars)
|
||||
: ownedArray_(NULL), uchars_(trieUChars),
|
||||
pos_(uchars_), remainingMatchLength_(-1) {}
|
||||
|
||||
|
|
@ -75,7 +75,7 @@ public:
|
|||
|
||||
/**
|
||||
* Copy constructor, copies the other trie reader object and its state,
|
||||
* but not the UChar array which will be shared. (Shallow copy.)
|
||||
* but not the char16_t array which will be shared. (Shallow copy.)
|
||||
* @param other Another UCharsTrie object.
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
|
|
@ -109,8 +109,8 @@ public:
|
|||
private:
|
||||
friend class UCharsTrie;
|
||||
|
||||
const UChar *uchars;
|
||||
const UChar *pos;
|
||||
const char16_t *uchars;
|
||||
const char16_t *pos;
|
||||
int32_t remainingMatchLength;
|
||||
};
|
||||
|
||||
|
|
@ -148,14 +148,14 @@ public:
|
|||
|
||||
/**
|
||||
* Determines whether the string so far matches, whether it has a value,
|
||||
* and whether another input UChar can continue a matching string.
|
||||
* and whether another input char16_t can continue a matching string.
|
||||
* @return The match/value Result.
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
UStringTrieResult current() const;
|
||||
|
||||
/**
|
||||
* Traverses the trie from the initial state for this input UChar.
|
||||
* Traverses the trie from the initial state for this input char16_t.
|
||||
* Equivalent to reset().next(uchar).
|
||||
* @param uchar Input char value. Values below 0 and above 0xffff will never match.
|
||||
* @return The match/value Result.
|
||||
|
|
@ -177,7 +177,7 @@ public:
|
|||
UStringTrieResult firstForCodePoint(UChar32 cp);
|
||||
|
||||
/**
|
||||
* Traverses the trie from the current state for this input UChar.
|
||||
* Traverses the trie from the current state for this input char16_t.
|
||||
* @param uchar Input char value. Values below 0 and above 0xffff will never match.
|
||||
* @return The match/value Result.
|
||||
* @stable ICU 4.8
|
||||
|
|
@ -208,7 +208,7 @@ public:
|
|||
* @return The match/value Result.
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
UStringTrieResult next(const UChar *s, int32_t length);
|
||||
UStringTrieResult next(ConstChar16Ptr s, int32_t length);
|
||||
|
||||
/**
|
||||
* Returns a matching string's value if called immediately after
|
||||
|
|
@ -220,7 +220,7 @@ public:
|
|||
* @stable ICU 4.8
|
||||
*/
|
||||
inline int32_t getValue() const {
|
||||
const UChar *pos=pos_;
|
||||
const char16_t *pos=pos_;
|
||||
int32_t leadUnit=*pos++;
|
||||
// U_ASSERT(leadUnit>=kMinValueLead);
|
||||
return leadUnit&kValueIsFinal ?
|
||||
|
|
@ -237,16 +237,16 @@ public:
|
|||
* @stable ICU 4.8
|
||||
*/
|
||||
inline UBool hasUniqueValue(int32_t &uniqueValue) const {
|
||||
const UChar *pos=pos_;
|
||||
const char16_t *pos=pos_;
|
||||
// Skip the rest of a pending linear-match node.
|
||||
return pos!=NULL && findUniqueValue(pos+remainingMatchLength_+1, FALSE, uniqueValue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Finds each UChar which continues the string from the current state.
|
||||
* That is, each UChar c for which it would be next(c)!=USTRINGTRIE_NO_MATCH now.
|
||||
* @param out Each next UChar is appended to this object.
|
||||
* @return the number of UChars which continue the string from here
|
||||
* Finds each char16_t which continues the string from the current state.
|
||||
* That is, each char16_t c for which it would be next(c)!=USTRINGTRIE_NO_MATCH now.
|
||||
* @param out Each next char16_t is appended to this object.
|
||||
* @return the number of char16_ts which continue the string from here
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
int32_t getNextUChars(Appendable &out) const;
|
||||
|
|
@ -258,8 +258,8 @@ public:
|
|||
class U_COMMON_API Iterator : public UMemory {
|
||||
public:
|
||||
/**
|
||||
* Iterates from the root of a UChar-serialized UCharsTrie.
|
||||
* @param trieUChars The trie UChars.
|
||||
* Iterates from the root of a char16_t-serialized UCharsTrie.
|
||||
* @param trieUChars The trie char16_ts.
|
||||
* @param maxStringLength If 0, the iterator returns full strings.
|
||||
* Otherwise, the iterator returns strings with this maximum length.
|
||||
* @param errorCode Standard ICU error code. Its input value must
|
||||
|
|
@ -268,7 +268,7 @@ public:
|
|||
* function chaining. (See User Guide for details.)
|
||||
* @stable ICU 4.8
|
||||
*/
|
||||
Iterator(const UChar *trieUChars, int32_t maxStringLength, UErrorCode &errorCode);
|
||||
Iterator(ConstChar16Ptr trieUChars, int32_t maxStringLength, UErrorCode &errorCode);
|
||||
|
||||
/**
|
||||
* Iterates from the current state of the specified UCharsTrie.
|
||||
|
|
@ -336,11 +336,11 @@ public:
|
|||
return TRUE;
|
||||
}
|
||||
|
||||
const UChar *branchNext(const UChar *pos, int32_t length, UErrorCode &errorCode);
|
||||
const char16_t *branchNext(const char16_t *pos, int32_t length, UErrorCode &errorCode);
|
||||
|
||||
const UChar *uchars_;
|
||||
const UChar *pos_;
|
||||
const UChar *initialPos_;
|
||||
const char16_t *uchars_;
|
||||
const char16_t *pos_;
|
||||
const char16_t *initialPos_;
|
||||
int32_t remainingMatchLength_;
|
||||
int32_t initialRemainingMatchLength_;
|
||||
UBool skipValue_; // Skip intermediate value which was already delivered.
|
||||
|
|
@ -368,7 +368,7 @@ private:
|
|||
* this constructor adopts the builder's array.
|
||||
* This constructor is only called by the builder.
|
||||
*/
|
||||
UCharsTrie(UChar *adoptUChars, const UChar *trieUChars)
|
||||
UCharsTrie(char16_t *adoptUChars, const char16_t *trieUChars)
|
||||
: ownedArray_(adoptUChars), uchars_(trieUChars),
|
||||
pos_(uchars_), remainingMatchLength_(-1) {}
|
||||
|
||||
|
|
@ -381,7 +381,7 @@ private:
|
|||
|
||||
// Reads a compact 32-bit integer.
|
||||
// pos is already after the leadUnit, and the lead unit has bit 15 reset.
|
||||
static inline int32_t readValue(const UChar *pos, int32_t leadUnit) {
|
||||
static inline int32_t readValue(const char16_t *pos, int32_t leadUnit) {
|
||||
int32_t value;
|
||||
if(leadUnit<kMinTwoUnitValueLead) {
|
||||
value=leadUnit;
|
||||
|
|
@ -392,7 +392,7 @@ private:
|
|||
}
|
||||
return value;
|
||||
}
|
||||
static inline const UChar *skipValue(const UChar *pos, int32_t leadUnit) {
|
||||
static inline const char16_t *skipValue(const char16_t *pos, int32_t leadUnit) {
|
||||
if(leadUnit>=kMinTwoUnitValueLead) {
|
||||
if(leadUnit<kThreeUnitValueLead) {
|
||||
++pos;
|
||||
|
|
@ -402,12 +402,12 @@ private:
|
|||
}
|
||||
return pos;
|
||||
}
|
||||
static inline const UChar *skipValue(const UChar *pos) {
|
||||
static inline const char16_t *skipValue(const char16_t *pos) {
|
||||
int32_t leadUnit=*pos++;
|
||||
return skipValue(pos, leadUnit&0x7fff);
|
||||
}
|
||||
|
||||
static inline int32_t readNodeValue(const UChar *pos, int32_t leadUnit) {
|
||||
static inline int32_t readNodeValue(const char16_t *pos, int32_t leadUnit) {
|
||||
// U_ASSERT(kMinValueLead<=leadUnit && leadUnit<kValueIsFinal);
|
||||
int32_t value;
|
||||
if(leadUnit<kMinTwoUnitNodeValueLead) {
|
||||
|
|
@ -419,7 +419,7 @@ private:
|
|||
}
|
||||
return value;
|
||||
}
|
||||
static inline const UChar *skipNodeValue(const UChar *pos, int32_t leadUnit) {
|
||||
static inline const char16_t *skipNodeValue(const char16_t *pos, int32_t leadUnit) {
|
||||
// U_ASSERT(kMinValueLead<=leadUnit && leadUnit<kValueIsFinal);
|
||||
if(leadUnit>=kMinTwoUnitNodeValueLead) {
|
||||
if(leadUnit<kThreeUnitNodeValueLead) {
|
||||
|
|
@ -431,7 +431,7 @@ private:
|
|||
return pos;
|
||||
}
|
||||
|
||||
static inline const UChar *jumpByDelta(const UChar *pos) {
|
||||
static inline const char16_t *jumpByDelta(const char16_t *pos) {
|
||||
int32_t delta=*pos++;
|
||||
if(delta>=kMinTwoUnitDeltaLead) {
|
||||
if(delta==kThreeUnitDeltaLead) {
|
||||
|
|
@ -444,7 +444,7 @@ private:
|
|||
return pos+delta;
|
||||
}
|
||||
|
||||
static const UChar *skipDelta(const UChar *pos) {
|
||||
static const char16_t *skipDelta(const char16_t *pos) {
|
||||
int32_t delta=*pos++;
|
||||
if(delta>=kMinTwoUnitDeltaLead) {
|
||||
if(delta==kThreeUnitDeltaLead) {
|
||||
|
|
@ -461,28 +461,28 @@ private:
|
|||
}
|
||||
|
||||
// Handles a branch node for both next(uchar) and next(string).
|
||||
UStringTrieResult branchNext(const UChar *pos, int32_t length, int32_t uchar);
|
||||
UStringTrieResult branchNext(const char16_t *pos, int32_t length, int32_t uchar);
|
||||
|
||||
// Requires remainingLength_<0.
|
||||
UStringTrieResult nextImpl(const UChar *pos, int32_t uchar);
|
||||
UStringTrieResult nextImpl(const char16_t *pos, int32_t uchar);
|
||||
|
||||
// Helper functions for hasUniqueValue().
|
||||
// Recursively finds a unique value (or whether there is not a unique one)
|
||||
// from a branch.
|
||||
static const UChar *findUniqueValueFromBranch(const UChar *pos, int32_t length,
|
||||
static const char16_t *findUniqueValueFromBranch(const char16_t *pos, int32_t length,
|
||||
UBool haveUniqueValue, int32_t &uniqueValue);
|
||||
// Recursively finds a unique value (or whether there is not a unique one)
|
||||
// starting from a position on a node lead unit.
|
||||
static UBool findUniqueValue(const UChar *pos, UBool haveUniqueValue, int32_t &uniqueValue);
|
||||
static UBool findUniqueValue(const char16_t *pos, UBool haveUniqueValue, int32_t &uniqueValue);
|
||||
|
||||
// Helper functions for getNextUChars().
|
||||
// getNextUChars() when pos is on a branch node.
|
||||
static void getNextBranchUChars(const UChar *pos, int32_t length, Appendable &out);
|
||||
static void getNextBranchUChars(const char16_t *pos, int32_t length, Appendable &out);
|
||||
|
||||
// UCharsTrie data structure
|
||||
//
|
||||
// The trie consists of a series of UChar-serialized nodes for incremental
|
||||
// Unicode string/UChar sequence matching. (UChar=16-bit unsigned integer)
|
||||
// The trie consists of a series of char16_t-serialized nodes for incremental
|
||||
// Unicode string/char16_t sequence matching. (char16_t=16-bit unsigned integer)
|
||||
// The root node is at the beginning of the trie data.
|
||||
//
|
||||
// Types of nodes are distinguished by their node lead unit ranges.
|
||||
|
|
@ -491,9 +491,9 @@ private:
|
|||
//
|
||||
// Node types:
|
||||
// - Final-value node: Stores a 32-bit integer in a compact, variable-length format.
|
||||
// The value is for the string/UChar sequence so far.
|
||||
// The value is for the string/char16_t sequence so far.
|
||||
// - Match node, optionally with an intermediate value in a different compact format.
|
||||
// The value, if present, is for the string/UChar sequence so far.
|
||||
// The value, if present, is for the string/char16_t sequence so far.
|
||||
//
|
||||
// Aside from the value, which uses the node lead unit's high bits:
|
||||
//
|
||||
|
|
@ -560,15 +560,15 @@ private:
|
|||
|
||||
static const int32_t kMaxTwoUnitDelta=((kThreeUnitDeltaLead-kMinTwoUnitDeltaLead)<<16)-1; // 0x03feffff
|
||||
|
||||
UChar *ownedArray_;
|
||||
char16_t *ownedArray_;
|
||||
|
||||
// Fixed value referencing the UCharsTrie words.
|
||||
const UChar *uchars_;
|
||||
const char16_t *uchars_;
|
||||
|
||||
// Iterator variables.
|
||||
|
||||
// Pointer to next trie unit to read. NULL if no more matches.
|
||||
const UChar *pos_;
|
||||
const char16_t *pos_;
|
||||
// Remaining length of a linear-match node, minus 1. Negative if not in such a node.
|
||||
int32_t remainingMatchLength_;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -89,21 +89,21 @@ public:
|
|||
UCharsTrie *build(UStringTrieBuildOption buildOption, UErrorCode &errorCode);
|
||||
|
||||
/**
|
||||
* Builds a UCharsTrie for the add()ed data and UChar-serializes it.
|
||||
* Builds a UCharsTrie for the add()ed data and char16_t-serializes it.
|
||||
* Once built, no further data can be add()ed until clear() is called.
|
||||
*
|
||||
* A UCharsTrie cannot be empty. At least one (string, value) pair
|
||||
* must have been add()ed.
|
||||
*
|
||||
* Multiple calls to buildUnicodeString() set the UnicodeStrings to the
|
||||
* builder's same UChar array, without rebuilding.
|
||||
* builder's same char16_t array, without rebuilding.
|
||||
* If buildUnicodeString() is called after build(), the trie will be
|
||||
* re-serialized into a new array.
|
||||
* If build() is called after buildUnicodeString(), the trie object will become
|
||||
* the owner of the previously returned array.
|
||||
* After clear() has been called, a new array will be used as well.
|
||||
* @param buildOption Build option, see UStringTrieBuildOption.
|
||||
* @param result A UnicodeString which will be set to the UChar-serialized
|
||||
* @param result A UnicodeString which will be set to the char16_t-serialized
|
||||
* UCharsTrie for the add()ed data.
|
||||
* @param errorCode Standard ICU error code. Its input value must
|
||||
* pass the U_SUCCESS() test, or else the function returns
|
||||
|
|
@ -135,14 +135,14 @@ private:
|
|||
void buildUChars(UStringTrieBuildOption buildOption, UErrorCode &errorCode);
|
||||
|
||||
virtual int32_t getElementStringLength(int32_t i) const;
|
||||
virtual UChar getElementUnit(int32_t i, int32_t unitIndex) const;
|
||||
virtual char16_t getElementUnit(int32_t i, int32_t unitIndex) const;
|
||||
virtual int32_t getElementValue(int32_t i) const;
|
||||
|
||||
virtual int32_t getLimitOfLinearMatch(int32_t first, int32_t last, int32_t unitIndex) const;
|
||||
|
||||
virtual int32_t countElementUnits(int32_t start, int32_t limit, int32_t unitIndex) const;
|
||||
virtual int32_t skipElementsBySomeUnits(int32_t i, int32_t unitIndex, int32_t count) const;
|
||||
virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, UChar unit) const;
|
||||
virtual int32_t indexOfElementWithNextUnit(int32_t i, int32_t unitIndex, char16_t unit) const;
|
||||
|
||||
virtual UBool matchNodesCanHaveValues() const { return TRUE; }
|
||||
|
||||
|
|
@ -152,11 +152,11 @@ private:
|
|||
|
||||
class UCTLinearMatchNode : public LinearMatchNode {
|
||||
public:
|
||||
UCTLinearMatchNode(const UChar *units, int32_t len, Node *nextNode);
|
||||
UCTLinearMatchNode(const char16_t *units, int32_t len, Node *nextNode);
|
||||
virtual UBool operator==(const Node &other) const;
|
||||
virtual void write(StringTrieBuilder &builder);
|
||||
private:
|
||||
const UChar *s;
|
||||
const char16_t *s;
|
||||
};
|
||||
|
||||
virtual Node *createLinearMatchNode(int32_t i, int32_t unitIndex, int32_t length,
|
||||
|
|
@ -164,7 +164,7 @@ private:
|
|||
|
||||
UBool ensureCapacity(int32_t length);
|
||||
virtual int32_t write(int32_t unit);
|
||||
int32_t write(const UChar *s, int32_t length);
|
||||
int32_t write(const char16_t *s, int32_t length);
|
||||
virtual int32_t writeElementUnits(int32_t i, int32_t unitIndex, int32_t length);
|
||||
virtual int32_t writeValueAndFinal(int32_t i, UBool isFinal);
|
||||
virtual int32_t writeValueAndType(UBool hasValue, int32_t value, int32_t node);
|
||||
|
|
@ -175,9 +175,9 @@ private:
|
|||
int32_t elementsCapacity;
|
||||
int32_t elementsLength;
|
||||
|
||||
// UChar serialization of the trie.
|
||||
// char16_t serialization of the trie.
|
||||
// Grows from the back: ucharsLength measures from the end of the buffer!
|
||||
UChar *uchars;
|
||||
char16_t *uchars;
|
||||
int32_t ucharsCapacity;
|
||||
int32_t ucharsLength;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -15,18 +15,18 @@
|
|||
|
||||
/**
|
||||
* \file
|
||||
* \brief C++ API: UChar Character Iterator
|
||||
* \brief C++ API: char16_t Character Iterator
|
||||
*/
|
||||
|
||||
U_NAMESPACE_BEGIN
|
||||
|
||||
/**
|
||||
* A concrete subclass of CharacterIterator that iterates over the
|
||||
* characters (code units or code points) in a UChar array.
|
||||
* characters (code units or code points) in a char16_t array.
|
||||
* It's possible not only to create an
|
||||
* iterator that iterates over an entire UChar array, but also to
|
||||
* create one that iterates over only a subrange of a UChar array
|
||||
* (iterators over different subranges of the same UChar array don't
|
||||
* iterator that iterates over an entire char16_t array, but also to
|
||||
* create one that iterates over only a subrange of a char16_t array
|
||||
* (iterators over different subranges of the same char16_t array don't
|
||||
* compare equal).
|
||||
* @see CharacterIterator
|
||||
* @see ForwardCharacterIterator
|
||||
|
|
@ -35,34 +35,34 @@ U_NAMESPACE_BEGIN
|
|||
class U_COMMON_API UCharCharacterIterator : public CharacterIterator {
|
||||
public:
|
||||
/**
|
||||
* Create an iterator over the UChar array referred to by "textPtr".
|
||||
* Create an iterator over the char16_t array referred to by "textPtr".
|
||||
* The iteration range is 0 to <code>length-1</code>.
|
||||
* text is only aliased, not adopted (the
|
||||
* destructor will not delete it).
|
||||
* @param textPtr The UChar array to be iterated over
|
||||
* @param length The length of the UChar array
|
||||
* @param textPtr The char16_t array to be iterated over
|
||||
* @param length The length of the char16_t array
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
UCharCharacterIterator(const UChar* textPtr, int32_t length);
|
||||
UCharCharacterIterator(ConstChar16Ptr textPtr, int32_t length);
|
||||
|
||||
/**
|
||||
* Create an iterator over the UChar array referred to by "textPtr".
|
||||
* Create an iterator over the char16_t array referred to by "textPtr".
|
||||
* The iteration range is 0 to <code>length-1</code>.
|
||||
* text is only aliased, not adopted (the
|
||||
* destructor will not delete it).
|
||||
* The starting
|
||||
* position is specified by "position". If "position" is outside the valid
|
||||
* iteration range, the behavior of this object is undefined.
|
||||
* @param textPtr The UChar array to be iteratd over
|
||||
* @param length The length of the UChar array
|
||||
* @param textPtr The char16_t array to be iteratd over
|
||||
* @param length The length of the char16_t array
|
||||
* @param position The starting position of the iteration
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
UCharCharacterIterator(const UChar* textPtr, int32_t length,
|
||||
UCharCharacterIterator(ConstChar16Ptr textPtr, int32_t length,
|
||||
int32_t position);
|
||||
|
||||
/**
|
||||
* Create an iterator over the UChar array referred to by "textPtr".
|
||||
* Create an iterator over the char16_t array referred to by "textPtr".
|
||||
* The iteration range is 0 to <code>end-1</code>.
|
||||
* text is only aliased, not adopted (the
|
||||
* destructor will not delete it).
|
||||
|
|
@ -70,14 +70,14 @@ public:
|
|||
* position is specified by "position". If begin and end do not
|
||||
* form a valid iteration range or "position" is outside the valid
|
||||
* iteration range, the behavior of this object is undefined.
|
||||
* @param textPtr The UChar array to be iterated over
|
||||
* @param length The length of the UChar array
|
||||
* @param textPtr The char16_t array to be iterated over
|
||||
* @param length The length of the char16_t array
|
||||
* @param textBegin The begin position of the iteration range
|
||||
* @param textEnd The end position of the iteration range
|
||||
* @param position The starting position of the iteration
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
UCharCharacterIterator(const UChar* textPtr, int32_t length,
|
||||
UCharCharacterIterator(ConstChar16Ptr textPtr, int32_t length,
|
||||
int32_t textBegin,
|
||||
int32_t textEnd,
|
||||
int32_t position);
|
||||
|
|
@ -141,7 +141,7 @@ public:
|
|||
* @return the first code unit in its iteration range.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar first(void);
|
||||
virtual char16_t first(void);
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the first code unit in its
|
||||
|
|
@ -151,7 +151,7 @@ public:
|
|||
* @return the first code unit in its iteration range
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar firstPostInc(void);
|
||||
virtual char16_t firstPostInc(void);
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the first code point in its
|
||||
|
|
@ -181,7 +181,7 @@ public:
|
|||
* @return the last code unit in its iteration range.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar last(void);
|
||||
virtual char16_t last(void);
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the last code point in its
|
||||
|
|
@ -200,7 +200,7 @@ public:
|
|||
* @return the code unit
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar setIndex(int32_t position);
|
||||
virtual char16_t setIndex(int32_t position);
|
||||
|
||||
/**
|
||||
* Sets the iterator to refer to the beginning of the code point
|
||||
|
|
@ -220,7 +220,7 @@ public:
|
|||
* @return the code unit the iterator currently refers to.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar current(void) const;
|
||||
virtual char16_t current(void) const;
|
||||
|
||||
/**
|
||||
* Returns the code point the iterator currently refers to.
|
||||
|
|
@ -236,7 +236,7 @@ public:
|
|||
* @return the next code unit in the iteration range.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar next(void);
|
||||
virtual char16_t next(void);
|
||||
|
||||
/**
|
||||
* Gets the current code unit for returning and advances to the next code unit
|
||||
|
|
@ -246,7 +246,7 @@ public:
|
|||
* @return the current code unit.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar nextPostInc(void);
|
||||
virtual char16_t nextPostInc(void);
|
||||
|
||||
/**
|
||||
* Advances to the next code point in the iteration range (toward
|
||||
|
|
@ -288,7 +288,7 @@ public:
|
|||
* @return the previous code unit in the iteration range.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual UChar previous(void);
|
||||
virtual char16_t previous(void);
|
||||
|
||||
/**
|
||||
* Advances to the previous code point in the iteration range (toward
|
||||
|
|
@ -340,10 +340,10 @@ public:
|
|||
* Sets the iterator to iterate over a new range of text
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
void setText(const UChar* newText, int32_t newTextLength);
|
||||
void setText(ConstChar16Ptr newText, int32_t newTextLength);
|
||||
|
||||
/**
|
||||
* Copies the UChar array under iteration into the UnicodeString
|
||||
* Copies the char16_t array under iteration into the UnicodeString
|
||||
* referred to by "result". Even if this iterator iterates across
|
||||
* only a part of this string, the whole string is copied.
|
||||
* @param result Receives a copy of the text under iteration.
|
||||
|
|
@ -375,7 +375,7 @@ protected:
|
|||
* Protected member text
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
const UChar* text;
|
||||
const char16_t* text;
|
||||
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -301,32 +301,75 @@ typedef int8_t UBool;
|
|||
/**
|
||||
* \var UChar
|
||||
*
|
||||
* For C++, UChar is always defined to be char16_t.
|
||||
* The base type for UTF-16 code units and pointers.
|
||||
* Unsigned 16-bit integer.
|
||||
* Starting with ICU 59, C++ API uses char16_t directly, while C API continues to use UChar.
|
||||
*
|
||||
* For plain C, define UChar to be UCHAR_TYPE, if that is #defined (for example, to char16_t),
|
||||
* or wchar_t if that is 16 bits wide; always assumed to be unsigned.
|
||||
* If neither is available, then define UChar to be uint16_t.
|
||||
* UChar is configurable by defining the macro UCHAR_TYPE
|
||||
* on the preprocessor or compiler command line:
|
||||
* -DUCHAR_TYPE=uint16_t or -DUCHAR_TYPE=wchar_t (if U_SIZEOF_WCHAR_T==2) etc.
|
||||
* (The UCHAR_TYPE can also be #defined earlier in this file, for outside the ICU library code.)
|
||||
* This is for transitional use from application code that uses uint16_t or wchar_t for UTF-16.
|
||||
*
|
||||
* This makes the definition of UChar platform-dependent
|
||||
* but allows direct string type compatibility with platforms with
|
||||
* 16-bit wchar_t types.
|
||||
* The default is UChar=char16_t.
|
||||
*
|
||||
* C++11 defines char16_t as bit-compatible with uint16_t, but as a distinct type.
|
||||
*
|
||||
* In C, char16_t is a simple typedef of uint_least16_t.
|
||||
* ICU requires uint_least16_t=uint16_t for data memory mapping.
|
||||
* On macOS, char16_t is not available because the uchar.h standard header is missing.
|
||||
*
|
||||
* @stable ICU 4.4
|
||||
*/
|
||||
#ifdef __cplusplus
|
||||
|
||||
#if 1
|
||||
// #if 1 is normal. UChar defaults to char16_t in C++.
|
||||
// For configuration testing of UChar=uint16_t temporarily change this to #if 0.
|
||||
// The intltest Makefile #defines UCHAR_TYPE=char16_t,
|
||||
// so we only #define it to uint16_t if it is undefined so far.
|
||||
#elif !defined(UCHAR_TYPE)
|
||||
# define UCHAR_TYPE uint16_t
|
||||
#endif
|
||||
|
||||
#if defined(U_COMBINED_IMPLEMENTATION) || defined(U_COMMON_IMPLEMENTATION) || \
|
||||
defined(U_I18N_IMPLEMENTATION) || defined(U_IO_IMPLEMENTATION)
|
||||
// Inside the ICU library code, never configurable.
|
||||
typedef char16_t UChar;
|
||||
#elif defined(UCHAR_TYPE)
|
||||
typedef UCHAR_TYPE UChar;
|
||||
#elif U_SIZEOF_WCHAR_T==2
|
||||
typedef wchar_t UChar;
|
||||
#elif U_HAVE_CHAR16_T
|
||||
#elif defined(__cplusplus)
|
||||
typedef char16_t UChar;
|
||||
#elif defined(__CHAR16_TYPE__)
|
||||
typedef __CHAR16_TYPE__ UChar;
|
||||
#else
|
||||
typedef uint16_t UChar;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* \var OldUChar
|
||||
* Default ICU 58 definition of UChar.
|
||||
* A base type for UTF-16 code units and pointers.
|
||||
* Unsigned 16-bit integer.
|
||||
*
|
||||
* Define OldUChar to be wchar_t if that is 16 bits wide.
|
||||
* If wchar_t is not 16 bits wide, then define UChar to be uint16_t.
|
||||
*
|
||||
* This makes the definition of OldUChar platform-dependent
|
||||
* but allows direct string type compatibility with platforms with
|
||||
* 16-bit wchar_t types.
|
||||
*
|
||||
* This is how UChar was defined in ICU 58, for transition convenience.
|
||||
* Exception: ICU 58 UChar was defined to UCHAR_TYPE if that macro was defined.
|
||||
* The current UChar responds to UCHAR_TYPE but OldUChar does not.
|
||||
*
|
||||
* @draft ICU 59
|
||||
*/
|
||||
#if U_SIZEOF_WCHAR_T==2
|
||||
typedef wchar_t OldUChar;
|
||||
#elif defined(__CHAR16_TYPE__)
|
||||
typedef __CHAR16_TYPE__ OldUChar;
|
||||
#else
|
||||
typedef uint16_t OldUChar;
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Define UChar32 as a type for single Unicode code points.
|
||||
* UChar32 is a signed 32-bit integer (same as int32_t).
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ U_NAMESPACE_BEGIN
|
|||
* defined range.
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
#define U_ETHER ((UChar)0xFFFF)
|
||||
#define U_ETHER ((char16_t)0xFFFF)
|
||||
|
||||
/**
|
||||
*
|
||||
|
|
|
|||
|
|
@ -294,7 +294,7 @@ class U_COMMON_API UnicodeSet U_FINAL : public UnicodeFilter {
|
|||
* indicating that toPattern() must generate a pattern
|
||||
* representation from the inversion list.
|
||||
*/
|
||||
UChar *pat;
|
||||
char16_t *pat;
|
||||
UVector* strings; // maintained in sorted order
|
||||
UnicodeSetStringSpan *stringSpan;
|
||||
|
||||
|
|
@ -891,7 +891,7 @@ public:
|
|||
* @stable ICU 3.8
|
||||
* @see USetSpanCondition
|
||||
*/
|
||||
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;
|
||||
|
||||
/**
|
||||
* Returns the end of the substring of the input string according to the USetSpanCondition.
|
||||
|
|
@ -924,7 +924,7 @@ public:
|
|||
* @stable ICU 3.8
|
||||
* @see USetSpanCondition
|
||||
*/
|
||||
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;
|
||||
|
||||
/**
|
||||
* Returns the start of the substring of the input string according to the USetSpanCondition.
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -178,12 +178,12 @@
|
|||
|
||||
/**
|
||||
* \def NULL
|
||||
* Define NULL if necessary, to 0 for C++ and to ((void *)0) for C.
|
||||
* Define NULL if necessary, to nullptr for C++ and to ((void *)0) for C.
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
#ifndef NULL
|
||||
#ifdef __cplusplus
|
||||
#define NULL 0
|
||||
#define NULL nullptr
|
||||
#else
|
||||
#define NULL ((void *)0)
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -218,9 +218,10 @@ UnicodeString::UnicodeString(const UChar *text,
|
|||
}
|
||||
|
||||
UnicodeString::UnicodeString(UBool isTerminated,
|
||||
const UChar *text,
|
||||
ConstChar16Ptr textPtr,
|
||||
int32_t textLength) {
|
||||
fUnion.fFields.fLengthAndFlags = kReadonlyAlias;
|
||||
const UChar *text = textPtr;
|
||||
if(text == NULL) {
|
||||
// treat as an empty string, do not alias
|
||||
setToEmpty();
|
||||
|
|
@ -234,7 +235,8 @@ UnicodeString::UnicodeString(UBool isTerminated,
|
|||
// text is terminated, or else it would have failed the above test
|
||||
textLength = u_strlen(text);
|
||||
}
|
||||
setArray((UChar *)text, textLength, isTerminated ? textLength + 1 : textLength);
|
||||
setArray(const_cast<UChar *>(text), textLength,
|
||||
isTerminated ? textLength + 1 : textLength);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -873,7 +875,7 @@ UnicodeString::doExtract(int32_t start,
|
|||
}
|
||||
|
||||
int32_t
|
||||
UnicodeString::extract(UChar *dest, int32_t destCapacity,
|
||||
UnicodeString::extract(Char16Ptr dest, int32_t destCapacity,
|
||||
UErrorCode &errorCode) const {
|
||||
int32_t len = length();
|
||||
if(U_SUCCESS(errorCode)) {
|
||||
|
|
@ -1215,10 +1217,10 @@ UnicodeString::unBogus() {
|
|||
}
|
||||
}
|
||||
|
||||
const UChar *
|
||||
const char16_t *
|
||||
UnicodeString::getTerminatedBuffer() {
|
||||
if(!isWritable()) {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
UChar *array = getArrayStart();
|
||||
int32_t len = length();
|
||||
|
|
@ -1249,14 +1251,14 @@ UnicodeString::getTerminatedBuffer() {
|
|||
array[len] = 0;
|
||||
return array;
|
||||
} else {
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
// setTo() analogous to the readonly-aliasing constructor with the same signature
|
||||
UnicodeString &
|
||||
UnicodeString::setTo(UBool isTerminated,
|
||||
const UChar *text,
|
||||
ConstChar16Ptr textPtr,
|
||||
int32_t textLength)
|
||||
{
|
||||
if(fUnion.fFields.fLengthAndFlags & kOpenGetBuffer) {
|
||||
|
|
@ -1264,6 +1266,7 @@ UnicodeString::setTo(UBool isTerminated,
|
|||
return *this;
|
||||
}
|
||||
|
||||
const UChar *text = textPtr;
|
||||
if(text == NULL) {
|
||||
// treat as an empty string, do not alias
|
||||
releaseArray();
|
||||
|
|
@ -1713,14 +1716,14 @@ UnicodeString::doHashCode() const
|
|||
// External Buffer
|
||||
//========================================
|
||||
|
||||
UChar *
|
||||
char16_t *
|
||||
UnicodeString::getBuffer(int32_t minCapacity) {
|
||||
if(minCapacity>=-1 && cloneArrayIfNeeded(minCapacity)) {
|
||||
fUnion.fFields.fLengthAndFlags|=kOpenGetBuffer;
|
||||
setZeroLength();
|
||||
return getArrayStart();
|
||||
} else {
|
||||
return 0;
|
||||
return nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -2242,13 +2242,13 @@ unistrTextCopy(UText *ut,
|
|||
}
|
||||
|
||||
if(move) {
|
||||
// move: copy to destIndex, then replace original with nothing
|
||||
// move: copy to destIndex, then remove original
|
||||
int32_t segLength=limit32-start32;
|
||||
us->copy(start32, limit32, destIndex32);
|
||||
if(destIndex32<start32) {
|
||||
start32+=segLength;
|
||||
}
|
||||
us->replace(start32, segLength, NULL, 0);
|
||||
us->remove(start32, segLength);
|
||||
} else {
|
||||
// copy
|
||||
us->copy(start32, limit32, destIndex32);
|
||||
|
|
|
|||
|
|
@ -13,6 +13,7 @@
|
|||
|
||||
#include "unicode/utypes.h"
|
||||
|
||||
// This file contains only desktop Windows behavior
|
||||
#if U_PLATFORM_HAS_WIN32_API
|
||||
|
||||
#include "wintz.h"
|
||||
|
|
@ -46,102 +47,25 @@ typedef struct
|
|||
* Various registry keys and key fragments.
|
||||
*/
|
||||
static const char CURRENT_ZONE_REGKEY[] = "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation\\";
|
||||
/* static const char STANDARD_NAME_REGKEY[] = "StandardName"; Currently unused constant */
|
||||
static const char STANDARD_TIME_REGKEY[] = " Standard Time";
|
||||
static const char TZI_REGKEY[] = "TZI";
|
||||
static const char STD_REGKEY[] = "Std";
|
||||
|
||||
/**
|
||||
* HKLM subkeys used to probe for the flavor of Windows. Note that we
|
||||
* specifically check for the "GMT" zone subkey; this is present on
|
||||
* NT, but on XP has become "GMT Standard Time". We need to
|
||||
* discriminate between these cases.
|
||||
* The time zone root keys (under HKLM) for Win7+
|
||||
*/
|
||||
static const char* const WIN_TYPE_PROBE_REGKEY[] = {
|
||||
/* WIN_9X_ME_TYPE */
|
||||
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Time Zones",
|
||||
|
||||
/* WIN_NT_TYPE */
|
||||
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\GMT"
|
||||
|
||||
/* otherwise: WIN_2K_XP_TYPE */
|
||||
};
|
||||
|
||||
/**
|
||||
* The time zone root subkeys (under HKLM) for different flavors of
|
||||
* Windows.
|
||||
*/
|
||||
static const char* const TZ_REGKEY[] = {
|
||||
/* WIN_9X_ME_TYPE */
|
||||
"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Time Zones\\",
|
||||
|
||||
/* WIN_NT_TYPE | WIN_2K_XP_TYPE */
|
||||
"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\"
|
||||
};
|
||||
|
||||
/**
|
||||
* Flavor of Windows, from our perspective. Not a real OS version,
|
||||
* but rather the flavor of the layout of the time zone information in
|
||||
* the registry.
|
||||
*/
|
||||
enum {
|
||||
WIN_9X_ME_TYPE = 1,
|
||||
WIN_NT_TYPE = 2,
|
||||
WIN_2K_XP_TYPE = 3
|
||||
};
|
||||
|
||||
static int32_t gWinType = 0;
|
||||
|
||||
static int32_t detectWindowsType()
|
||||
{
|
||||
int32_t winType;
|
||||
LONG result;
|
||||
HKEY hkey;
|
||||
|
||||
/* Detect the version of windows by trying to open a sequence of
|
||||
probe keys. We don't use the OS version API because what we
|
||||
really want to know is how the registry is laid out.
|
||||
Specifically, is it 9x/Me or not, and is it "GMT" or "GMT
|
||||
Standard Time". */
|
||||
for (winType = 0; winType < 2; winType++) {
|
||||
result = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
|
||||
WIN_TYPE_PROBE_REGKEY[winType],
|
||||
0,
|
||||
KEY_QUERY_VALUE,
|
||||
&hkey);
|
||||
RegCloseKey(hkey);
|
||||
|
||||
if (result == ERROR_SUCCESS) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return winType+1; /* +1 to bring it inline with the enum */
|
||||
}
|
||||
static const char TZ_REGKEY[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\";
|
||||
|
||||
static LONG openTZRegKey(HKEY *hkey, const char *winid)
|
||||
{
|
||||
char subKeyName[110]; /* TODO: why 96?? */
|
||||
char subKeyName[110]; /* TODO: why 110?? */
|
||||
char *name;
|
||||
LONG result;
|
||||
|
||||
/* This isn't thread safe, but it's good enough because the result should be constant per system. */
|
||||
if (gWinType <= 0) {
|
||||
gWinType = detectWindowsType();
|
||||
}
|
||||
|
||||
uprv_strcpy(subKeyName, TZ_REGKEY[(gWinType != WIN_9X_ME_TYPE)]);
|
||||
uprv_strcpy(subKeyName, TZ_REGKEY);
|
||||
name = &subKeyName[strlen(subKeyName)];
|
||||
uprv_strcat(subKeyName, winid);
|
||||
|
||||
if (gWinType == WIN_9X_ME_TYPE) {
|
||||
/* Remove " Standard Time" */
|
||||
char *pStd = uprv_strstr(subKeyName, STANDARD_TIME_REGKEY);
|
||||
if (pStd) {
|
||||
*pStd = 0;
|
||||
}
|
||||
}
|
||||
|
||||
result = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
|
||||
subKeyName,
|
||||
0,
|
||||
|
|
@ -158,7 +82,8 @@ static LONG getTZI(const char *winid, TZI *tzi)
|
|||
|
||||
result = openTZRegKey(&hkey, winid);
|
||||
|
||||
if (result == ERROR_SUCCESS) {
|
||||
if (result == ERROR_SUCCESS)
|
||||
{
|
||||
result = RegQueryValueExA(hkey,
|
||||
TZI_REGKEY,
|
||||
NULL,
|
||||
|
|
@ -171,14 +96,16 @@ static LONG getTZI(const char *winid, TZI *tzi)
|
|||
return result;
|
||||
}
|
||||
|
||||
static LONG getSTDName(const char *winid, char *regStdName, int32_t length) {
|
||||
static LONG getSTDName(const char *winid, char *regStdName, int32_t length)
|
||||
{
|
||||
DWORD cbData = length;
|
||||
LONG result;
|
||||
HKEY hkey;
|
||||
|
||||
result = openTZRegKey(&hkey, winid);
|
||||
|
||||
if (result == ERROR_SUCCESS) {
|
||||
if (result == ERROR_SUCCESS)
|
||||
{
|
||||
result = RegQueryValueExA(hkey,
|
||||
STD_REGKEY,
|
||||
NULL,
|
||||
|
|
@ -191,7 +118,8 @@ static LONG getSTDName(const char *winid, char *regStdName, int32_t length) {
|
|||
return result;
|
||||
}
|
||||
|
||||
static LONG getTZKeyName(char* tzKeyName, int32_t length) {
|
||||
static LONG getTZKeyName(char* tzKeyName, int32_t length)
|
||||
{
|
||||
HKEY hkey;
|
||||
LONG result = FALSE;
|
||||
DWORD cbData = length;
|
||||
|
|
@ -218,21 +146,19 @@ static LONG getTZKeyName(char* tzKeyName, int32_t length) {
|
|||
}
|
||||
|
||||
/*
|
||||
This code attempts to detect the Windows time zone, as set in the
|
||||
Windows Date and Time control panel. It attempts to work on
|
||||
multiple flavors of Windows (9x, Me, NT, 2000, XP) and on localized
|
||||
This code attempts to detect the Windows time zone directly,
|
||||
as set in the Windows Date and Time control panel. It attempts
|
||||
to work on versions greater than Windows Vista and on localized
|
||||
installs. It works by directly interrogating the registry and
|
||||
comparing the data there with the data returned by the
|
||||
GetTimeZoneInformation API, along with some other strategies. The
|
||||
registry contains time zone data under one of two keys (depending on
|
||||
the flavor of Windows):
|
||||
registry contains time zone data under this key:
|
||||
|
||||
HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zones\
|
||||
HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones\
|
||||
|
||||
Under this key are several subkeys, one for each time zone. These
|
||||
subkeys are named "Pacific" on Win9x/Me and "Pacific Standard Time"
|
||||
on WinNT/2k/XP. There are some other wrinkles; see the code for
|
||||
Under this key are several subkeys, one for each time zone. For
|
||||
example these subkeys are named "Pacific Standard Time" on Vista+.
|
||||
There are some other wrinkles; see the code for
|
||||
details. The subkey name is NOT LOCALIZED, allowing us to support
|
||||
localized installs.
|
||||
|
||||
|
|
@ -270,7 +196,8 @@ static LONG getTZKeyName(char* tzKeyName, int32_t length) {
|
|||
* time zone, translated to an ICU time zone, or NULL upon failure.
|
||||
*/
|
||||
U_CFUNC const char* U_EXPORT2
|
||||
uprv_detectWindowsTimeZone() {
|
||||
uprv_detectWindowsTimeZone()
|
||||
{
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
UResourceBundle* bundle = NULL;
|
||||
char* icuid = NULL;
|
||||
|
|
@ -288,7 +215,6 @@ uprv_detectWindowsTimeZone() {
|
|||
TZI tziReg;
|
||||
TIME_ZONE_INFORMATION apiTZI;
|
||||
|
||||
BOOL isVistaOrHigher;
|
||||
BOOL tryPreVistaFallback;
|
||||
OSVERSIONINFO osVerInfo;
|
||||
|
||||
|
|
@ -325,75 +251,86 @@ uprv_detectWindowsTimeZone() {
|
|||
*/
|
||||
uprv_memset(&osVerInfo, 0, sizeof(osVerInfo));
|
||||
osVerInfo.dwOSVersionInfoSize = sizeof(osVerInfo);
|
||||
GetVersionEx(&osVerInfo);
|
||||
isVistaOrHigher = osVerInfo.dwMajorVersion >= 6; /* actually includes Windows Server 2008 as well, but don't worry about it */
|
||||
tryPreVistaFallback = TRUE;
|
||||
if(isVistaOrHigher) {
|
||||
result = getTZKeyName(regStdName, sizeof(regStdName));
|
||||
if(ERROR_SUCCESS == result) {
|
||||
UResourceBundle* winTZ = ures_getByKey(bundle, regStdName, NULL, &status);
|
||||
if(U_SUCCESS(status)) {
|
||||
const UChar* icuTZ = NULL;
|
||||
if (errorCode != 0) {
|
||||
icuTZ = ures_getStringByKey(winTZ, ISOcodeA, &len, &status);
|
||||
}
|
||||
if (errorCode==0 || icuTZ==NULL) {
|
||||
/* fallback to default "001" and reset status */
|
||||
status = U_ZERO_ERROR;
|
||||
icuTZ = ures_getStringByKey(winTZ, "001", &len, &status);
|
||||
}
|
||||
|
||||
if(U_SUCCESS(status)) {
|
||||
int index=0;
|
||||
while (! (*icuTZ == '\0' || *icuTZ ==' ')) {
|
||||
tmpid[index++]=(char)(*icuTZ++); /* safe to assume 'char' is ASCII compatible on windows */
|
||||
}
|
||||
tmpid[index]='\0';
|
||||
tryPreVistaFallback = FALSE;
|
||||
}
|
||||
result = getTZKeyName(regStdName, sizeof(regStdName));
|
||||
if(ERROR_SUCCESS == result)
|
||||
{
|
||||
UResourceBundle* winTZ = ures_getByKey(bundle, regStdName, NULL, &status);
|
||||
if(U_SUCCESS(status))
|
||||
{
|
||||
const UChar* icuTZ = NULL;
|
||||
if (errorCode != 0)
|
||||
{
|
||||
icuTZ = ures_getStringByKey(winTZ, ISOcodeA, &len, &status);
|
||||
}
|
||||
if (errorCode==0 || icuTZ==NULL)
|
||||
{
|
||||
/* fallback to default "001" and reset status */
|
||||
status = U_ZERO_ERROR;
|
||||
icuTZ = ures_getStringByKey(winTZ, "001", &len, &status);
|
||||
}
|
||||
|
||||
if(U_SUCCESS(status))
|
||||
{
|
||||
int index=0;
|
||||
while (! (*icuTZ == '\0' || *icuTZ ==' '))
|
||||
{
|
||||
tmpid[index++]=(char)(*icuTZ++); /* safe to assume 'char' is ASCII compatible on windows */
|
||||
}
|
||||
tmpid[index]='\0';
|
||||
tryPreVistaFallback = FALSE;
|
||||
}
|
||||
ures_close(winTZ);
|
||||
}
|
||||
ures_close(winTZ);
|
||||
}
|
||||
|
||||
if(tryPreVistaFallback) {
|
||||
|
||||
if(tryPreVistaFallback)
|
||||
{
|
||||
/* Note: We get the winid not from static tables but from resource bundle. */
|
||||
while (U_SUCCESS(status) && ures_hasNext(bundle)) {
|
||||
while (U_SUCCESS(status) && ures_hasNext(bundle))
|
||||
{
|
||||
UBool idFound = FALSE;
|
||||
const char* winid;
|
||||
UResourceBundle* winTZ = ures_getNextResource(bundle, NULL, &status);
|
||||
if (U_FAILURE(status)) {
|
||||
if (U_FAILURE(status))
|
||||
{
|
||||
break;
|
||||
}
|
||||
winid = ures_getKey(winTZ);
|
||||
result = getTZI(winid, &tziReg);
|
||||
|
||||
if (result == ERROR_SUCCESS) {
|
||||
if (result == ERROR_SUCCESS)
|
||||
{
|
||||
/* Windows alters the DaylightBias in some situations.
|
||||
Using the bias and the rules suffices, so overwrite
|
||||
these unreliable fields. */
|
||||
tziKey.standardBias = tziReg.standardBias;
|
||||
tziKey.daylightBias = tziReg.daylightBias;
|
||||
|
||||
if (uprv_memcmp((char *)&tziKey, (char*)&tziReg, sizeof(tziKey)) == 0) {
|
||||
if (uprv_memcmp((char *)&tziKey, (char*)&tziReg, sizeof(tziKey)) == 0)
|
||||
{
|
||||
const UChar* icuTZ = NULL;
|
||||
if (errorCode != 0) {
|
||||
if (errorCode != 0)
|
||||
{
|
||||
icuTZ = ures_getStringByKey(winTZ, ISOcodeA, &len, &status);
|
||||
}
|
||||
if (errorCode==0 || icuTZ==NULL) {
|
||||
if (errorCode==0 || icuTZ==NULL)
|
||||
{
|
||||
/* fallback to default "001" and reset status */
|
||||
status = U_ZERO_ERROR;
|
||||
icuTZ = ures_getStringByKey(winTZ, "001", &len, &status);
|
||||
}
|
||||
|
||||
if (U_SUCCESS(status)) {
|
||||
if (U_SUCCESS(status))
|
||||
{
|
||||
/* Get the standard name from the registry key to compare with
|
||||
the one from Windows API call. */
|
||||
uprv_memset(regStdName, 0, sizeof(regStdName));
|
||||
result = getSTDName(winid, regStdName, sizeof(regStdName));
|
||||
if (result == ERROR_SUCCESS) {
|
||||
if (uprv_strcmp(apiStdName, regStdName) == 0) {
|
||||
if (result == ERROR_SUCCESS)
|
||||
{
|
||||
if (uprv_strcmp(apiStdName, regStdName) == 0)
|
||||
{
|
||||
idFound = TRUE;
|
||||
}
|
||||
}
|
||||
|
|
@ -402,10 +339,12 @@ uprv_detectWindowsTimeZone() {
|
|||
* If none is found, tmpid buffer will contain a fallback ID (i.e. the time zone ID matching
|
||||
* the current time zone information)
|
||||
*/
|
||||
if (idFound || tmpid[0] == 0) {
|
||||
if (idFound || tmpid[0] == 0)
|
||||
{
|
||||
/* if icuTZ has more than one city, take only the first (i.e. terminate icuTZ at first space) */
|
||||
int index=0;
|
||||
while (! (*icuTZ == '\0' || *icuTZ ==' ')) {
|
||||
while (! (*icuTZ == '\0' || *icuTZ ==' '))
|
||||
{
|
||||
tmpid[index++]=(char)(*icuTZ++); /* safe to assume 'char' is ASCII compatible on windows */
|
||||
}
|
||||
tmpid[index]='\0';
|
||||
|
|
@ -414,7 +353,8 @@ uprv_detectWindowsTimeZone() {
|
|||
}
|
||||
}
|
||||
ures_close(winTZ);
|
||||
if (idFound) {
|
||||
if (idFound)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -423,10 +363,12 @@ uprv_detectWindowsTimeZone() {
|
|||
/*
|
||||
* Copy the timezone ID to icuid to be returned.
|
||||
*/
|
||||
if (tmpid[0] != 0) {
|
||||
if (tmpid[0] != 0)
|
||||
{
|
||||
len = uprv_strlen(tmpid);
|
||||
icuid = (char*)uprv_calloc(len + 1, sizeof(char));
|
||||
if (icuid != NULL) {
|
||||
if (icuid != NULL)
|
||||
{
|
||||
uprv_strcpy(icuid, tmpid);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1349,7 +1349,6 @@ AC_CONFIG_FILES([icudefs.mk \
|
|||
tools/pkgdata/Makefile \
|
||||
tools/tzcode/Makefile \
|
||||
tools/gencfu/Makefile \
|
||||
tools/escapesrc/Makefile \
|
||||
test/Makefile \
|
||||
test/compat/Makefile \
|
||||
test/testdata/Makefile \
|
||||
|
|
|
|||
|
|
@ -29,6 +29,7 @@
|
|||
|
||||
#if !UCONFIG_NO_COLLATION
|
||||
|
||||
#include "unicode/chariter.h"
|
||||
#include "unicode/coleitr.h"
|
||||
#include "unicode/tblcoll.h"
|
||||
#include "unicode/ustring.h"
|
||||
|
|
|
|||
|
|
@ -19,12 +19,12 @@
|
|||
|
||||
U_NAMESPACE_BEGIN
|
||||
|
||||
CurrencyAmount::CurrencyAmount(const Formattable& amount, const UChar* isoCode,
|
||||
CurrencyAmount::CurrencyAmount(const Formattable& amount, ConstChar16Ptr isoCode,
|
||||
UErrorCode& ec) :
|
||||
Measure(amount, new CurrencyUnit(isoCode, ec), ec) {
|
||||
}
|
||||
|
||||
CurrencyAmount::CurrencyAmount(double amount, const UChar* isoCode,
|
||||
CurrencyAmount::CurrencyAmount(double amount, ConstChar16Ptr isoCode,
|
||||
UErrorCode& ec) :
|
||||
Measure(Formattable(amount), new CurrencyUnit(isoCode, ec), ec) {
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,10 +19,10 @@
|
|||
|
||||
U_NAMESPACE_BEGIN
|
||||
|
||||
CurrencyUnit::CurrencyUnit(const UChar* _isoCode, UErrorCode& ec) {
|
||||
CurrencyUnit::CurrencyUnit(ConstChar16Ptr _isoCode, UErrorCode& ec) {
|
||||
*isoCode = 0;
|
||||
if (U_SUCCESS(ec)) {
|
||||
if (_isoCode && u_strlen(_isoCode)==3) {
|
||||
if (_isoCode != nullptr && u_strlen(_isoCode)==3) {
|
||||
u_strcpy(isoCode, _isoCode);
|
||||
char simpleIsoCode[4];
|
||||
u_UCharsToChars(isoCode, simpleIsoCode, 4);
|
||||
|
|
|
|||
|
|
@ -1368,7 +1368,7 @@ DateFormatSymbols::setZoneStrings(const UnicodeString* const *strings, int32_t r
|
|||
|
||||
//------------------------------------------------------
|
||||
|
||||
const UChar * U_EXPORT2
|
||||
const char16_t * U_EXPORT2
|
||||
DateFormatSymbols::getPatternUChars(void)
|
||||
{
|
||||
return gPatternChars;
|
||||
|
|
|
|||
|
|
@ -1188,7 +1188,7 @@ void NumberFormat::setCurrency(const UChar* theCurrency, UErrorCode& ec) {
|
|||
}
|
||||
}
|
||||
|
||||
const UChar* NumberFormat::getCurrency() const {
|
||||
const char16_t* NumberFormat::getCurrency() const {
|
||||
return fCurrency;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@
|
|||
|
||||
#include "unicode/uobject.h"
|
||||
#include "unicode/ucol.h"
|
||||
#include "unicode/normlzr.h"
|
||||
#include "unicode/unorm.h"
|
||||
#include "unicode/locid.h"
|
||||
#include "unicode/uniset.h"
|
||||
#include "unicode/umisc.h"
|
||||
|
|
@ -158,7 +158,7 @@ class CollationKey;
|
|||
* @see CollationKey
|
||||
* @see CollationElementIterator
|
||||
* @see Locale
|
||||
* @see Normalizer
|
||||
* @see Normalizer2
|
||||
* @version 2.0 11/15/01
|
||||
*/
|
||||
|
||||
|
|
@ -393,8 +393,8 @@ public:
|
|||
* is less than, greater than or equal to another string array.
|
||||
* <p>Example of use:
|
||||
* <pre>
|
||||
* . UChar ABC[] = {0x41, 0x42, 0x43, 0}; // = "ABC"
|
||||
* . UChar abc[] = {0x61, 0x62, 0x63, 0}; // = "abc"
|
||||
* . char16_t ABC[] = {0x41, 0x42, 0x43, 0}; // = "ABC"
|
||||
* . char16_t abc[] = {0x61, 0x62, 0x63, 0}; // = "abc"
|
||||
* . UErrorCode status = U_ZERO_ERROR;
|
||||
* . Collator *myCollation =
|
||||
* . Collator::createInstance(Locale::getUS(), status);
|
||||
|
|
@ -420,8 +420,8 @@ public:
|
|||
* target
|
||||
* @deprecated ICU 2.6 use the overload with UErrorCode &
|
||||
*/
|
||||
virtual EComparisonResult compare(const UChar* source, int32_t sourceLength,
|
||||
const UChar* target, int32_t targetLength)
|
||||
virtual EComparisonResult compare(const char16_t* source, int32_t sourceLength,
|
||||
const char16_t* target, int32_t targetLength)
|
||||
const;
|
||||
|
||||
/**
|
||||
|
|
@ -440,8 +440,8 @@ public:
|
|||
* than target
|
||||
* @stable ICU 2.6
|
||||
*/
|
||||
virtual UCollationResult compare(const UChar* source, int32_t sourceLength,
|
||||
const UChar* target, int32_t targetLength,
|
||||
virtual UCollationResult compare(const char16_t* source, int32_t sourceLength,
|
||||
const char16_t* target, int32_t targetLength,
|
||||
UErrorCode &status) const = 0;
|
||||
|
||||
/**
|
||||
|
|
@ -517,7 +517,7 @@ public:
|
|||
* @see CollationKey#compare
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual CollationKey& getCollationKey(const UChar*source,
|
||||
virtual CollationKey& getCollationKey(const char16_t*source,
|
||||
int32_t sourceLength,
|
||||
CollationKey& key,
|
||||
UErrorCode& status) const = 0;
|
||||
|
|
@ -911,7 +911,7 @@ public:
|
|||
* the top of one of the supported reordering groups,
|
||||
* and it must not be beyond the last of those groups.
|
||||
* See setMaxVariable().
|
||||
* @param varTop one or more (if contraction) UChars to which the variable top should be set
|
||||
* @param varTop one or more (if contraction) char16_ts to which the variable top should be set
|
||||
* @param len length of variable top string. If -1 it is considered to be zero terminated.
|
||||
* @param status error code. If error code is set, the return value is undefined. Errors set by this function are: <br>
|
||||
* U_CE_NOT_FOUND_ERROR if more than one character was passed and there is no such contraction<br>
|
||||
|
|
@ -920,7 +920,7 @@ public:
|
|||
* @return variable top primary weight
|
||||
* @deprecated ICU 53 Call setMaxVariable() instead.
|
||||
*/
|
||||
virtual uint32_t setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status) = 0;
|
||||
virtual uint32_t setVariableTop(const char16_t *varTop, int32_t len, UErrorCode &status) = 0;
|
||||
|
||||
/**
|
||||
* Sets the variable top to the primary weight of the specified string.
|
||||
|
|
@ -929,7 +929,7 @@ public:
|
|||
* the top of one of the supported reordering groups,
|
||||
* and it must not be beyond the last of those groups.
|
||||
* See setMaxVariable().
|
||||
* @param varTop a UnicodeString size 1 or more (if contraction) of UChars to which the variable top should be set
|
||||
* @param varTop a UnicodeString size 1 or more (if contraction) of char16_ts to which the variable top should be set
|
||||
* @param status error code. If error code is set, the return value is undefined. Errors set by this function are: <br>
|
||||
* U_CE_NOT_FOUND_ERROR if more than one character was passed and there is no such contraction<br>
|
||||
* U_ILLEGAL_ARGUMENT_ERROR if the variable top is beyond
|
||||
|
|
@ -1002,7 +1002,7 @@ public:
|
|||
int32_t resultLength) const = 0;
|
||||
|
||||
/**
|
||||
* Get the sort key as an array of bytes from a UChar buffer.
|
||||
* Get the sort key as an array of bytes from a char16_t buffer.
|
||||
* Sort key byte arrays are zero-terminated and can be compared using
|
||||
* strcmp().
|
||||
*
|
||||
|
|
@ -1020,7 +1020,7 @@ public:
|
|||
* @return Number of bytes needed for storing the sort key
|
||||
* @stable ICU 2.2
|
||||
*/
|
||||
virtual int32_t getSortKey(const UChar*source, int32_t sourceLength,
|
||||
virtual int32_t getSortKey(const char16_t*source, int32_t sourceLength,
|
||||
uint8_t*result, int32_t resultLength) const = 0;
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ class U_I18N_API CurrencyAmount: public Measure {
|
|||
* is invalid, then this will be set to a failing value.
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
CurrencyAmount(const Formattable& amount, const UChar* isoCode,
|
||||
CurrencyAmount(const Formattable& amount, ConstChar16Ptr isoCode,
|
||||
UErrorCode &ec);
|
||||
|
||||
/**
|
||||
|
|
@ -59,7 +59,7 @@ class U_I18N_API CurrencyAmount: public Measure {
|
|||
* then this will be set to a failing value.
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
CurrencyAmount(double amount, const UChar* isoCode,
|
||||
CurrencyAmount(double amount, ConstChar16Ptr isoCode,
|
||||
UErrorCode &ec);
|
||||
|
||||
/**
|
||||
|
|
@ -115,14 +115,14 @@ class U_I18N_API CurrencyAmount: public Measure {
|
|||
* Return the ISO currency code of this object.
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
inline const UChar* getISOCurrency() const;
|
||||
inline const char16_t* getISOCurrency() const;
|
||||
};
|
||||
|
||||
inline const CurrencyUnit& CurrencyAmount::getCurrency() const {
|
||||
return (const CurrencyUnit&) getUnit();
|
||||
}
|
||||
|
||||
inline const UChar* CurrencyAmount::getISOCurrency() const {
|
||||
inline const char16_t* CurrencyAmount::getISOCurrency() const {
|
||||
return getCurrency().getISOCurrency();
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -28,7 +28,7 @@ U_NAMESPACE_BEGIN
|
|||
|
||||
/**
|
||||
* A unit of currency, such as USD (U.S. dollars) or JPY (Japanese
|
||||
* yen). This class is a thin wrapper over a UChar string that
|
||||
* yen). This class is a thin wrapper over a char16_t string that
|
||||
* subclasses MeasureUnit, for use with Measure and MeasureFormat.
|
||||
*
|
||||
* @author Alan Liu
|
||||
|
|
@ -44,7 +44,7 @@ class U_I18N_API CurrencyUnit: public MeasureUnit {
|
|||
* then this will be set to a failing value.
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
CurrencyUnit(const UChar* isoCode, UErrorCode &ec);
|
||||
CurrencyUnit(ConstChar16Ptr isoCode, UErrorCode &ec);
|
||||
|
||||
/**
|
||||
* Copy constructor
|
||||
|
|
@ -93,16 +93,16 @@ class U_I18N_API CurrencyUnit: public MeasureUnit {
|
|||
* Return the ISO currency code of this object.
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
inline const UChar* getISOCurrency() const;
|
||||
inline const char16_t* getISOCurrency() const;
|
||||
|
||||
private:
|
||||
/**
|
||||
* The ISO 4217 code of this object.
|
||||
*/
|
||||
UChar isoCode[4];
|
||||
char16_t isoCode[4];
|
||||
};
|
||||
|
||||
inline const UChar* CurrencyUnit::getISOCurrency() const {
|
||||
inline const char16_t* CurrencyUnit::getISOCurrency() const {
|
||||
return isoCode;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -393,7 +393,7 @@ public:
|
|||
* Returns that pattern stored in currecy info. Internal API for use by NumberFormat API.
|
||||
* @internal
|
||||
*/
|
||||
inline const UChar* getCurrencyPattern(void) const;
|
||||
inline const char16_t* getCurrencyPattern(void) const;
|
||||
#endif /* U_HIDE_INTERNAL_API */
|
||||
|
||||
private:
|
||||
|
|
@ -424,7 +424,7 @@ private:
|
|||
|
||||
char actualLocale[ULOC_FULLNAME_CAPACITY];
|
||||
char validLocale[ULOC_FULLNAME_CAPACITY];
|
||||
const UChar* currPattern;
|
||||
const char16_t* currPattern;
|
||||
|
||||
UnicodeString currencySpcBeforeSym[UNUM_CURRENCY_SPACING_COUNT];
|
||||
UnicodeString currencySpcAfterSym[UNUM_CURRENCY_SPACING_COUNT];
|
||||
|
|
@ -492,7 +492,7 @@ DecimalFormatSymbols::getLocale() const {
|
|||
}
|
||||
|
||||
#ifndef U_HIDE_INTERNAL_API
|
||||
inline const UChar*
|
||||
inline const char16_t*
|
||||
DecimalFormatSymbols::getCurrencyPattern() const {
|
||||
return currPattern;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -604,7 +604,7 @@ template class U_I18N_API EnumSet<UNumberFormatAttribute,
|
|||
* including prefix and suffix, determines the format width. For example, in
|
||||
* the pattern <code>"* #0 o''clock"</code>, the format width is 10.
|
||||
*
|
||||
* <li>The width is counted in 16-bit code units (UChars).
|
||||
* <li>The width is counted in 16-bit code units (char16_ts).
|
||||
*
|
||||
* <li>Some parameters which usually do not matter have meaning when padding is
|
||||
* used, because the pattern width is significant with padding. In the pattern
|
||||
|
|
@ -1961,14 +1961,14 @@ public:
|
|||
* @param ec input-output error code
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
|
||||
virtual void setCurrency(const char16_t* theCurrency, UErrorCode& ec);
|
||||
|
||||
/**
|
||||
* Sets the currency used to display currency amounts. See
|
||||
* setCurrency(const UChar*, UErrorCode&).
|
||||
* @deprecated ICU 3.0. Use setCurrency(const UChar*, UErrorCode&).
|
||||
* setCurrency(const char16_t*, UErrorCode&).
|
||||
* @deprecated ICU 3.0. Use setCurrency(const char16_t*, UErrorCode&).
|
||||
*/
|
||||
virtual void setCurrency(const UChar* theCurrency);
|
||||
virtual void setCurrency(const char16_t* theCurrency);
|
||||
|
||||
/**
|
||||
* Sets the <tt>Currency Context</tt> object used to display currency.
|
||||
|
|
@ -2108,7 +2108,7 @@ private:
|
|||
void parse(const UnicodeString& text,
|
||||
Formattable& result,
|
||||
ParsePosition& pos,
|
||||
UChar* currency) const;
|
||||
char16_t* currency) const;
|
||||
|
||||
enum {
|
||||
fgStatusInfinite,
|
||||
|
|
@ -2124,7 +2124,7 @@ private:
|
|||
int8_t type,
|
||||
ParsePosition& parsePosition,
|
||||
DigitList& digits, UBool* status,
|
||||
UChar* currency) const;
|
||||
char16_t* currency) const;
|
||||
|
||||
// Mixed style parsing for currency.
|
||||
// It parses against the current currency pattern
|
||||
|
|
@ -2135,7 +2135,7 @@ private:
|
|||
ParsePosition& parsePosition,
|
||||
DigitList& digits,
|
||||
UBool* status,
|
||||
UChar* currency) const;
|
||||
char16_t* currency) const;
|
||||
|
||||
int32_t skipPadding(const UnicodeString& text, int32_t position) const;
|
||||
|
||||
|
|
@ -2146,7 +2146,7 @@ private:
|
|||
const UnicodeString* affixPat,
|
||||
UBool complexCurrencyParsing,
|
||||
int8_t type,
|
||||
UChar* currency) const;
|
||||
char16_t* currency) const;
|
||||
|
||||
static UnicodeString& trimMarksFromAffix(const UnicodeString& affix, UnicodeString& trimmedAffix);
|
||||
|
||||
|
|
@ -2169,7 +2169,7 @@ private:
|
|||
const UnicodeString& input,
|
||||
int32_t pos,
|
||||
int8_t type,
|
||||
UChar* currency) const;
|
||||
char16_t* currency) const;
|
||||
|
||||
static int32_t match(const UnicodeString& text, int32_t pos, UChar32 ch);
|
||||
|
||||
|
|
@ -2195,11 +2195,11 @@ private:
|
|||
void setupCurrencyAffixPatterns(UErrorCode& status);
|
||||
|
||||
// get the currency rounding with respect to currency usage
|
||||
double getCurrencyRounding(const UChar* currency,
|
||||
double getCurrencyRounding(const char16_t* currency,
|
||||
UErrorCode* ec) const;
|
||||
|
||||
// get the currency fraction with respect to currency usage
|
||||
int getCurrencyFractionDigits(const UChar* currency,
|
||||
int getCurrencyFractionDigits(const char16_t* currency,
|
||||
UErrorCode* ec) const;
|
||||
|
||||
// hashtable operations
|
||||
|
|
@ -2271,7 +2271,7 @@ protected:
|
|||
* have a capacity of at least 4
|
||||
* @internal
|
||||
*/
|
||||
virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const;
|
||||
virtual void getEffectiveCurrency(char16_t* result, UErrorCode& ec) const;
|
||||
|
||||
/** number of integer digits
|
||||
* @stable ICU 2.4
|
||||
|
|
|
|||
|
|
@ -426,13 +426,13 @@ public:
|
|||
* doesn't specify any time separator, and always recognized when parsing.
|
||||
* @internal
|
||||
*/
|
||||
static const UChar DEFAULT_TIME_SEPARATOR = 0x003a; // ':'
|
||||
static const char16_t DEFAULT_TIME_SEPARATOR = 0x003a; // ':'
|
||||
|
||||
/**
|
||||
* This alternate time separator is always recognized when parsing.
|
||||
* @internal
|
||||
*/
|
||||
static const UChar ALTERNATE_TIME_SEPARATOR = 0x002e; // '.'
|
||||
static const char16_t ALTERNATE_TIME_SEPARATOR = 0x002e; // '.'
|
||||
|
||||
/**
|
||||
* Gets the time separator string. For example: ":".
|
||||
|
|
@ -566,7 +566,7 @@ public:
|
|||
* @return the non-localized date-time pattern characters
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
static const UChar * U_EXPORT2 getPatternUChars(void);
|
||||
static const char16_t * U_EXPORT2 getPatternUChars(void);
|
||||
|
||||
/**
|
||||
* Gets localized date-time pattern characters. For example: 'u', 't', etc.
|
||||
|
|
@ -977,7 +977,7 @@ private:
|
|||
* Returns the date format field index of the pattern character c,
|
||||
* or UDAT_FIELD_COUNT if c is not a pattern character.
|
||||
*/
|
||||
static UDateFormatField U_EXPORT2 getPatternCharIndex(UChar c);
|
||||
static UDateFormatField U_EXPORT2 getPatternCharIndex(char16_t c);
|
||||
|
||||
/**
|
||||
* Returns TRUE if f (with its pattern character repeated count times) is a numeric field.
|
||||
|
|
@ -987,7 +987,7 @@ private:
|
|||
/**
|
||||
* Returns TRUE if c (repeated count times) is the pattern character for a numeric field.
|
||||
*/
|
||||
static UBool U_EXPORT2 isNumericPatternChar(UChar c, int32_t count);
|
||||
static UBool U_EXPORT2 isNumericPatternChar(char16_t c, int32_t count);
|
||||
public:
|
||||
#ifndef U_HIDE_INTERNAL_API
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -996,7 +996,7 @@ private:
|
|||
|
||||
|
||||
// from calendar field to pattern letter
|
||||
static const UChar fgCalendarFieldToPatternLetter[];
|
||||
static const char16_t fgCalendarFieldToPatternLetter[];
|
||||
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -517,7 +517,7 @@ private:
|
|||
DateTimeMatcher *skipMatcher;
|
||||
Hashtable *fAvailableFormatKeyHash;
|
||||
UnicodeString emptyString;
|
||||
UChar fDefaultHourFormatChar;
|
||||
char16_t fDefaultHourFormatChar;
|
||||
|
||||
int32_t fAllowedHourFormats[7]; // Actually an array of AllowedHourFormat enum type, ending with UNKNOWN.
|
||||
|
||||
|
|
|
|||
|
|
@ -939,7 +939,7 @@ private:
|
|||
* @return the index of the list which matches the keyword s.
|
||||
*/
|
||||
static int32_t findKeyword( const UnicodeString& s,
|
||||
const UChar * const *list);
|
||||
const char16_t * const *list);
|
||||
|
||||
/**
|
||||
* Thin wrapper around the format(... AppendableWrapper ...) variant.
|
||||
|
|
|
|||
|
|
@ -931,7 +931,7 @@ public:
|
|||
* @param ec input-output error code
|
||||
* @stable ICU 3.0
|
||||
*/
|
||||
virtual void setCurrency(const UChar* theCurrency, UErrorCode& ec);
|
||||
virtual void setCurrency(const char16_t* theCurrency, UErrorCode& ec);
|
||||
|
||||
/**
|
||||
* Gets the currency used to display currency
|
||||
|
|
@ -940,7 +940,7 @@ public:
|
|||
* the currency in use, or a pointer to the empty string.
|
||||
* @stable ICU 2.6
|
||||
*/
|
||||
const UChar* getCurrency() const;
|
||||
const char16_t* getCurrency() const;
|
||||
|
||||
/**
|
||||
* Set a particular UDisplayContext value in the formatter, such as
|
||||
|
|
@ -1018,7 +1018,7 @@ protected:
|
|||
* have a capacity of at least 4
|
||||
* @internal
|
||||
*/
|
||||
virtual void getEffectiveCurrency(UChar* result, UErrorCode& ec) const;
|
||||
virtual void getEffectiveCurrency(char16_t* result, UErrorCode& ec) const;
|
||||
|
||||
#ifndef U_HIDE_INTERNAL_API
|
||||
/**
|
||||
|
|
@ -1065,7 +1065,7 @@ private:
|
|||
UBool fLenient; // TRUE => lenient parse is enabled
|
||||
|
||||
// ISO currency code
|
||||
UChar fCurrency[4];
|
||||
char16_t fCurrency[4];
|
||||
|
||||
UDisplayContext fCapitalizationContext;
|
||||
|
||||
|
|
|
|||
|
|
@ -350,17 +350,17 @@ public:
|
|||
private:
|
||||
/**
|
||||
* Cause a compilation error if an application accidentally attempts to
|
||||
* create a matcher with a (UChar *) string as input rather than
|
||||
* create a matcher with a (char16_t *) string as input rather than
|
||||
* a UnicodeString. Avoids a dangling reference to a temporary string.
|
||||
* <p>
|
||||
* To efficiently work with UChar *strings, wrap the data in a UnicodeString
|
||||
* To efficiently work with char16_t *strings, wrap the data in a UnicodeString
|
||||
* using one of the aliasing constructors, such as
|
||||
* <code>UnicodeString(UBool isTerminated, const UChar *text, int32_t textLength);</code>
|
||||
* <code>UnicodeString(UBool isTerminated, const char16_t *text, int32_t textLength);</code>
|
||||
* or in a UText, using
|
||||
* <code>utext_openUChars(UText *ut, const UChar *text, int64_t textLength, UErrorCode *status);</code>
|
||||
* <code>utext_openUChars(UText *ut, const char16_t *text, int64_t textLength, UErrorCode *status);</code>
|
||||
*
|
||||
*/
|
||||
RegexMatcher *matcher(const UChar *input,
|
||||
RegexMatcher *matcher(const char16_t *input,
|
||||
UErrorCode &status) const;
|
||||
public:
|
||||
|
||||
|
|
@ -748,17 +748,17 @@ public:
|
|||
private:
|
||||
/**
|
||||
* Cause a compilation error if an application accidentally attempts to
|
||||
* create a matcher with a (UChar *) string as input rather than
|
||||
* create a matcher with a (char16_t *) string as input rather than
|
||||
* a UnicodeString. Avoids a dangling reference to a temporary string.
|
||||
* <p>
|
||||
* To efficiently work with UChar *strings, wrap the data in a UnicodeString
|
||||
* To efficiently work with char16_t *strings, wrap the data in a UnicodeString
|
||||
* using one of the aliasing constructors, such as
|
||||
* <code>UnicodeString(UBool isTerminated, const UChar *text, int32_t textLength);</code>
|
||||
* <code>UnicodeString(UBool isTerminated, const char16_t *text, int32_t textLength);</code>
|
||||
* or in a UText, using
|
||||
* <code>utext_openUChars(UText *ut, const UChar *text, int64_t textLength, UErrorCode *status);</code>
|
||||
* <code>utext_openUChars(UText *ut, const char16_t *text, int64_t textLength, UErrorCode *status);</code>
|
||||
*
|
||||
*/
|
||||
RegexMatcher(const UnicodeString ®exp, const UChar *input,
|
||||
RegexMatcher(const UnicodeString ®exp, const char16_t *input,
|
||||
uint32_t flags, UErrorCode &status);
|
||||
public:
|
||||
|
||||
|
|
@ -1156,17 +1156,17 @@ public:
|
|||
private:
|
||||
/**
|
||||
* Cause a compilation error if an application accidentally attempts to
|
||||
* reset a matcher with a (UChar *) string as input rather than
|
||||
* reset a matcher with a (char16_t *) string as input rather than
|
||||
* a UnicodeString. Avoids a dangling reference to a temporary string.
|
||||
* <p>
|
||||
* To efficiently work with UChar *strings, wrap the data in a UnicodeString
|
||||
* To efficiently work with char16_t *strings, wrap the data in a UnicodeString
|
||||
* using one of the aliasing constructors, such as
|
||||
* <code>UnicodeString(UBool isTerminated, const UChar *text, int32_t textLength);</code>
|
||||
* <code>UnicodeString(UBool isTerminated, const char16_t *text, int32_t textLength);</code>
|
||||
* or in a UText, using
|
||||
* <code>utext_openUChars(UText *ut, const UChar *text, int64_t textLength, UErrorCode *status);</code>
|
||||
* <code>utext_openUChars(UText *ut, const char16_t *text, int64_t textLength, UErrorCode *status);</code>
|
||||
*
|
||||
*/
|
||||
RegexMatcher &reset(const UChar *input);
|
||||
RegexMatcher &reset(const char16_t *input);
|
||||
public:
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -1170,7 +1170,7 @@ public:
|
|||
* @param field The UDateFormatField to get
|
||||
* @stable ICU 54
|
||||
*/
|
||||
const NumberFormat * getNumberFormatForField(UChar field) const;
|
||||
const NumberFormat * getNumberFormatForField(char16_t field) const;
|
||||
|
||||
#ifndef U_HIDE_INTERNAL_API
|
||||
/**
|
||||
|
|
@ -1262,7 +1262,7 @@ private:
|
|||
* succeeds.
|
||||
*/
|
||||
void subFormat(UnicodeString &appendTo,
|
||||
UChar ch,
|
||||
char16_t ch,
|
||||
int32_t count,
|
||||
UDisplayContext capitalizationContext,
|
||||
int32_t fieldNum,
|
||||
|
|
@ -1294,7 +1294,7 @@ private:
|
|||
* Return true if the given format character, occuring count
|
||||
* times, represents a numeric field.
|
||||
*/
|
||||
static UBool isNumeric(UChar formatChar, int32_t count);
|
||||
static UBool isNumeric(char16_t formatChar, int32_t count);
|
||||
|
||||
/**
|
||||
* Returns TRUE if the patternOffset is at the start of a numeric field.
|
||||
|
|
@ -1412,7 +1412,7 @@ private:
|
|||
* @return the new start position if matching succeeded; a negative number
|
||||
* indicating matching failure, otherwise.
|
||||
*/
|
||||
int32_t subParse(const UnicodeString& text, int32_t& start, UChar ch, int32_t count,
|
||||
int32_t subParse(const UnicodeString& text, int32_t& start, char16_t ch, int32_t count,
|
||||
UBool obeyCount, UBool allowNegative, UBool ambiguousYear[], int32_t& saveHebrewMonth, Calendar& cal,
|
||||
int32_t patLoc, MessageFormat * numericLeapMonthFormatter, UTimeZoneFormatTimeType *tzTimeType, SimpleDateFormatMutableNFs &mutableNFs,
|
||||
int32_t *dayPeriod=NULL) const;
|
||||
|
|
@ -1523,12 +1523,12 @@ private:
|
|||
/**
|
||||
* Map calendar field letter into calendar field level.
|
||||
*/
|
||||
static int32_t getLevelFromChar(UChar ch);
|
||||
static int32_t getLevelFromChar(char16_t ch);
|
||||
|
||||
/**
|
||||
* Tell if a character can be used to define a field in a format string.
|
||||
*/
|
||||
static UBool isSyntaxChar(UChar ch);
|
||||
static UBool isSyntaxChar(char16_t ch);
|
||||
|
||||
/**
|
||||
* The formatting pattern for this formatter.
|
||||
|
|
|
|||
|
|
@ -308,8 +308,8 @@ public:
|
|||
* than target
|
||||
* @stable ICU 2.6
|
||||
*/
|
||||
virtual UCollationResult compare(const UChar* source, int32_t sourceLength,
|
||||
const UChar* target, int32_t targetLength,
|
||||
virtual UCollationResult compare(const char16_t* source, int32_t sourceLength,
|
||||
const char16_t* target, int32_t targetLength,
|
||||
UErrorCode &status) const;
|
||||
|
||||
/**
|
||||
|
|
@ -377,7 +377,7 @@ public:
|
|||
* @see CollationKey
|
||||
* @stable ICU 2.0
|
||||
*/
|
||||
virtual CollationKey& getCollationKey(const UChar *source,
|
||||
virtual CollationKey& getCollationKey(const char16_t *source,
|
||||
int32_t sourceLength,
|
||||
CollationKey& key,
|
||||
UErrorCode& status) const;
|
||||
|
|
@ -552,7 +552,7 @@ public:
|
|||
* the top of one of the supported reordering groups,
|
||||
* and it must not be beyond the last of those groups.
|
||||
* See setMaxVariable().
|
||||
* @param varTop one or more (if contraction) UChars to which the variable top should be set
|
||||
* @param varTop one or more (if contraction) char16_ts to which the variable top should be set
|
||||
* @param len length of variable top string. If -1 it is considered to be zero terminated.
|
||||
* @param status error code. If error code is set, the return value is undefined. Errors set by this function are: <br>
|
||||
* U_CE_NOT_FOUND_ERROR if more than one character was passed and there is no such contraction<br>
|
||||
|
|
@ -561,7 +561,7 @@ public:
|
|||
* @return variable top primary weight
|
||||
* @deprecated ICU 53 Call setMaxVariable() instead.
|
||||
*/
|
||||
virtual uint32_t setVariableTop(const UChar *varTop, int32_t len, UErrorCode &status);
|
||||
virtual uint32_t setVariableTop(const char16_t *varTop, int32_t len, UErrorCode &status);
|
||||
|
||||
/**
|
||||
* Sets the variable top to the primary weight of the specified string.
|
||||
|
|
@ -570,7 +570,7 @@ public:
|
|||
* the top of one of the supported reordering groups,
|
||||
* and it must not be beyond the last of those groups.
|
||||
* See setMaxVariable().
|
||||
* @param varTop a UnicodeString size 1 or more (if contraction) of UChars to which the variable top should be set
|
||||
* @param varTop a UnicodeString size 1 or more (if contraction) of char16_ts to which the variable top should be set
|
||||
* @param status error code. If error code is set, the return value is undefined. Errors set by this function are: <br>
|
||||
* U_CE_NOT_FOUND_ERROR if more than one character was passed and there is no such contraction<br>
|
||||
* U_ILLEGAL_ARGUMENT_ERROR if the variable top is beyond
|
||||
|
|
@ -631,7 +631,7 @@ public:
|
|||
int32_t resultLength) const;
|
||||
|
||||
/**
|
||||
* Get the sort key as an array of bytes from a UChar buffer.
|
||||
* Get the sort key as an array of bytes from a char16_t buffer.
|
||||
*
|
||||
* Note that sort keys are often less efficient than simply doing comparison.
|
||||
* For more details, see the ICU User Guide.
|
||||
|
|
@ -646,7 +646,7 @@ public:
|
|||
* @return Number of bytes needed for storing the sort key
|
||||
* @stable ICU 2.2
|
||||
*/
|
||||
virtual int32_t getSortKey(const UChar *source, int32_t sourceLength,
|
||||
virtual int32_t getSortKey(const char16_t *source, int32_t sourceLength,
|
||||
uint8_t *result, int32_t resultLength) const;
|
||||
|
||||
/**
|
||||
|
|
@ -821,17 +821,17 @@ private:
|
|||
void adoptTailoring(CollationTailoring *t, UErrorCode &errorCode);
|
||||
|
||||
// Both lengths must be <0 or else both must be >=0.
|
||||
UCollationResult doCompare(const UChar *left, int32_t leftLength,
|
||||
const UChar *right, int32_t rightLength,
|
||||
UCollationResult doCompare(const char16_t *left, int32_t leftLength,
|
||||
const char16_t *right, int32_t rightLength,
|
||||
UErrorCode &errorCode) const;
|
||||
UCollationResult doCompare(const uint8_t *left, int32_t leftLength,
|
||||
const uint8_t *right, int32_t rightLength,
|
||||
UErrorCode &errorCode) const;
|
||||
|
||||
void writeSortKey(const UChar *s, int32_t length,
|
||||
void writeSortKey(const char16_t *s, int32_t length,
|
||||
SortKeyByteSink &sink, UErrorCode &errorCode) const;
|
||||
|
||||
void writeIdenticalLevel(const UChar *s, const UChar *limit,
|
||||
void writeIdenticalLevel(const char16_t *s, const char16_t *limit,
|
||||
SortKeyByteSink &sink, UErrorCode &errorCode) const;
|
||||
|
||||
const CollationSettings &getDefaultSettings() const;
|
||||
|
|
|
|||
|
|
@ -863,7 +863,7 @@ private:
|
|||
* @param id zone id string
|
||||
* @return the pointer of the ID resource, or NULL.
|
||||
*/
|
||||
static const UChar* findID(const UnicodeString& id);
|
||||
static const char16_t* findID(const UnicodeString& id);
|
||||
|
||||
/**
|
||||
* Resolve a link in Olson tzdata. When the given id is known and it's not a link,
|
||||
|
|
@ -873,7 +873,7 @@ private:
|
|||
* @param id zone id string
|
||||
* @return the dereferenced zone or NULL
|
||||
*/
|
||||
static const UChar* dereferOlsonLink(const UnicodeString& id);
|
||||
static const char16_t* dereferOlsonLink(const UnicodeString& id);
|
||||
|
||||
/**
|
||||
* Returns the region code associated with the given zone,
|
||||
|
|
@ -881,7 +881,7 @@ private:
|
|||
* @param id zone id string
|
||||
* @return the region associated with the given zone
|
||||
*/
|
||||
static const UChar* getRegion(const UnicodeString& id);
|
||||
static const char16_t* getRegion(const UnicodeString& id);
|
||||
|
||||
public:
|
||||
#ifndef U_HIDE_INTERNAL_API
|
||||
|
|
@ -893,7 +893,7 @@ private:
|
|||
* @return the region associated with the given zone
|
||||
* @internal
|
||||
*/
|
||||
static const UChar* getRegion(const UnicodeString& id, UErrorCode& status);
|
||||
static const char16_t* getRegion(const UnicodeString& id, UErrorCode& status);
|
||||
#endif /* U_HIDE_INTERNAL_API */
|
||||
|
||||
private:
|
||||
|
|
|
|||
|
|
@ -1319,7 +1319,7 @@ inline int32_t Transliterator::getMaximumContextLength(void) const {
|
|||
inline void Transliterator::setID(const UnicodeString& id) {
|
||||
ID = id;
|
||||
// NUL-terminate the ID string, which is a non-aliased copy.
|
||||
ID.append((UChar)0);
|
||||
ID.append((char16_t)0);
|
||||
ID.truncate(ID.length()-1);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -942,7 +942,7 @@ private:
|
|||
* @param parsedLen the parsed length, or 0 on failure.
|
||||
* @return the parsed offset in milliseconds.
|
||||
*/
|
||||
int32_t parseDefaultOffsetFields(const UnicodeString& text, int32_t start, UChar separator,
|
||||
int32_t parseDefaultOffsetFields(const UnicodeString& text, int32_t start, char16_t separator,
|
||||
int32_t& parsedLen) const;
|
||||
|
||||
/**
|
||||
|
|
@ -982,7 +982,7 @@ private:
|
|||
* @param maxFields The maximum fields
|
||||
* @return The offset string
|
||||
*/
|
||||
static UnicodeString& formatOffsetWithAsciiDigits(int32_t offset, UChar sep,
|
||||
static UnicodeString& formatOffsetWithAsciiDigits(int32_t offset, char16_t sep,
|
||||
OffsetFields minFields, OffsetFields maxFields, UnicodeString& result);
|
||||
|
||||
/**
|
||||
|
|
@ -1012,7 +1012,7 @@ private:
|
|||
* @param maxFields The maximum Fields to be parsed
|
||||
* @return Parsed offset, 0 or positive number.
|
||||
*/
|
||||
static int32_t parseAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, UChar sep,
|
||||
static int32_t parseAsciiOffsetFields(const UnicodeString& text, ParsePosition& pos, char16_t sep,
|
||||
OffsetFields minFields, OffsetFields maxFields);
|
||||
|
||||
/**
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@
|
|||
#include "uresimp.h"
|
||||
#include "uhash.h"
|
||||
#include "olsontz.h"
|
||||
#include "uinvchar.h"
|
||||
|
||||
static UMutex gZoneMetaLock = U_MUTEX_INITIALIZER;
|
||||
|
||||
|
|
@ -255,6 +256,12 @@ ZoneMeta::getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status) {
|
|||
tzid.extract(utzid, ZID_KEY_MAX + 1, tmpStatus);
|
||||
U_ASSERT(tmpStatus == U_ZERO_ERROR); // we checked the length of tzid already
|
||||
|
||||
if (!uprv_isInvariantUString(utzid, -1)) {
|
||||
// All of known tz IDs are only containing ASCII invariant characters.
|
||||
status = U_ILLEGAL_ARGUMENT_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
// Check if it was already cached
|
||||
umtx_lock(&gZoneMetaLock);
|
||||
{
|
||||
|
|
|
|||
|
|
@ -41,7 +41,11 @@ public:
|
|||
/**
|
||||
* Return the canonical id for this tzid defined by CLDR, which might be the id itself.
|
||||
* This overload method returns a persistent const UChar*, which is guranteed to persist
|
||||
* (a pointer to a resource).
|
||||
* (a pointer to a resource). If the given system tzid is not known, U_ILLEGAL_ARGUMENT_ERROR
|
||||
* is set in the status.
|
||||
* @param tzid Zone ID
|
||||
* @param status Receives the status
|
||||
* @return The canonical ID for the input time zone ID
|
||||
*/
|
||||
static const UChar* U_EXPORT2 getCanonicalCLDRID(const UnicodeString &tzid, UErrorCode& status);
|
||||
|
||||
|
|
|
|||
|
|
@ -35,7 +35,7 @@ BUILDDIR := $(BUILDDIR:test\\intltest/../../=)
|
|||
BUILDDIR := $(BUILDDIR:TEST\\INTLTEST/../../=)
|
||||
|
||||
CPPFLAGS += -I$(srcdir) -I$(top_srcdir)/common -I$(top_srcdir)/i18n -I$(top_srcdir)/tools/toolutil -I$(top_srcdir)/tools/ctestfw
|
||||
CPPFLAGS += -DUNISTR_FROM_CHAR_EXPLICIT= -DUNISTR_FROM_STRING_EXPLICIT=
|
||||
CPPFLAGS += -DUNISTR_FROM_CHAR_EXPLICIT= -DUNISTR_FROM_STRING_EXPLICIT= -DUCHAR_TYPE=char16_t
|
||||
DEFS += -D'U_TOPSRCDIR="$(top_srcdir)/"' -D'U_TOPBUILDDIR="$(BUILDDIR)"'
|
||||
LIBS = $(LIBCTESTFW) $(LIBICUI18N) $(LIBICUUC) $(LIBICUTOOLUTIL) $(DEFAULT_LIBS) $(LIB_M) $(LIB_THREAD)
|
||||
|
||||
|
|
|
|||
|
|
@ -368,7 +368,7 @@
|
|||
<ClCompile Include="idnaconf.cpp" />
|
||||
<ClCompile Include="idnaref.cpp" />
|
||||
<ClCompile Include="nptrans.cpp" />
|
||||
<ClCompile Include="punyref.c" />
|
||||
<ClCompile Include="punyref.cpp" />
|
||||
<ClCompile Include="testidn.cpp">
|
||||
<DisableLanguageExtensions>false</DisableLanguageExtensions>
|
||||
</ClCompile>
|
||||
|
|
|
|||
|
|
@ -352,7 +352,7 @@
|
|||
<ClCompile Include="nptrans.cpp">
|
||||
<Filter>idna</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="punyref.c">
|
||||
<ClCompile Include="punyref.cpp">
|
||||
<Filter>idna</Filter>
|
||||
</ClCompile>
|
||||
<ClCompile Include="testidn.cpp">
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@
|
|||
* Corporation and others. All Rights Reserved.
|
||||
*
|
||||
*******************************************************************************
|
||||
* file name: punyref.h
|
||||
* file name: punyref.cpp
|
||||
* encoding: UTF-8
|
||||
* tab size: 8 (not used)
|
||||
* indentation:4
|
||||
|
|
@ -644,7 +644,7 @@ void StringSearchTest::TestOpenClose()
|
|||
}
|
||||
delete result;
|
||||
|
||||
text.append(0, 0x1);
|
||||
// No-op: text.append(0, 0x1); -- what was intended here?
|
||||
status = U_ZERO_ERROR;
|
||||
result = new StringSearch(pattern, text, NULL, NULL, status);
|
||||
if (U_SUCCESS(status)) {
|
||||
|
|
|
|||
|
|
@ -82,6 +82,7 @@ TimeZoneFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name
|
|||
TESTCASE(3, TestISOFormat);
|
||||
TESTCASE(4, TestFormat);
|
||||
TESTCASE(5, TestFormatTZDBNames);
|
||||
TESTCASE(6, TestFormatCustomZone);
|
||||
default: name = ""; break;
|
||||
}
|
||||
}
|
||||
|
|
@ -1213,5 +1214,38 @@ TimeZoneFormatTest::TestFormatTZDBNames(void) {
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
TimeZoneFormatTest::TestFormatCustomZone(void) {
|
||||
struct {
|
||||
const char* id;
|
||||
int32_t offset;
|
||||
const char* expected;
|
||||
} TESTDATA[] = {
|
||||
{ "abc", 3600000, "GMT+01:00" }, // unknown ID
|
||||
{ "$abc", -3600000, "GMT-01:00" }, // unknown, with ASCII variant char '$'
|
||||
{ "\\u00c1\\u00df\\u00c7", 5400000, "GMT+01:30"}, // unknown, with non-ASCII chars
|
||||
{ 0, 0, 0 }
|
||||
};
|
||||
|
||||
UDate now = Calendar::getNow();
|
||||
|
||||
for (int32_t i = 0; ; i++) {
|
||||
const char *id = TESTDATA[i].id;
|
||||
if (id == 0) {
|
||||
break;
|
||||
}
|
||||
UnicodeString tzid = UnicodeString(id, -1, US_INV).unescape();
|
||||
SimpleTimeZone tz(TESTDATA[i].offset, tzid);
|
||||
|
||||
UErrorCode status = U_ZERO_ERROR;
|
||||
LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(Locale("en"), status));
|
||||
UnicodeString tzstr;
|
||||
UnicodeString expected = UnicodeString(TESTDATA[i].expected, -1, US_INV).unescape();
|
||||
|
||||
tzfmt->format(UTZFMT_STYLE_SPECIFIC_LONG, tz, now, tzstr, NULL);
|
||||
assertEquals(UnicodeString("Format result for ") + tzid, expected, tzstr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#endif /* #if !UCONFIG_NO_FORMATTING */
|
||||
|
|
|
|||
|
|
@ -27,6 +27,7 @@ class TimeZoneFormatTest : public IntlTest {
|
|||
void TestISOFormat(void);
|
||||
void TestFormat(void);
|
||||
void TestFormatTZDBNames(void);
|
||||
void TestFormatCustomZone(void);
|
||||
|
||||
void RunTimeRoundTripTests(int32_t threadNumber);
|
||||
};
|
||||
|
|
|
|||
|
|
@ -61,6 +61,9 @@ void UnicodeStringTest::runIndexedTest( int32_t index, UBool exec, const char* &
|
|||
TESTCASE_AUTO(TestSizeofUnicodeString);
|
||||
TESTCASE_AUTO(TestStartsWithAndEndsWithNulTerminated);
|
||||
TESTCASE_AUTO(TestMoveSwap);
|
||||
TESTCASE_AUTO(TestUInt16Pointers);
|
||||
TESTCASE_AUTO(TestWCharPointers);
|
||||
TESTCASE_AUTO(TestNullPointers);
|
||||
TESTCASE_AUTO_END;
|
||||
}
|
||||
|
||||
|
|
@ -1554,7 +1557,10 @@ UnicodeStringTest::TestBogus() {
|
|||
|
||||
// writable alias to another string's buffer: very bad idea, just convenient for this test
|
||||
test3.setToBogus();
|
||||
if(!test3.isBogus() || test3.setTo((UChar *)test1.getBuffer(), test1.length(), test1.getCapacity()).isBogus() || test3!=test1) {
|
||||
if(!test3.isBogus() ||
|
||||
test3.setTo(const_cast<UChar *>(test1.getBuffer()),
|
||||
test1.length(), test1.getCapacity()).isBogus() ||
|
||||
test3!=test1) {
|
||||
errln("bogus.setTo(writable alias) failed");
|
||||
}
|
||||
|
||||
|
|
@ -1609,8 +1615,8 @@ UnicodeStringTest::TestBogus() {
|
|||
// test that NULL primitive input string values are treated like
|
||||
// empty strings, not errors (bogus)
|
||||
test2.setTo((UChar32)0x10005);
|
||||
if(test2.insert(1, NULL, 1).length()!=2) {
|
||||
errln("UniStr.insert(...NULL...) should not modify the string but does");
|
||||
if(test2.insert(1, nullptr, 1).length()!=2) {
|
||||
errln("UniStr.insert(...nullptr...) should not modify the string but does");
|
||||
}
|
||||
|
||||
UErrorCode errorCode=U_ZERO_ERROR;
|
||||
|
|
@ -2186,3 +2192,64 @@ UnicodeStringTest::TestMoveSwap() {
|
|||
errln("UnicodeString copy after self-move did not work");
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
UnicodeStringTest::TestUInt16Pointers() {
|
||||
static const uint16_t carr[] = { 0x61, 0x62, 0x63, 0 };
|
||||
uint16_t arr[4];
|
||||
|
||||
UnicodeString expected(u"abc");
|
||||
assertEquals("abc from pointer", expected, UnicodeString(carr));
|
||||
assertEquals("abc from pointer+length", expected, UnicodeString(carr, 3));
|
||||
assertEquals("abc from read-only-alias pointer", expected, UnicodeString(TRUE, carr, 3));
|
||||
|
||||
UnicodeString alias(arr, 0, 4);
|
||||
alias.append(u'a').append(u'b').append(u'c');
|
||||
assertEquals("abc from writable alias", expected, alias);
|
||||
assertEquals("buffer=abc from writable alias", expected, UnicodeString(arr, 3));
|
||||
|
||||
UErrorCode errorCode = U_ZERO_ERROR;
|
||||
int32_t length = UnicodeString(u"def").extract(arr, 4, errorCode);
|
||||
TEST_ASSERT_STATUS(errorCode);
|
||||
assertEquals("def from extract()", UnicodeString(u"def"), UnicodeString(arr, length));
|
||||
}
|
||||
|
||||
void
|
||||
UnicodeStringTest::TestWCharPointers() {
|
||||
#if U_SIZEOF_WCHAR_T==2
|
||||
static const wchar_t carr[] = { 0x61, 0x62, 0x63, 0 };
|
||||
wchar_t arr[4];
|
||||
|
||||
UnicodeString expected(u"abc");
|
||||
assertEquals("abc from pointer", expected, UnicodeString(carr));
|
||||
assertEquals("abc from pointer+length", expected, UnicodeString(carr, 3));
|
||||
assertEquals("abc from read-only-alias pointer", expected, UnicodeString(TRUE, carr, 3));
|
||||
|
||||
UnicodeString alias(arr, 0, 4);
|
||||
alias.append(u'a').append(u'b').append(u'c');
|
||||
assertEquals("abc from writable alias", expected, alias);
|
||||
assertEquals("buffer=abc from writable alias", expected, UnicodeString(arr, 3));
|
||||
|
||||
UErrorCode errorCode = U_ZERO_ERROR;
|
||||
int32_t length = UnicodeString(u"def").extract(arr, 4, errorCode);
|
||||
TEST_ASSERT_STATUS(errorCode);
|
||||
assertEquals("def from extract()", UnicodeString(u"def"), UnicodeString(arr, length));
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
UnicodeStringTest::TestNullPointers() {
|
||||
assertTrue("empty from nullptr", UnicodeString(nullptr).isEmpty());
|
||||
assertTrue("empty from nullptr+length", UnicodeString(nullptr, 2).isEmpty());
|
||||
assertTrue("empty from read-only-alias nullptr", UnicodeString(TRUE, nullptr, 3).isEmpty());
|
||||
|
||||
UnicodeString alias(nullptr, 4, 4); // empty, no alias
|
||||
assertTrue("empty from writable alias", alias.isEmpty());
|
||||
alias.append(u'a').append(u'b').append(u'c');
|
||||
UnicodeString expected(u"abc");
|
||||
assertEquals("abc from writable alias", expected, alias);
|
||||
|
||||
UErrorCode errorCode = U_ZERO_ERROR;
|
||||
UnicodeString(u"def").extract(nullptr, 0, errorCode);
|
||||
assertEquals("buffer overflow extracting to nullptr", U_BUFFER_OVERFLOW_ERROR, errorCode);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -92,6 +92,10 @@ public:
|
|||
void TestUnicodeStringImplementsAppendable();
|
||||
void TestSizeofUnicodeString();
|
||||
void TestMoveSwap();
|
||||
|
||||
void TestUInt16Pointers();
|
||||
void TestWCharPointers();
|
||||
void TestNullPointers();
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -106,12 +106,12 @@ static void U_CALLCONV TestStream(void)
|
|||
|
||||
inTestStream >> inStr >> inStr2;
|
||||
if (inStr.compare(thisMu) != 0) {
|
||||
u_austrncpy(inStrC, inStr.getBuffer(), inStr.length());
|
||||
u_austrncpy(inStrC, toUCharPtr(inStr.getBuffer()), inStr.length());
|
||||
inStrC[inStr.length()] = 0;
|
||||
log_err("Got: \"%s\", Expected: \"tHis\\u03BC\"\n", inStrC);
|
||||
}
|
||||
if (inStr2.compare(mu) != 0) {
|
||||
u_austrncpy(inStrC, inStr.getBuffer(), inStr.length());
|
||||
u_austrncpy(inStrC, toUCharPtr(inStr.getBuffer()), inStr.length());
|
||||
inStrC[inStr.length()] = 0;
|
||||
log_err("Got: \"%s\", Expected: \"mu\"\n", inStrC);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -164,7 +164,7 @@ LB20.1b: CB CM* ÷;
|
|||
# not picking up the continuing match after the BA from 21a.
|
||||
# TODO: For CJ tailorings (with BAX) does this rule want to include BAX? If so,
|
||||
# should "HL BAX" not break when followed by a CB? Thats what the current
|
||||
# rules do, which is why "[^CM CB]?" includes the ?.
|
||||
# rules do, which is why "[^CM CB]?" includes the ?.
|
||||
LB21a: HL CM* (HY | BA | BAX) CM* [^CM CB]?;
|
||||
|
||||
# DO allow breaks here before $BAXcm and $NSXcm, so don't include them
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ subdir = tools
|
|||
|
||||
SUBDIRS = toolutil ctestfw makeconv genrb genbrk \
|
||||
gencnval gensprep icuinfo genccode gencmn icupkg pkgdata \
|
||||
gentest gennorm2 gencfu gendict escapesrc
|
||||
gentest gennorm2 gencfu gendict
|
||||
|
||||
## List of phony targets
|
||||
.PHONY : all all-local all-recursive install install-local \
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@
|
|||
|
||||
#include "unicode/datamap.h"
|
||||
#include "unicode/resbund.h"
|
||||
#include "unicode/unistr.h"
|
||||
#include "hash.h"
|
||||
#include <stdlib.h>
|
||||
|
||||
|
|
@ -20,7 +21,7 @@ int32_t
|
|||
DataMap::utoi(const UnicodeString &s) const
|
||||
{
|
||||
char ch[256];
|
||||
const UChar *u = s.getBuffer();
|
||||
const UChar *u = toUCharPtr(s.getBuffer());
|
||||
int32_t len = s.length();
|
||||
u_UCharsToChars(u, ch, len);
|
||||
ch[len] = 0; /* include terminating \0 */
|
||||
|
|
|
|||
|
|
@ -280,7 +280,7 @@ uint8_t Normalizer2DataBuilder::getCC(UChar32 c) const {
|
|||
|
||||
static UBool isWellFormed(const UnicodeString &s) {
|
||||
UErrorCode errorCode=U_ZERO_ERROR;
|
||||
u_strToUTF8(NULL, 0, NULL, s.getBuffer(), s.length(), &errorCode);
|
||||
u_strToUTF8(NULL, 0, NULL, toUCharPtr(s.getBuffer()), s.length(), &errorCode);
|
||||
return U_SUCCESS(errorCode) || errorCode==U_BUFFER_OVERFLOW_ERROR;
|
||||
}
|
||||
|
||||
|
|
@ -313,7 +313,7 @@ void Normalizer2DataBuilder::setRoundTripMapping(UChar32 c, const UnicodeString
|
|||
(int)phase, (long)c);
|
||||
exit(U_INVALID_FORMAT_ERROR);
|
||||
}
|
||||
int32_t numCP=u_countChar32(m.getBuffer(), m.length());
|
||||
int32_t numCP=u_countChar32(toUCharPtr(m.getBuffer()), m.length());
|
||||
if(numCP!=2) {
|
||||
fprintf(stderr,
|
||||
"error in gennorm2 phase %d: "
|
||||
|
|
@ -450,7 +450,7 @@ Normalizer2DataBuilder::decompose(UChar32 start, UChar32 end, uint32_t value) {
|
|||
Norm &norm=norms[value];
|
||||
const UnicodeString &m=*norm.mapping;
|
||||
UnicodeString *decomposed=NULL;
|
||||
const UChar *s=m.getBuffer();
|
||||
const UChar *s=toUCharPtr(m.getBuffer());
|
||||
int32_t length=m.length();
|
||||
int32_t prev, i=0;
|
||||
UChar32 c;
|
||||
|
|
@ -605,7 +605,7 @@ Normalizer2DataBuilder::reorder(Norm *p, BuilderReorderingBuffer &buffer) {
|
|||
if(length>Normalizer2Impl::MAPPING_LENGTH_MASK) {
|
||||
return; // writeMapping() will complain about it and print the code point.
|
||||
}
|
||||
const UChar *s=m.getBuffer();
|
||||
const UChar *s=toUCharPtr(m.getBuffer());
|
||||
int32_t i=0;
|
||||
UChar32 c;
|
||||
while(i<length) {
|
||||
|
|
@ -1207,7 +1207,7 @@ void Normalizer2DataBuilder::writeBinaryFile(const char *filename) {
|
|||
}
|
||||
udata_writeBlock(pData, indexes, sizeof(indexes));
|
||||
udata_writeBlock(pData, norm16TrieBytes.getAlias(), norm16TrieLength);
|
||||
udata_writeUString(pData, extraData.getBuffer(), extraData.length());
|
||||
udata_writeUString(pData, toUCharPtr(extraData.getBuffer()), extraData.length());
|
||||
udata_writeBlock(pData, smallFCD, sizeof(smallFCD));
|
||||
int32_t writtenSize=udata_finish(pData, errorCode);
|
||||
if(errorCode.isFailure()) {
|
||||
|
|
|
|||
|
|
@ -271,7 +271,7 @@ StringBaseResource::StringBaseResource(SRBRoot *bundle, const char *tag, int8_t
|
|||
return;
|
||||
}
|
||||
|
||||
fString.setTo(value, len);
|
||||
fString.setTo(ConstChar16Ptr(value), len);
|
||||
fString.getTerminatedBuffer(); // Some code relies on NUL-termination.
|
||||
if (U_SUCCESS(errorCode) && fString.isBogus()) {
|
||||
errorCode = U_MEMORY_ALLOCATION_ERROR;
|
||||
|
|
@ -1031,7 +1031,7 @@ void SRBRoot::write(const char *outputDir, const char *outputPkg,
|
|||
if (f16BitUnits.length() <= 1) {
|
||||
// no pool strings to checksum
|
||||
} else if (U_IS_BIG_ENDIAN) {
|
||||
checksum = computeCRC((const char *)f16BitUnits.getBuffer(),
|
||||
checksum = computeCRC(reinterpret_cast<const char *>(f16BitUnits.getBuffer()),
|
||||
(uint32_t)f16BitUnits.length() * 2, checksum);
|
||||
} else {
|
||||
// Swap to big-endian so we get the same checksum on all platforms
|
||||
|
|
@ -1039,7 +1039,7 @@ void SRBRoot::write(const char *outputDir, const char *outputPkg,
|
|||
UnicodeString s(f16BitUnits);
|
||||
s.append((UChar)1); // Ensure that we own this buffer.
|
||||
assert(!s.isBogus());
|
||||
uint16_t *p = (uint16_t *)s.getBuffer();
|
||||
uint16_t *p = const_cast<uint16_t *>(reinterpret_cast<const uint16_t *>(s.getBuffer()));
|
||||
for (int32_t count = f16BitUnits.length(); count > 0; --count) {
|
||||
uint16_t x = *p;
|
||||
*p++ = (uint16_t)((x << 8) | (x >> 8));
|
||||
|
|
|
|||
|
|
@ -304,7 +304,7 @@ public:
|
|||
StringBaseResource(int8_t type, const UChar *value, int32_t len, UErrorCode &errorCode);
|
||||
virtual ~StringBaseResource();
|
||||
|
||||
const UChar *getBuffer() const { return fString.getBuffer(); }
|
||||
const UChar *getBuffer() const { return icu::toUCharPtr(fString.getBuffer()); }
|
||||
int32_t length() const { return fString.length(); }
|
||||
|
||||
virtual void handlePreWrite(uint32_t *byteOffset);
|
||||
|
|
|
|||
|
|
@ -73,7 +73,7 @@ static int32_t write_utf8_file(FileStream* fileStream, UnicodeString outString)
|
|||
u_strToUTF8(NULL,
|
||||
0,
|
||||
&len,
|
||||
outString.getBuffer(),
|
||||
toUCharPtr(outString.getBuffer()),
|
||||
outString.length(),
|
||||
&status);
|
||||
|
||||
|
|
@ -85,7 +85,7 @@ static int32_t write_utf8_file(FileStream* fileStream, UnicodeString outString)
|
|||
u_strToUTF8(dest,
|
||||
len,
|
||||
&len,
|
||||
outString.getBuffer(),
|
||||
toUCharPtr(outString.getBuffer()),
|
||||
outString.length(),
|
||||
&status);
|
||||
|
||||
|
|
|
|||
|
|
@ -117,7 +117,7 @@ U_CAPI int32_t
|
|||
udbg_stoi(const UnicodeString &s)
|
||||
{
|
||||
char ch[256];
|
||||
const UChar *u = s.getBuffer();
|
||||
const UChar *u = toUCharPtr(s.getBuffer());
|
||||
int32_t len = s.length();
|
||||
u_UCharsToChars(u, ch, len);
|
||||
ch[len] = 0; /* include terminating \0 */
|
||||
|
|
@ -129,7 +129,7 @@ U_CAPI double
|
|||
udbg_stod(const UnicodeString &s)
|
||||
{
|
||||
char ch[256];
|
||||
const UChar *u = s.getBuffer();
|
||||
const UChar *u = toUCharPtr(s.getBuffer());
|
||||
int32_t len = s.length();
|
||||
u_UCharsToChars(u, ch, len);
|
||||
ch[len] = 0; /* include terminating \0 */
|
||||
|
|
|
|||
|
|
@ -515,12 +515,12 @@ PreparsedUCD::parseCodePointRange(const char *s, UChar32 &start, UChar32 &end, U
|
|||
|
||||
void
|
||||
PreparsedUCD::parseString(const char *s, UnicodeString &uni, UErrorCode &errorCode) {
|
||||
UChar *buffer=uni.getBuffer(-1);
|
||||
UChar *buffer=toUCharPtr(uni.getBuffer(-1));
|
||||
int32_t length=u_parseString(s, buffer, uni.getCapacity(), NULL, &errorCode);
|
||||
if(errorCode==U_BUFFER_OVERFLOW_ERROR) {
|
||||
errorCode=U_ZERO_ERROR;
|
||||
uni.releaseBuffer(0);
|
||||
buffer=uni.getBuffer(length);
|
||||
buffer=toUCharPtr(uni.getBuffer(length));
|
||||
length=u_parseString(s, buffer, uni.getCapacity(), NULL, &errorCode);
|
||||
}
|
||||
uni.releaseBuffer(length);
|
||||
|
|
|
|||
|
|
@ -209,7 +209,7 @@ UXMLParser::parseFile(const char *filename, UErrorCode &errorCode) {
|
|||
goto exit;
|
||||
}
|
||||
|
||||
buffer=src.getBuffer(bytesLength);
|
||||
buffer=toUCharPtr(src.getBuffer(bytesLength));
|
||||
if(buffer==NULL) {
|
||||
// unexpected failure to reserve some string capacity
|
||||
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
||||
|
|
@ -278,7 +278,7 @@ UXMLParser::parseFile(const char *filename, UErrorCode &errorCode) {
|
|||
pb=bytes;
|
||||
for(;;) {
|
||||
length=src.length();
|
||||
buffer=src.getBuffer(capacity);
|
||||
buffer=toUCharPtr(src.getBuffer(capacity));
|
||||
if(buffer==NULL) {
|
||||
// unexpected failure to reserve some string capacity
|
||||
errorCode=U_MEMORY_ALLOCATION_ERROR;
|
||||
|
|
|
|||
|
|
@ -2147,57 +2147,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
|
|||
/**
|
||||
* Returns the {@link DateFormatSymbols} object that should be used to format a
|
||||
* calendar system's dates in the given locale.
|
||||
* <p>
|
||||
* <b>Subclassing:</b><br>
|
||||
* When creating a new Calendar subclass, you must create the
|
||||
* {@link ResourceBundle ResourceBundle}
|
||||
* containing its {@link DateFormatSymbols DateFormatSymbols} in a specific place.
|
||||
* The resource bundle name is based on the calendar's fully-specified
|
||||
* class name, with ".resources" inserted at the end of the package name
|
||||
* (just before the class name) and "Symbols" appended to the end.
|
||||
* For example, the bundle corresponding to "com.ibm.icu.util.HebrewCalendar"
|
||||
* is "com.ibm.icu.impl.data.HebrewCalendarSymbols".
|
||||
* <p>
|
||||
* Within the ResourceBundle, this method searches for five keys:
|
||||
* <ul>
|
||||
* <li><b>DayNames</b> -
|
||||
* An array of strings corresponding to each possible
|
||||
* value of the <code>DAY_OF_WEEK</code> field. Even though
|
||||
* <code>DAY_OF_WEEK</code> starts with <code>SUNDAY</code> = 1,
|
||||
* This array is 0-based; the name for Sunday goes in the
|
||||
* first position, at index 0. If this key is not found
|
||||
* in the bundle, the day names are inherited from the
|
||||
* default <code>DateFormatSymbols</code> for the requested locale.
|
||||
*
|
||||
* <li><b>DayAbbreviations</b> -
|
||||
* An array of abbreviated day names corresponding
|
||||
* to the values in the "DayNames" array. If this key
|
||||
* is not found in the resource bundle, the "DayNames"
|
||||
* values are used instead. If neither key is found,
|
||||
* the day abbreviations are inherited from the default
|
||||
* <code>DateFormatSymbols</code> for the locale.
|
||||
*
|
||||
* <li><b>MonthNames</b> -
|
||||
* An array of strings corresponding to each possible
|
||||
* value of the <code>MONTH</code> field. If this key is not found
|
||||
* in the bundle, the month names are inherited from the
|
||||
* default <code>DateFormatSymbols</code> for the requested locale.
|
||||
*
|
||||
* <li><b>MonthAbbreviations</b> -
|
||||
* An array of abbreviated day names corresponding
|
||||
* to the values in the "MonthNames" array. If this key
|
||||
* is not found in the resource bundle, the "MonthNames"
|
||||
* values are used instead. If neither key is found,
|
||||
* the day abbreviations are inherited from the default
|
||||
* <code>DateFormatSymbols</code> for the locale.
|
||||
*
|
||||
* <li><b>Eras</b> -
|
||||
* An array of strings corresponding to each possible
|
||||
* value of the <code>ERA</code> field. If this key is not found
|
||||
* in the bundle, the era names are inherited from the
|
||||
* default <code>DateFormatSymbols</code> for the requested locale.
|
||||
* </ul>
|
||||
* <p>
|
||||
* @param cal The calendar system whose date format symbols are desired.
|
||||
* @param locale The locale whose symbols are desired.
|
||||
*
|
||||
|
|
@ -2211,57 +2161,6 @@ public class DateFormatSymbols implements Serializable, Cloneable {
|
|||
/**
|
||||
* Returns the {@link DateFormatSymbols} object that should be used to format a
|
||||
* calendar system's dates in the given locale.
|
||||
* <p>
|
||||
* <b>Subclassing:</b><br>
|
||||
* When creating a new Calendar subclass, you must create the
|
||||
* {@link ResourceBundle ResourceBundle}
|
||||
* containing its {@link DateFormatSymbols DateFormatSymbols} in a specific place.
|
||||
* The resource bundle name is based on the calendar's fully-specified
|
||||
* class name, with ".resources" inserted at the end of the package name
|
||||
* (just before the class name) and "Symbols" appended to the end.
|
||||
* For example, the bundle corresponding to "com.ibm.icu.util.HebrewCalendar"
|
||||
* is "com.ibm.icu.impl.data.HebrewCalendarSymbols".
|
||||
* <p>
|
||||
* Within the ResourceBundle, this method searches for five keys:
|
||||
* <ul>
|
||||
* <li><b>DayNames</b> -
|
||||
* An array of strings corresponding to each possible
|
||||
* value of the <code>DAY_OF_WEEK</code> field. Even though
|
||||
* <code>DAY_OF_WEEK</code> starts with <code>SUNDAY</code> = 1,
|
||||
* This array is 0-based; the name for Sunday goes in the
|
||||
* first position, at index 0. If this key is not found
|
||||
* in the bundle, the day names are inherited from the
|
||||
* default <code>DateFormatSymbols</code> for the requested locale.
|
||||
*
|
||||
* <li><b>DayAbbreviations</b> -
|
||||
* An array of abbreviated day names corresponding
|
||||
* to the values in the "DayNames" array. If this key
|
||||
* is not found in the resource bundle, the "DayNames"
|
||||
* values are used instead. If neither key is found,
|
||||
* the day abbreviations are inherited from the default
|
||||
* <code>DateFormatSymbols</code> for the locale.
|
||||
*
|
||||
* <li><b>MonthNames</b> -
|
||||
* An array of strings corresponding to each possible
|
||||
* value of the <code>MONTH</code> field. If this key is not found
|
||||
* in the bundle, the month names are inherited from the
|
||||
* default <code>DateFormatSymbols</code> for the requested locale.
|
||||
*
|
||||
* <li><b>MonthAbbreviations</b> -
|
||||
* An array of abbreviated day names corresponding
|
||||
* to the values in the "MonthNames" array. If this key
|
||||
* is not found in the resource bundle, the "MonthNames"
|
||||
* values are used instead. If neither key is found,
|
||||
* the day abbreviations are inherited from the default
|
||||
* <code>DateFormatSymbols</code> for the locale.
|
||||
*
|
||||
* <li><b>Eras</b> -
|
||||
* An array of strings corresponding to each possible
|
||||
* value of the <code>ERA</code> field. If this key is not found
|
||||
* in the bundle, the era names are inherited from the
|
||||
* default <code>DateFormatSymbols</code> for the requested locale.
|
||||
* </ul>
|
||||
* <p>
|
||||
* @param cal The calendar system whose date format symbols are desired.
|
||||
* @param locale The ulocale whose symbols are desired.
|
||||
*
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue