| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 2011, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: uniset_closure.cpp |
| * encoding: UTF-8 |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 2011may30 |
| * created by: Markus W. Scherer |
| * |
| * UnicodeSet::closeOver() and related methods moved here from uniset_props.cpp |
| * to simplify dependencies. |
| * In particular, this depends on the BreakIterator, but the BreakIterator |
| * code also builds UnicodeSets from patterns and needs uniset_props. |
| */ |
| |
| #if defined(STARBOARD) |
| #include "starboard/client_porting/poem/string_poem.h" |
| #endif // defined(STARBOARD) |
| #include "unicode/brkiter.h" |
| #include "unicode/locid.h" |
| #include "unicode/parsepos.h" |
| #include "unicode/uniset.h" |
| #include "cmemory.h" |
| #include "ruleiter.h" |
| #include "ucase.h" |
| #include "util.h" |
| #include "uvector.h" |
| |
| U_NAMESPACE_BEGIN |
| |
| // TODO memory debugging provided inside uniset.cpp |
| // could be made available here but probably obsolete with use of modern |
| // memory leak checker tools |
| #define _dbgct(me) |
| |
| //---------------------------------------------------------------- |
| // Constructors &c |
| //---------------------------------------------------------------- |
| |
| UnicodeSet::UnicodeSet(const UnicodeString& pattern, |
| uint32_t options, |
| const SymbolTable* symbols, |
| UErrorCode& status) { |
| applyPattern(pattern, options, symbols, status); |
| _dbgct(this); |
| } |
| |
| UnicodeSet::UnicodeSet(const UnicodeString& pattern, ParsePosition& pos, |
| uint32_t options, |
| const SymbolTable* symbols, |
| UErrorCode& status) { |
| applyPattern(pattern, pos, options, symbols, status); |
| _dbgct(this); |
| } |
| |
| //---------------------------------------------------------------- |
| // Public API |
| //---------------------------------------------------------------- |
| |
| UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern, |
| uint32_t options, |
| const SymbolTable* symbols, |
| UErrorCode& status) { |
| ParsePosition pos(0); |
| applyPattern(pattern, pos, options, symbols, status); |
| if (U_FAILURE(status)) return *this; |
| |
| int32_t i = pos.getIndex(); |
| |
| if (options & USET_IGNORE_SPACE) { |
| // Skip over trailing whitespace |
| ICU_Utility::skipWhitespace(pattern, i, TRUE); |
| } |
| |
| if (i != pattern.length()) { |
| status = U_ILLEGAL_ARGUMENT_ERROR; |
| } |
| return *this; |
| } |
| |
| UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern, |
| ParsePosition& pos, |
| uint32_t options, |
| const SymbolTable* symbols, |
| UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return *this; |
| } |
| if (isFrozen()) { |
| status = U_NO_WRITE_PERMISSION; |
| return *this; |
| } |
| // Need to build the pattern in a temporary string because |
| // _applyPattern calls add() etc., which set pat to empty. |
| UnicodeString rebuiltPat; |
| RuleCharacterIterator chars(pattern, symbols, pos); |
| applyPattern(chars, symbols, rebuiltPat, options, &UnicodeSet::closeOver, 0, status); |
| if (U_FAILURE(status)) return *this; |
| if (chars.inVariable()) { |
| // syntaxError(chars, "Extra chars in variable value"); |
| status = U_MALFORMED_SET; |
| return *this; |
| } |
| setPattern(rebuiltPat); |
| return *this; |
| } |
| |
| // USetAdder implementation |
| // Does not use uset.h to reduce code dependencies |
| static void U_CALLCONV |
| _set_add(USet *set, UChar32 c) { |
| ((UnicodeSet *)set)->add(c); |
| } |
| |
| static void U_CALLCONV |
| _set_addRange(USet *set, UChar32 start, UChar32 end) { |
| ((UnicodeSet *)set)->add(start, end); |
| } |
| |
| static void U_CALLCONV |
| _set_addString(USet *set, const UChar *str, int32_t length) { |
| ((UnicodeSet *)set)->add(UnicodeString((UBool)(length<0), str, length)); |
| } |
| |
| //---------------------------------------------------------------- |
| // Case folding API |
| //---------------------------------------------------------------- |
| |
| // add the result of a full case mapping to the set |
| // use str as a temporary string to avoid constructing one |
| static inline void |
| addCaseMapping(UnicodeSet &set, int32_t result, const UChar *full, UnicodeString &str) { |
| if(result >= 0) { |
| if(result > UCASE_MAX_STRING_LENGTH) { |
| // add a single-code point case mapping |
| set.add(result); |
| } else { |
| // add a string case mapping from full with length result |
| str.setTo((UBool)FALSE, full, result); |
| set.add(str); |
| } |
| } |
| // result < 0: the code point mapped to itself, no need to add it |
| // see ucase.h |
| } |
| |
| UnicodeSet& UnicodeSet::closeOver(int32_t attribute) { |
| if (isFrozen() || isBogus()) { |
| return *this; |
| } |
| if (attribute & (USET_CASE_INSENSITIVE | USET_ADD_CASE_MAPPINGS)) { |
| { |
| UnicodeSet foldSet(*this); |
| UnicodeString str; |
| USetAdder sa = { |
| foldSet.toUSet(), |
| _set_add, |
| _set_addRange, |
| _set_addString, |
| NULL, // don't need remove() |
| NULL // don't need removeRange() |
| }; |
| |
| // start with input set to guarantee inclusion |
| // USET_CASE: remove strings because the strings will actually be reduced (folded); |
| // therefore, start with no strings and add only those needed |
| if ((attribute & USET_CASE_INSENSITIVE) && foldSet.hasStrings()) { |
| foldSet.strings->removeAllElements(); |
| } |
| |
| int32_t n = getRangeCount(); |
| UChar32 result; |
| const UChar *full; |
| |
| for (int32_t i=0; i<n; ++i) { |
| UChar32 start = getRangeStart(i); |
| UChar32 end = getRangeEnd(i); |
| |
| if (attribute & USET_CASE_INSENSITIVE) { |
| // full case closure |
| for (UChar32 cp=start; cp<=end; ++cp) { |
| ucase_addCaseClosure(cp, &sa); |
| } |
| } else { |
| // add case mappings |
| // (does not add long s for regular s, or Kelvin for k, for example) |
| for (UChar32 cp=start; cp<=end; ++cp) { |
| result = ucase_toFullLower(cp, NULL, NULL, &full, UCASE_LOC_ROOT); |
| addCaseMapping(foldSet, result, full, str); |
| |
| result = ucase_toFullTitle(cp, NULL, NULL, &full, UCASE_LOC_ROOT); |
| addCaseMapping(foldSet, result, full, str); |
| |
| result = ucase_toFullUpper(cp, NULL, NULL, &full, UCASE_LOC_ROOT); |
| addCaseMapping(foldSet, result, full, str); |
| |
| result = ucase_toFullFolding(cp, &full, 0); |
| addCaseMapping(foldSet, result, full, str); |
| } |
| } |
| } |
| if (hasStrings()) { |
| if (attribute & USET_CASE_INSENSITIVE) { |
| for (int32_t j=0; j<strings->size(); ++j) { |
| str = *(const UnicodeString *) strings->elementAt(j); |
| str.foldCase(); |
| if(!ucase_addStringCaseClosure(str.getBuffer(), str.length(), &sa)) { |
| foldSet.add(str); // does not map to code points: add the folded string itself |
| } |
| } |
| } else { |
| Locale root(""); |
| #if !UCONFIG_NO_BREAK_ITERATION |
| UErrorCode status = U_ZERO_ERROR; |
| BreakIterator *bi = BreakIterator::createWordInstance(root, status); |
| if (U_SUCCESS(status)) { |
| #endif |
| const UnicodeString *pStr; |
| |
| for (int32_t j=0; j<strings->size(); ++j) { |
| pStr = (const UnicodeString *) strings->elementAt(j); |
| (str = *pStr).toLower(root); |
| foldSet.add(str); |
| #if !UCONFIG_NO_BREAK_ITERATION |
| (str = *pStr).toTitle(bi, root); |
| foldSet.add(str); |
| #endif |
| (str = *pStr).toUpper(root); |
| foldSet.add(str); |
| (str = *pStr).foldCase(); |
| foldSet.add(str); |
| } |
| #if !UCONFIG_NO_BREAK_ITERATION |
| } |
| delete bi; |
| #endif |
| } |
| } |
| *this = foldSet; |
| } |
| } |
| return *this; |
| } |
| |
| U_NAMESPACE_END |
