2004-08-26 22:51:40 +00:00
|
|
|
/*
|
|
|
|
*******************************************************************************
|
|
|
|
*
|
2010-02-25 00:21:02 +00:00
|
|
|
* Copyright (C) 1999-2010, International Business Machines
|
2004-08-26 22:51:40 +00:00
|
|
|
* 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"
|
2004-12-05 06:23:51 +00:00
|
|
|
#include "uhash.h"
|
2004-08-26 22:51:40 +00:00
|
|
|
|
|
|
|
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;
|
2004-09-11 14:24:31 +00:00
|
|
|
int32_t result=u_strcmpFold(chars, length, srcChars, srcLength,
|
|
|
|
options|U_COMPARE_IGNORE_CASE, &errorCode);
|
2004-08-26 22:51:40 +00:00
|
|
|
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
|
|
|
|
//========================================
|
|
|
|
|
2007-08-30 08:57:44 +00:00
|
|
|
/*
|
|
|
|
* Implement argument checking and buffer handling
|
|
|
|
* for string case mapping as a common function.
|
|
|
|
*/
|
|
|
|
|
2004-08-26 22:51:40 +00:00
|
|
|
UnicodeString &
|
|
|
|
UnicodeString::caseMap(BreakIterator *titleIter,
|
2004-10-08 05:17:17 +00:00
|
|
|
const char *locale,
|
2004-08-26 22:51:40 +00:00
|
|
|
uint32_t options,
|
|
|
|
int32_t toWhichCase) {
|
2007-09-28 04:50:25 +00:00
|
|
|
if(isEmpty() || !isWritable()) {
|
2004-08-26 22:51:40 +00:00
|
|
|
// nothing to do
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2004-09-06 15:57:11 +00:00
|
|
|
UErrorCode errorCode;
|
|
|
|
|
2004-09-08 00:19:10 +00:00
|
|
|
errorCode = U_ZERO_ERROR;
|
2005-04-28 21:54:57 +00:00
|
|
|
const UCaseProps *csp=ucase_getSingleton(&errorCode);
|
2004-09-06 15:57:11 +00:00
|
|
|
if(U_FAILURE(errorCode)) {
|
|
|
|
setToBogus();
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2004-08-26 22:51:40 +00:00
|
|
|
// We need to allocate a new buffer for the internal string case mapping function.
|
2007-09-28 04:50:25 +00:00
|
|
|
// This is very similar to how doReplace() keeps the old array pointer
|
2004-08-26 22:51:40 +00:00
|
|
|
// and deletes the old array itself after it is done.
|
|
|
|
// In addition, we are forcing cloneArrayIfNeeded() to always allocate a new array.
|
2007-09-28 04:50:25 +00:00
|
|
|
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();
|
|
|
|
}
|
2004-08-26 22:51:40 +00:00
|
|
|
|
|
|
|
int32_t capacity;
|
2007-09-28 04:50:25 +00:00
|
|
|
if(oldLength <= US_STACKBUF_SIZE) {
|
|
|
|
capacity = US_STACKBUF_SIZE;
|
2004-08-26 22:51:40 +00:00
|
|
|
} else {
|
2007-09-28 04:50:25 +00:00
|
|
|
capacity = oldLength + 20;
|
2004-08-26 22:51:40 +00:00
|
|
|
}
|
2007-09-28 04:50:25 +00:00
|
|
|
int32_t *bufferToDelete = 0;
|
2004-08-26 22:51:40 +00:00
|
|
|
if(!cloneArrayIfNeeded(capacity, capacity, FALSE, &bufferToDelete, TRUE)) {
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Case-map, and if the result is too long, then reallocate and repeat.
|
2007-09-28 04:50:25 +00:00
|
|
|
int32_t newLength;
|
2004-08-26 22:51:40 +00:00
|
|
|
do {
|
|
|
|
errorCode = U_ZERO_ERROR;
|
|
|
|
if(toWhichCase==TO_LOWER) {
|
2007-09-28 04:50:25 +00:00
|
|
|
newLength = ustr_toLower(csp, getArrayStart(), getCapacity(),
|
|
|
|
oldArray, oldLength,
|
|
|
|
locale, &errorCode);
|
2004-08-26 22:51:40 +00:00
|
|
|
} else if(toWhichCase==TO_UPPER) {
|
2007-09-28 04:50:25 +00:00
|
|
|
newLength = ustr_toUpper(csp, getArrayStart(), getCapacity(),
|
|
|
|
oldArray, oldLength,
|
|
|
|
locale, &errorCode);
|
2004-08-26 22:51:40 +00:00
|
|
|
} else if(toWhichCase==TO_TITLE) {
|
2004-09-06 15:57:11 +00:00
|
|
|
#if UCONFIG_NO_BREAK_ITERATION
|
|
|
|
errorCode=U_UNSUPPORTED_ERROR;
|
|
|
|
#else
|
2007-09-28 04:50:25 +00:00
|
|
|
newLength = ustr_toTitle(csp, getArrayStart(), getCapacity(),
|
|
|
|
oldArray, oldLength,
|
|
|
|
(UBreakIterator *)titleIter, locale, options, &errorCode);
|
2004-08-26 22:51:40 +00:00
|
|
|
#endif
|
|
|
|
} else {
|
2007-09-28 04:50:25 +00:00
|
|
|
newLength = ustr_foldCase(csp, getArrayStart(), getCapacity(),
|
|
|
|
oldArray, oldLength,
|
|
|
|
options,
|
|
|
|
&errorCode);
|
2004-08-26 22:51:40 +00:00
|
|
|
}
|
2007-09-28 04:50:25 +00:00
|
|
|
setLength(newLength);
|
|
|
|
} while(errorCode==U_BUFFER_OVERFLOW_ERROR && cloneArrayIfNeeded(newLength, newLength, FALSE));
|
2004-08-26 22:51:40 +00:00
|
|
|
|
|
|
|
if (bufferToDelete) {
|
|
|
|
uprv_free(bufferToDelete);
|
|
|
|
}
|
|
|
|
if(U_FAILURE(errorCode)) {
|
|
|
|
setToBogus();
|
|
|
|
}
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2004-10-08 05:17:17 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2007-07-27 06:37:08 +00:00
|
|
|
UnicodeString &
|
|
|
|
UnicodeString::toTitle(BreakIterator *titleIter, const Locale &locale, uint32_t options) {
|
|
|
|
return caseMap(titleIter, locale.getName(), options, TO_TITLE);
|
|
|
|
}
|
|
|
|
|
2004-10-08 05:17:17 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
UnicodeString &
|
|
|
|
UnicodeString::foldCase(uint32_t options) {
|
|
|
|
/* The Locale parameter isn't used. Use "" instead. */
|
|
|
|
return caseMap(0, "", options, FOLD_CASE);
|
|
|
|
}
|
|
|
|
|
2004-08-26 22:51:40 +00:00
|
|
|
U_NAMESPACE_END
|
2004-12-05 06:23:51 +00:00
|
|
|
|
|
|
|
// 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;
|
|
|
|
}
|
|
|
|
|