The Tor Browser: comparison intl/icu/source/common/unistr

--1:000000000000
+:5c7eaf888f6b
+/*
+*******************************************************************************
+*
+*   Copyright (C) 1999-2011, 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 "cstring.h"
+#include "cmemory.h"
+#include "unicode/ustring.h"
+#include "unicode/unistr.h"
+#include "unicode/uchar.h"
+#include "uelement.h"
+#include "ustr_imp.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;
+if(srcStart!=0) {
+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
+//========================================
+UnicodeString &
+UnicodeString::caseMap(const UCaseMap *csm,
+UStringCaseMapper *stringCaseMapper) {
+if(isEmpty() || !isWritable()) {
+// nothing to do
+return *this;
+}
+// We need to allocate a new buffer for the internal string case mapping function.
+// This is very similar to how doReplace() 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 oldStackBuffer[US_STACKBUF_SIZE];
+UChar *oldArray;
+int32_t oldLength;
+if(fFlags&kUsingStackBuffer) {
+// copy the stack buffer contents because it will be overwritten
+u_memcpy(oldStackBuffer, fUnion.fStackBuffer, fShortLength);
+oldArray = oldStackBuffer;
+oldLength = fShortLength;
+} else {
+oldArray = getArrayStart();
+oldLength = length();
+}
+int32_t capacity;
+if(oldLength <= US_STACKBUF_SIZE) {
+capacity = US_STACKBUF_SIZE;
+} else {
+capacity = oldLength + 20;
+}
+int32_t *bufferToDelete = 0;
+if(!cloneArrayIfNeeded(capacity, capacity, FALSE, &bufferToDelete, TRUE)) {
+return *this;
+}
+// Case-map, and if the result is too long, then reallocate and repeat.
+UErrorCode errorCode;
+int32_t newLength;
+do {
+errorCode = U_ZERO_ERROR;
+newLength = stringCaseMapper(csm, getArrayStart(), getCapacity(),
+oldArray, oldLength, &errorCode);
+setLength(newLength);
+} while(errorCode==U_BUFFER_OVERFLOW_ERROR && cloneArrayIfNeeded(newLength, newLength, FALSE));
+if (bufferToDelete) {
+uprv_free(bufferToDelete);
+}
+if(U_FAILURE(errorCode)) {
+setToBogus();
+}
+return *this;
+}
+UnicodeString &
+UnicodeString::foldCase(uint32_t options) {
+UCaseMap csm=UCASEMAP_INITIALIZER;
+csm.csp=ucase_getSingleton();
+csm.options=options;
+return caseMap(&csm, ustrcase_internalFold);
+}
+U_NAMESPACE_END
+// Defined here to reduce dependencies on break iterator
+U_CAPI int32_t U_EXPORT2
+uhash_hashCaselessUnicodeString(const UElement 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 UElement key1, const UElement 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;
+}

The Tor Browser / file comparison

comparison: intl/icu/source/common/unistr_case.cpp

intl/icu/source/common/unistr_case.cpp