summaryrefslogtreecommitdiff
path: root/Build/source/libs/icu/icu-xetex/common/unistr_case.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'Build/source/libs/icu/icu-xetex/common/unistr_case.cpp')
-rw-r--r--Build/source/libs/icu/icu-xetex/common/unistr_case.cpp246
1 files changed, 246 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-xetex/common/unistr_case.cpp b/Build/source/libs/icu/icu-xetex/common/unistr_case.cpp
new file mode 100644
index 00000000000..e557b4da7bd
--- /dev/null
+++ b/Build/source/libs/icu/icu-xetex/common/unistr_case.cpp
@@ -0,0 +1,246 @@
+/*
+*******************************************************************************
+*
+* Copyright (C) 1999-2007, International Business Machines
+* Corporation and others. All Rights Reserved.
+*
+*******************************************************************************
+* file name: unistr_case.cpp
+* encoding: US-ASCII
+* tab size: 8 (not used)
+* indentation:2
+*
+* created on: 2004aug19
+* created by: Markus W. Scherer
+*
+* Case-mapping functions moved here from unistr.cpp
+*/
+
+#include "unicode/utypes.h"
+#include "unicode/putil.h"
+#include "unicode/locid.h"
+#include "cstring.h"
+#include "cmemory.h"
+#include "unicode/ustring.h"
+#include "unicode/unistr.h"
+#include "unicode/uchar.h"
+#include "unicode/ubrk.h"
+#include "ustr_imp.h"
+#include "unormimp.h"
+#include "uhash.h"
+
+U_NAMESPACE_BEGIN
+
+//========================================
+// Read-only implementation
+//========================================
+
+int8_t
+UnicodeString::doCaseCompare(int32_t start,
+ int32_t length,
+ const UChar *srcChars,
+ int32_t srcStart,
+ int32_t srcLength,
+ uint32_t options) const
+{
+ // compare illegal string values
+ // treat const UChar *srcChars==NULL as an empty string
+ if(isBogus()) {
+ return -1;
+ }
+
+ // pin indices to legal values
+ pinIndices(start, length);
+
+ if(srcChars == NULL) {
+ srcStart = srcLength = 0;
+ }
+
+ // get the correct pointer
+ const UChar *chars = getArrayStart();
+
+ chars += start;
+ srcChars += srcStart;
+
+ if(chars != srcChars) {
+ UErrorCode errorCode=U_ZERO_ERROR;
+ int32_t result=u_strcmpFold(chars, length, srcChars, srcLength,
+ options|U_COMPARE_IGNORE_CASE, &errorCode);
+ if(result!=0) {
+ return (int8_t)(result >> 24 | 1);
+ }
+ } else {
+ // get the srcLength if necessary
+ if(srcLength < 0) {
+ srcLength = u_strlen(srcChars + srcStart);
+ }
+ if(length != srcLength) {
+ return (int8_t)((length - srcLength) >> 24 | 1);
+ }
+ }
+ return 0;
+}
+
+//========================================
+// Write implementation
+//========================================
+
+/*
+ * Implement argument checking and buffer handling
+ * for string case mapping as a common function.
+ */
+
+UnicodeString &
+UnicodeString::caseMap(BreakIterator *titleIter,
+ const char *locale,
+ uint32_t options,
+ int32_t toWhichCase) {
+ if(fLength <= 0) {
+ // nothing to do
+ return *this;
+ }
+
+ UErrorCode errorCode;
+
+ errorCode = U_ZERO_ERROR;
+ const UCaseProps *csp=ucase_getSingleton(&errorCode);
+ if(U_FAILURE(errorCode)) {
+ setToBogus();
+ return *this;
+ }
+
+ // We need to allocate a new buffer for the internal string case mapping function.
+ // This is very similar to how doReplace() below keeps the old array pointer
+ // and deletes the old array itself after it is done.
+ // In addition, we are forcing cloneArrayIfNeeded() to always allocate a new array.
+ UChar *oldArray = fArray;
+ int32_t oldLength = fLength;
+ int32_t *bufferToDelete = 0;
+
+ // Make sure that if the string is in fStackBuffer we do not overwrite it!
+ int32_t capacity;
+ if(fLength <= US_STACKBUF_SIZE) {
+ if(fArray == fStackBuffer) {
+ capacity = 2 * US_STACKBUF_SIZE; // make sure that cloneArrayIfNeeded() allocates a new buffer
+ } else {
+ capacity = US_STACKBUF_SIZE;
+ }
+ } else {
+ capacity = fLength + 20;
+ }
+ if(!cloneArrayIfNeeded(capacity, capacity, FALSE, &bufferToDelete, TRUE)) {
+ return *this;
+ }
+
+ // Case-map, and if the result is too long, then reallocate and repeat.
+ do {
+ errorCode = U_ZERO_ERROR;
+ if(toWhichCase==TO_LOWER) {
+ fLength = ustr_toLower(csp, fArray, fCapacity,
+ oldArray, oldLength,
+ locale, &errorCode);
+ } else if(toWhichCase==TO_UPPER) {
+ fLength = ustr_toUpper(csp, fArray, fCapacity,
+ oldArray, oldLength,
+ locale, &errorCode);
+ } else if(toWhichCase==TO_TITLE) {
+#if UCONFIG_NO_BREAK_ITERATION
+ errorCode=U_UNSUPPORTED_ERROR;
+#else
+ fLength = ustr_toTitle(csp, fArray, fCapacity,
+ oldArray, oldLength,
+ (UBreakIterator *)titleIter, locale, options, &errorCode);
+#endif
+ } else {
+ fLength = ustr_foldCase(csp, fArray, fCapacity,
+ oldArray, oldLength,
+ options,
+ &errorCode);
+ }
+ } while(errorCode==U_BUFFER_OVERFLOW_ERROR && cloneArrayIfNeeded(fLength, fLength, FALSE));
+
+ if (bufferToDelete) {
+ uprv_free(bufferToDelete);
+ }
+ if(U_FAILURE(errorCode)) {
+ setToBogus();
+ }
+ return *this;
+}
+
+UnicodeString &
+UnicodeString::toLower() {
+ return caseMap(0, Locale::getDefault().getName(), 0, TO_LOWER);
+}
+
+UnicodeString &
+UnicodeString::toLower(const Locale &locale) {
+ return caseMap(0, locale.getName(), 0, TO_LOWER);
+}
+
+UnicodeString &
+UnicodeString::toUpper() {
+ return caseMap(0, Locale::getDefault().getName(), 0, TO_UPPER);
+}
+
+UnicodeString &
+UnicodeString::toUpper(const Locale &locale) {
+ return caseMap(0, locale.getName(), 0, TO_UPPER);
+}
+
+#if !UCONFIG_NO_BREAK_ITERATION
+
+UnicodeString &
+UnicodeString::toTitle(BreakIterator *titleIter) {
+ return caseMap(titleIter, Locale::getDefault().getName(), 0, TO_TITLE);
+}
+
+UnicodeString &
+UnicodeString::toTitle(BreakIterator *titleIter, const Locale &locale) {
+ return caseMap(titleIter, locale.getName(), 0, TO_TITLE);
+}
+
+UnicodeString &
+UnicodeString::toTitle(BreakIterator *titleIter, const Locale &locale, uint32_t options) {
+ return caseMap(titleIter, locale.getName(), options, TO_TITLE);
+}
+
+#endif
+
+UnicodeString &
+UnicodeString::foldCase(uint32_t options) {
+ /* The Locale parameter isn't used. Use "" instead. */
+ return caseMap(0, "", options, FOLD_CASE);
+}
+
+U_NAMESPACE_END
+
+// Defined here to reduce dependencies on break iterator
+U_CAPI int32_t U_EXPORT2
+uhash_hashCaselessUnicodeString(const UHashTok key) {
+ U_NAMESPACE_USE
+ const UnicodeString *str = (const UnicodeString*) key.pointer;
+ if (str == NULL) {
+ return 0;
+ }
+ // Inefficient; a better way would be to have a hash function in
+ // UnicodeString that does case folding on the fly.
+ UnicodeString copy(*str);
+ return copy.foldCase().hashCode();
+}
+
+// Defined here to reduce dependencies on break iterator
+U_CAPI UBool U_EXPORT2
+uhash_compareCaselessUnicodeString(const UHashTok key1, const UHashTok key2) {
+ U_NAMESPACE_USE
+ const UnicodeString *str1 = (const UnicodeString*) key1.pointer;
+ const UnicodeString *str2 = (const UnicodeString*) key2.pointer;
+ if (str1 == str2) {
+ return TRUE;
+ }
+ if (str1 == NULL || str2 == NULL) {
+ return FALSE;
+ }
+ return str1->caseCompare(*str2, U_FOLD_CASE_DEFAULT) == 0;
+}
+