+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html
/*
**********************************************************************
-* Copyright (C) 1999-2003, International Business Machines
+* Copyright (C) 1999-2015, International Business Machines
* Corporation and others. All Rights Reserved.
**********************************************************************
* Date Name Description
**********************************************************************
*/
-#include "unicode/uniset.h"
+#include "unicode/utypes.h"
#include "unicode/parsepos.h"
-#include "unicode/uchar.h"
-#include "unicode/uscript.h"
-#include "symtable.h"
+#include "unicode/symtable.h"
+#include "unicode/uniset.h"
+#include "unicode/ustring.h"
+#include "unicode/utf8.h"
+#include "unicode/utf16.h"
+#include "ruleiter.h"
#include "cmemory.h"
-#include "uhash.h"
+#include "cstring.h"
+#include "patternprops.h"
+#include "uelement.h"
#include "util.h"
#include "uvector.h"
-#include "uprops.h"
#include "charstr.h"
#include "ustrfmt.h"
-#include "mutex.h"
#include "uassert.h"
-#include "hash.h"
-#include "ucmp8.h"
-
-// HIGH_VALUE > all valid values. 110000 for codepoints
-#define UNICODESET_HIGH 0x0110000
-
-// LOW <= all valid values. ZERO for codepoints
-#define UNICODESET_LOW 0x000000
-
-// initial storage. Must be >= 0
-#define START_EXTRA 16
-
-// extra amount for growth. Must be >= 0
-#define GROW_EXTRA START_EXTRA
+#include "bmpset.h"
+#include "unisetspan.h"
// Define UChar constants using hex for EBCDIC compatibility
// Used #define to reduce private static exports and memory access time.
#define UPPER_N ((UChar)78) /*N*/
#define EQUALS ((UChar)0x003D) /*=*/
-static const UChar POSIX_OPEN[] = { 91,58,0 }; // "[:"
-static const UChar POSIX_CLOSE[] = { 58,93,0 }; // ":]"
-static const UChar PERL_OPEN[] = { 92,112,0 }; // "\\p"
-static const UChar PERL_CLOSE[] = { 125,0 }; // "}"
-static const UChar NAME_OPEN[] = { 92,78,0 }; // "\\N"
-
-// Special property set IDs
-static const char ANY[] = "ANY"; // [\u0000-\U0010FFFF]
-static const char ASCII[] = "ASCII"; // [\u0000-\u007F]
-
-static const char NAME_PROP[] = "na"; // Unicode name property alias
-
-// TODO: Remove the following special-case code when
-// these four C99-compatibility properties are implemented
-// as enums/names.
-U_CDECL_BEGIN
- typedef UBool (U_CALLCONV *_C99_Property_Function)(UChar32);
-U_CDECL_END
-static const struct _C99_Map {
- const char* name;
- _C99_Property_Function func;
-} _C99_DISPATCH[] = {
- // These three entries omitted; they clash with PropertyAliases
- // names for Unicode properties, so UnicodeSet already maps them
- // to those properties.
- //{ "alpha", u_isalpha },
- //{ "lower", u_islower },
- //{ "upper", u_isupper },
-
- // MUST be in SORTED order
- { "blank", u_isblank },
- { "cntrl", u_iscntrl },
- { "digit", u_isdigit },
- { "graph", u_isgraph },
- { "print", u_isprint },
- { "punct", u_ispunct },
- { "space", u_isspace },
- { "title", u_istitle },
- { "xdigit", u_isxdigit }
-};
-#define _C99_COUNT (9)
-
-// TEMPORARY: Remove when deprecated category code constructor is removed.
-static const UChar CATEGORY_NAMES[] = {
- // Must be kept in sync with uchar.h/UCharCategory
- 0x43, 0x6E, /* "Cn" */
- 0x4C, 0x75, /* "Lu" */
- 0x4C, 0x6C, /* "Ll" */
- 0x4C, 0x74, /* "Lt" */
- 0x4C, 0x6D, /* "Lm" */
- 0x4C, 0x6F, /* "Lo" */
- 0x4D, 0x6E, /* "Mn" */
- 0x4D, 0x65, /* "Me" */
- 0x4D, 0x63, /* "Mc" */
- 0x4E, 0x64, /* "Nd" */
- 0x4E, 0x6C, /* "Nl" */
- 0x4E, 0x6F, /* "No" */
- 0x5A, 0x73, /* "Zs" */
- 0x5A, 0x6C, /* "Zl" */
- 0x5A, 0x70, /* "Zp" */
- 0x43, 0x63, /* "Cc" */
- 0x43, 0x66, /* "Cf" */
- 0x43, 0x6F, /* "Co" */
- 0x43, 0x73, /* "Cs" */
- 0x50, 0x64, /* "Pd" */
- 0x50, 0x73, /* "Ps" */
- 0x50, 0x65, /* "Pe" */
- 0x50, 0x63, /* "Pc" */
- 0x50, 0x6F, /* "Po" */
- 0x53, 0x6D, /* "Sm" */
- 0x53, 0x63, /* "Sc" */
- 0x53, 0x6B, /* "Sk" */
- 0x53, 0x6F, /* "So" */
- 0x50, 0x69, /* "Pi" */
- 0x50, 0x66, /* "Pf" */
- 0x00
-};
-
-/**
- * Delimiter string used in patterns to close a category reference:
- * ":]". Example: "[:Lu:]".
- */
-static const UChar CATEGORY_CLOSE[] = {COLON, SET_CLOSE, 0x0000}; /* ":]" */
-
-U_NAMESPACE_BEGIN
-
-const char ParsePosition::fgClassID=0;
-
-/**
- * Minimum value that can be stored in a UnicodeSet.
- */
-const UChar32 UnicodeSet::MIN_VALUE = UNICODESET_LOW;
-
-/**
- * Maximum value that can be stored in a UnicodeSet.
- */
-const UChar32 UnicodeSet::MAX_VALUE = UNICODESET_HIGH - 1;
-
-const char UnicodeSet::fgClassID = 0;
-
-static UnicodeSet* INCLUSIONS = NULL; // cached uprv_getInclusions()
-
-static Hashtable* CASE_EQUIV_HASH = NULL; // for closeOver(USET_CASE)
-
-static CompactByteArray* CASE_EQUIV_CBA = NULL; // for closeOver(USET_CASE)
-
-// helper functions for matching of pattern syntax pieces ------------------ ***
-// these functions are parallel to the PERL_OPEN etc. strings above
-
-// using these functions is not only faster than UnicodeString::compare() and
-// caseCompare(), but they also make UnicodeSet work for simple patterns when
-// no Unicode properties data is available - when caseCompare() fails
+// HIGH_VALUE > all valid values. 110000 for codepoints
+#define UNICODESET_HIGH 0x0110000
-static inline UBool
-isPerlOpen(const UnicodeString &pattern, int32_t pos) {
- UChar c;
- return pattern.charAt(pos)==BACKSLASH && ((c=pattern.charAt(pos+1))==LOWER_P || c==UPPER_P);
-}
+// LOW <= all valid values. ZERO for codepoints
+#define UNICODESET_LOW 0x000000
-static inline UBool
-isPerlClose(const UnicodeString &pattern, int32_t pos) {
- return pattern.charAt(pos)==CLOSE_BRACE;
-}
+/** Max list [0, 1, 2, ..., max code point, HIGH] */
+constexpr int32_t MAX_LENGTH = UNICODESET_HIGH + 1;
-static inline UBool
-isNameOpen(const UnicodeString &pattern, int32_t pos) {
- return pattern.charAt(pos)==BACKSLASH && pattern.charAt(pos+1)==UPPER_N;
-}
+U_NAMESPACE_BEGIN
-static inline UBool
-isPOSIXOpen(const UnicodeString &pattern, int32_t pos) {
- return pattern.charAt(pos)==SET_OPEN && pattern.charAt(pos+1)==COLON;
-}
+SymbolTable::~SymbolTable() {}
-static inline UBool
-isPOSIXClose(const UnicodeString &pattern, int32_t pos) {
- return pattern.charAt(pos)==COLON && pattern.charAt(pos+1)==SET_CLOSE;
-}
+UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeSet)
/**
* Modify the given UChar32 variable so that it is in range, by
// UnicodeString in UVector support
//----------------------------------------------------------------
-static void U_CALLCONV cloneUnicodeString(UHashTok *dst, UHashTok *src) {
+static void U_CALLCONV cloneUnicodeString(UElement *dst, UElement *src) {
dst->pointer = new UnicodeString(*(UnicodeString*)src->pointer);
}
-static int8_t U_CALLCONV compareUnicodeString(UHashTok t1, UHashTok t2) {
+static int8_t U_CALLCONV compareUnicodeString(UElement t1, UElement t2) {
const UnicodeString &a = *(const UnicodeString*)t1.pointer;
const UnicodeString &b = *(const UnicodeString*)t2.pointer;
return a.compare(b);
}
+UBool UnicodeSet::hasStrings() const {
+ return strings != nullptr && !strings->isEmpty();
+}
+
+int32_t UnicodeSet::stringsSize() const {
+ return strings == nullptr ? 0 : strings->size();
+}
+
+UBool UnicodeSet::stringsContains(const UnicodeString &s) const {
+ return strings != nullptr && strings->contains((void*) &s);
+}
+
//----------------------------------------------------------------
// Constructors &c
//----------------------------------------------------------------
/**
* Constructs an empty set.
*/
-UnicodeSet::UnicodeSet() :
- len(1), capacity(1 + START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- if(list!=NULL){
- list[0] = UNICODESET_HIGH;
- }
- allocateStrings();
+UnicodeSet::UnicodeSet() {
+ list[0] = UNICODESET_HIGH;
_dbgct(this);
}
* @param start first character, inclusive, of range
* @param end last character, inclusive, of range
*/
-UnicodeSet::UnicodeSet(UChar32 start, UChar32 end) :
- len(1), capacity(1 + START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- if(list!=NULL){
- list[0] = UNICODESET_HIGH;
- }
- allocateStrings();
- complement(start, end);
- _dbgct(this);
-}
-
-/**
- * Constructs a set from the given pattern, optionally ignoring
- * white space. See the class description for the syntax of the
- * pattern language.
- * @param pattern a string specifying what characters are in the set
- */
-UnicodeSet::UnicodeSet(const UnicodeString& pattern,
- UErrorCode& status) :
- len(0), capacity(START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- if(U_SUCCESS(status)){
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- /* test for NULL */
- if(list == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- }else{
- allocateStrings();
- applyPattern(pattern, USET_IGNORE_SPACE, status);
- }
- }
+UnicodeSet::UnicodeSet(UChar32 start, UChar32 end) {
+ list[0] = UNICODESET_HIGH;
+ add(start, end);
_dbgct(this);
}
/**
- * Constructs a set from the given pattern, optionally ignoring
- * white space. See the class description for the syntax of the
- * pattern language.
- * @param pattern a string specifying what characters are in the set
- * @param options bitmask for options to apply to the pattern.
- * Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
+ * Constructs a set that is identical to the given UnicodeSet.
*/
-UnicodeSet::UnicodeSet(const UnicodeString& pattern,
- uint32_t options,
- UErrorCode& status) :
- len(0), capacity(START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- if(U_SUCCESS(status)){
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- /* test for NULL */
- if(list == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- }else{
- allocateStrings();
- applyPattern(pattern, options, status);
- }
- }
- _dbgct(this);
-}
-
-// For internal use by RuleBasedTransliterator
-UnicodeSet::UnicodeSet(const UnicodeString& pattern, ParsePosition& pos,
- const SymbolTable& symbols,
- UErrorCode& status) :
- len(0), capacity(START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- if(U_SUCCESS(status)){
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- /* test for NULL */
- if(list == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- }else{
- allocateStrings();
- applyPattern(pattern, pos, USET_IGNORE_SPACE, &symbols, status);
- }
- }
- _dbgct(this);
-}
-
-// For internal use by TransliteratorIDParser
-UnicodeSet::UnicodeSet(const UnicodeString& pattern, ParsePosition& pos,
- uint32_t options, UErrorCode& status) :
- len(0), capacity(START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- if(U_SUCCESS(status)){
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- /* test for NULL */
- if(list == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- }else{
- allocateStrings();
- applyPattern(pattern, pos, options, NULL, status);
- }
- }
+UnicodeSet::UnicodeSet(const UnicodeSet& o) : UnicodeFilter(o) {
+ *this = o;
_dbgct(this);
}
-#ifdef U_USE_UNICODESET_DEPRECATES
-/**
- * DEPRECATED Constructs a set from the given Unicode character category.
- * @param category an integer indicating the character category as
- * defined in uchar.h.
- * @deprecated To be removed after 2002-DEC-31
- */
-UnicodeSet::UnicodeSet(int8_t category, UErrorCode& status) :
- len(0), capacity(START_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- static const UChar OPEN[] = { 91, 58, 0 }; // "[:"
- static const UChar CLOSE[]= { 58, 93, 0 }; // ":]"
- if (U_SUCCESS(status)) {
- if (category < 0 || category >= U_CHAR_CATEGORY_COUNT) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- } else {
- UnicodeString pattern(FALSE, CATEGORY_NAMES + category*2, 2);
- pattern.insert(0, OPEN);
- pattern.append(CLOSE);
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- /* test for NULL */
- if(list == NULL) {
- status = U_MEMORY_ALLOCATION_ERROR;
- }else{
- allocateStrings();
- applyPattern(pattern, status);
+// Copy-construct as thawed.
+UnicodeSet::UnicodeSet(const UnicodeSet& o, UBool /* asThawed */) : UnicodeFilter(o) {
+ if (ensureCapacity(o.len)) {
+ // *this = o except for bmpSet and stringSpan
+ len = o.len;
+ uprv_memcpy(list, o.list, (size_t)len*sizeof(UChar32));
+ if (o.hasStrings()) {
+ UErrorCode status = U_ZERO_ERROR;
+ if (!allocateStrings(status) ||
+ (strings->assign(*o.strings, cloneUnicodeString, status), U_FAILURE(status))) {
+ setToBogus();
+ return;
}
}
+ if (o.pat) {
+ setPattern(o.pat, o.patLen);
+ }
+ _dbgct(this);
}
- _dbgct(this);
-}
-#endif
-
-/**
- * Constructs a set that is identical to the given UnicodeSet.
- */
-UnicodeSet::UnicodeSet(const UnicodeSet& o) :
- UnicodeFilter(o),
- len(0), capacity(o.len + GROW_EXTRA), bufferCapacity(0),
- list(0), buffer(0), strings(0)
-{
- list = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- if(list!=NULL){
- allocateStrings();
- *this = o;
- }
- _dbgct(this);
}
/**
*/
UnicodeSet::~UnicodeSet() {
_dbgdt(this); // first!
- uprv_free(list);
- if (buffer) {
+ if (list != stackList) {
+ uprv_free(list);
+ }
+ delete bmpSet;
+ if (buffer != stackList) {
uprv_free(buffer);
}
delete strings;
+ delete stringSpan;
+ releasePattern();
}
/**
* Assigns this object to be a copy of another.
*/
UnicodeSet& UnicodeSet::operator=(const UnicodeSet& o) {
- ensureCapacity(o.len);
+ return copyFrom(o, FALSE);
+}
+
+UnicodeSet& UnicodeSet::copyFrom(const UnicodeSet& o, UBool asThawed) {
+ if (this == &o) {
+ return *this;
+ }
+ if (isFrozen()) {
+ return *this;
+ }
+ if (o.isBogus()) {
+ setToBogus();
+ return *this;
+ }
+ if (!ensureCapacity(o.len)) {
+ // ensureCapacity will mark the UnicodeSet as Bogus if OOM failure happens.
+ return *this;
+ }
len = o.len;
- uprv_memcpy(list, o.list, len*sizeof(UChar32));
- UErrorCode ec = U_ZERO_ERROR;
- strings->assign(*o.strings, cloneUnicodeString, ec);
- pat = o.pat;
+ uprv_memcpy(list, o.list, (size_t)len*sizeof(UChar32));
+ if (o.bmpSet != nullptr && !asThawed) {
+ bmpSet = new BMPSet(*o.bmpSet, list, len);
+ if (bmpSet == NULL) { // Check for memory allocation error.
+ setToBogus();
+ return *this;
+ }
+ }
+ if (o.hasStrings()) {
+ UErrorCode status = U_ZERO_ERROR;
+ if ((strings == nullptr && !allocateStrings(status)) ||
+ (strings->assign(*o.strings, cloneUnicodeString, status), U_FAILURE(status))) {
+ setToBogus();
+ return *this;
+ }
+ } else if (hasStrings()) {
+ strings->removeAllElements();
+ }
+ if (o.stringSpan != nullptr && !asThawed) {
+ stringSpan = new UnicodeSetStringSpan(*o.stringSpan, *strings);
+ if (stringSpan == NULL) { // Check for memory allocation error.
+ setToBogus();
+ return *this;
+ }
+ }
+ releasePattern();
+ if (o.pat) {
+ setPattern(o.pat, o.patLen);
+ }
return *this;
}
+/**
+ * Returns a copy of this object. All UnicodeMatcher objects have
+ * to support cloning in order to allow classes using
+ * UnicodeMatchers, such as Transliterator, to implement cloning.
+ */
+UnicodeFunctor* UnicodeSet::clone() const {
+ return new UnicodeSet(*this);
+}
+
+UnicodeFunctor *UnicodeSet::cloneAsThawed() const {
+ return new UnicodeSet(*this, TRUE);
+}
+
/**
* Compares the specified object with this set for equality. Returns
* <tt>true</tt> if the two sets
for (int32_t i = 0; i < len; ++i) {
if (list[i] != o.list[i]) return FALSE;
}
- if (*strings != *o.strings) return FALSE;
+ if (hasStrings() != o.hasStrings()) { return FALSE; }
+ if (hasStrings() && *strings != *o.strings) return FALSE;
return TRUE;
}
-/**
- * Returns a copy of this object. All UnicodeMatcher objects have
- * to support cloning in order to allow classes using
- * UnicodeMatchers, such as Transliterator, to implement cloning.
- */
-UnicodeFunctor* UnicodeSet::clone() const {
- return new UnicodeSet(*this);
-}
-
/**
* Returns the hash code value for this set.
*
* @see Object#hashCode()
*/
int32_t UnicodeSet::hashCode(void) const {
- int32_t result = len;
+ uint32_t result = static_cast<uint32_t>(len);
for (int32_t i = 0; i < len; ++i) {
- result *= 1000003;
+ result *= 1000003u;
result += list[i];
}
- return result;
+ return static_cast<int32_t>(result);
}
//----------------------------------------------------------------
//----------------------------------------------------------------
/**
- * Make this object represent the range <code>start - end</code>.
- * If <code>end > start</code> then this object is set to an
- * an empty range.
+ * Returns the number of elements in this set (its cardinality),
+ * Note than the elements of a set may include both individual
+ * codepoints and strings.
*
- * @param start first character in the set, inclusive
- * @rparam end last character in the set, inclusive
+ * @return the number of elements in this set (its cardinality).
*/
-UnicodeSet& UnicodeSet::set(UChar32 start, UChar32 end) {
- clear();
- complement(start, end);
- return *this;
+int32_t UnicodeSet::size(void) const {
+ int32_t n = 0;
+ int32_t count = getRangeCount();
+ for (int32_t i = 0; i < count; ++i) {
+ n += getRangeEnd(i) - getRangeStart(i) + 1;
+ }
+ return n + stringsSize();
}
/**
- * Modifies this set to represent the set specified by the given
- * pattern, optionally ignoring white space. See the class
- * description for the syntax of the pattern language.
- * @param pattern a string specifying what characters are in the set
- * @param ignoreSpaces if <code>true</code>, all spaces in the
- * pattern are ignored. Spaces are those characters for which
- * <code>uprv_isRuleWhiteSpace()</code> is <code>true</code>.
- * Characters preceded by '\\' are escaped, losing any special
- * meaning they otherwise have. Spaces may be included by
- * escaping them.
- * @exception <code>IllegalArgumentException</code> if the pattern
- * contains a syntax error.
+ * Returns <tt>true</tt> if this set contains no elements.
+ *
+ * @return <tt>true</tt> if this set contains no elements.
*/
-UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern,
- UErrorCode& status) {
- return applyPattern(pattern, USET_IGNORE_SPACE, status);
+UBool UnicodeSet::isEmpty(void) const {
+ return len == 1 && !hasStrings();
}
/**
- * Modifies this set to represent the set specified by the given
- * pattern, optionally ignoring white space. See the class
- * description for the syntax of the pattern language.
- * @param pattern a string specifying what characters are in the set
- * @param options bitmask for options to apply to the pattern.
- * Valid options are USET_IGNORE_SPACE and USET_CASE_INSENSITIVE.
+ * Returns true if this set contains the given character.
+ * @param c character to be checked for containment
+ * @return true if the test condition is met
*/
-UnicodeSet& UnicodeSet::applyPattern(const UnicodeString& pattern,
- uint32_t options,
- UErrorCode& status) {
- if (U_FAILURE(status)) {
- return *this;
+UBool UnicodeSet::contains(UChar32 c) const {
+ // Set i to the index of the start item greater than ch
+ // We know we will terminate without length test!
+ // LATER: for large sets, add binary search
+ //int32_t i = -1;
+ //for (;;) {
+ // if (c < list[++i]) break;
+ //}
+ if (bmpSet != NULL) {
+ return bmpSet->contains(c);
}
+ if (stringSpan != NULL) {
+ return stringSpan->contains(c);
+ }
+ if (c >= UNICODESET_HIGH) { // Don't need to check LOW bound
+ return FALSE;
+ }
+ int32_t i = findCodePoint(c);
+ return (UBool)(i & 1); // return true if odd
+}
- ParsePosition pos(0);
- applyPattern(pattern, pos, options, NULL, status);
- if (U_FAILURE(status)) return *this;
-
- int32_t i = pos.getIndex();
- int32_t n = pattern.length();
+/**
+ * Returns the smallest value i such that c < list[i]. Caller
+ * must ensure that c is a legal value or this method will enter
+ * an infinite loop. This method performs a binary search.
+ * @param c a character in the range MIN_VALUE..MAX_VALUE
+ * inclusive
+ * @return the smallest integer i in the range 0..len-1,
+ * inclusive, such that c < list[i]
+ */
+int32_t UnicodeSet::findCodePoint(UChar32 c) const {
+ /* Examples:
+ findCodePoint(c)
+ set list[] c=0 1 3 4 7 8
+ === ============== ===========
+ [] [110000] 0 0 0 0 0 0
+ [\u0000-\u0003] [0, 4, 110000] 1 1 1 2 2 2
+ [\u0004-\u0007] [4, 8, 110000] 0 0 0 1 1 2
+ [:Any:] [0, 110000] 1 1 1 1 1 1
+ */
- if (options & USET_IGNORE_SPACE) {
- // Skip over trailing whitespace
- while (i<n && uprv_isRuleWhiteSpace(pattern.charAt(i))) {
- ++i;
+ // Return the smallest i such that c < list[i]. Assume
+ // list[len - 1] == HIGH and that c is legal (0..HIGH-1).
+ if (c < list[0])
+ return 0;
+ // High runner test. c is often after the last range, so an
+ // initial check for this condition pays off.
+ int32_t lo = 0;
+ int32_t hi = len - 1;
+ if (lo >= hi || c >= list[hi-1])
+ return hi;
+ // invariant: c >= list[lo]
+ // invariant: c < list[hi]
+ for (;;) {
+ int32_t i = (lo + hi) >> 1;
+ if (i == lo) {
+ break; // Found!
+ } else if (c < list[i]) {
+ hi = i;
+ } else {
+ lo = i;
}
}
-
- if (i != n) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- }
- return *this;
+ return hi;
}
/**
- * Return true if the given position, in the given pattern, appears
- * to be the start of a UnicodeSet pattern.
+ * Returns true if this set contains every character
+ * of the given range.
+ * @param start first character, inclusive, of the range
+ * @param end last character, inclusive, of the range
+ * @return true if the test condition is met
*/
-UBool UnicodeSet::resemblesPattern(const UnicodeString& pattern, int32_t pos) {
- return ((pos+1) < pattern.length() &&
- pattern.charAt(pos) == (UChar)91/*[*/) ||
- resemblesPropertyPattern(pattern, pos);
+UBool UnicodeSet::contains(UChar32 start, UChar32 end) const {
+ //int32_t i = -1;
+ //for (;;) {
+ // if (start < list[++i]) break;
+ //}
+ int32_t i = findCodePoint(start);
+ return ((i & 1) != 0 && end < list[i]);
}
/**
- * Append the <code>toPattern()</code> representation of a
- * string to the given <code>StringBuffer</code>.
+ * Returns <tt>true</tt> if this set contains the given
+ * multicharacter string.
+ * @param s string to be checked for containment
+ * @return <tt>true</tt> if this set contains the specified string
*/
-void UnicodeSet::_appendToPat(UnicodeString& buf, const UnicodeString& s, UBool escapeUnprintable) {
- UChar32 cp;
- for (int32_t i = 0; i < s.length(); i += UTF_CHAR_LENGTH(cp)) {
- _appendToPat(buf, cp = s.char32At(i), escapeUnprintable);
+UBool UnicodeSet::contains(const UnicodeString& s) const {
+ if (s.length() == 0) return FALSE;
+ int32_t cp = getSingleCP(s);
+ if (cp < 0) {
+ return stringsContains(s);
+ } else {
+ return contains((UChar32) cp);
}
}
/**
- * Append the <code>toPattern()</code> representation of a
- * character to the given <code>StringBuffer</code>.
+ * Returns true if this set contains all the characters and strings
+ * of the given set.
+ * @param c set to be checked for containment
+ * @return true if the test condition is met
*/
-void UnicodeSet::_appendToPat(UnicodeString& buf, UChar32 c, UBool escapeUnprintable) {
- if (escapeUnprintable && ICU_Utility::isUnprintable(c)) {
- // Use hex escape notation (\uxxxx or \Uxxxxxxxx) for anything
- // unprintable
- if (ICU_Utility::escapeUnprintable(buf, c)) {
- return;
+UBool UnicodeSet::containsAll(const UnicodeSet& c) const {
+ // The specified set is a subset if all of its pairs are contained in
+ // this set. It's possible to code this more efficiently in terms of
+ // direct manipulation of the inversion lists if the need arises.
+ int32_t n = c.getRangeCount();
+ for (int i=0; i<n; ++i) {
+ if (!contains(c.getRangeStart(i), c.getRangeEnd(i))) {
+ return FALSE;
}
}
- // Okay to let ':' pass through
- switch (c) {
- case SET_OPEN:
- case SET_CLOSE:
- case HYPHEN:
- case COMPLEMENT:
- case INTERSECTION:
- case BACKSLASH:
- case 123/*{*/:
- case 125/*}*/:
- case SymbolTable::SYMBOL_REF:
- case COLON:
- buf.append(BACKSLASH);
- break;
- default:
- // Escape whitespace
- if (uprv_isRuleWhiteSpace(c)) {
- buf.append(BACKSLASH);
- }
- break;
- }
- buf.append(c);
-}
-
-/**
- * Returns a string representation of this set. If the result of
- * calling this function is passed to a UnicodeSet constructor, it
- * will produce another set that is equal to this one.
- */
-UnicodeString& UnicodeSet::toPattern(UnicodeString& result,
- UBool escapeUnprintable) const {
- result.truncate(0);
- return _toPattern(result, escapeUnprintable);
-}
-
-/**
- * Append a string representation of this set to result. This will be
- * a cleaned version of the string passed to applyPattern(), if there
- * is one. Otherwise it will be generated.
- */
-UnicodeString& UnicodeSet::_toPattern(UnicodeString& result,
- UBool escapeUnprintable) const {
- if (pat.length() > 0) {
- int32_t i;
- int32_t backslashCount = 0;
- for (i=0; i<pat.length(); ) {
- UChar32 c = pat.char32At(i);
- i += UTF_CHAR_LENGTH(c);
- if (escapeUnprintable && ICU_Utility::isUnprintable(c)) {
- // If the unprintable character is preceded by an odd
- // number of backslashes, then it has been escaped.
- // Before unescaping it, we delete the final
- // backslash.
- if ((backslashCount % 2) == 1) {
- result.truncate(result.length() - 1);
- }
- ICU_Utility::escapeUnprintable(result, c);
- backslashCount = 0;
- } else {
- result.append(c);
- if (c == BACKSLASH) {
- ++backslashCount;
- } else {
- backslashCount = 0;
- }
- }
- }
- return result;
- }
-
- return _generatePattern(result, escapeUnprintable);
-}
-
-/**
- * Generate and append a string representation of this set to result.
- * This does not use this.pat, the cleaned up copy of the string
- * passed to applyPattern().
- */
-UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
- UBool escapeUnprintable) const {
- result.append(SET_OPEN);
-
-// // Check against the predefined categories. We implicitly build
-// // up ALL category sets the first time toPattern() is called.
-// for (int8_t cat=0; cat<Unicode::GENERAL_TYPES_COUNT; ++cat) {
-// if (*this == getCategorySet(cat)) {
-// result.append(COLON);
-// result.append(CATEGORY_NAMES, cat*2, 2);
-// return result.append(CATEGORY_CLOSE);
-// }
-// }
-
- int32_t count = getRangeCount();
-
- // If the set contains at least 2 intervals and includes both
- // MIN_VALUE and MAX_VALUE, then the inverse representation will
- // be more economical.
- if (count > 1 &&
- getRangeStart(0) == MIN_VALUE &&
- getRangeEnd(count-1) == MAX_VALUE) {
-
- // Emit the inverse
- result.append(COMPLEMENT);
-
- for (int32_t i = 1; i < count; ++i) {
- UChar32 start = getRangeEnd(i-1)+1;
- UChar32 end = getRangeStart(i)-1;
- _appendToPat(result, start, escapeUnprintable);
- if (start != end) {
- result.append(HYPHEN);
- _appendToPat(result, end, escapeUnprintable);
- }
- }
- }
-
- // Default; emit the ranges as pairs
- else {
- for (int32_t i = 0; i < count; ++i) {
- UChar32 start = getRangeStart(i);
- UChar32 end = getRangeEnd(i);
- _appendToPat(result, start, escapeUnprintable);
- if (start != end) {
- result.append(HYPHEN);
- _appendToPat(result, end, escapeUnprintable);
- }
- }
- }
-
- for (int32_t i = 0; i<strings->size(); ++i) {
- result.append(OPEN_BRACE);
- _appendToPat(result,
- *(const UnicodeString*) strings->elementAt(i),
- escapeUnprintable);
- result.append(CLOSE_BRACE);
- }
- return result.append(SET_CLOSE);
-}
-
-/**
- * Returns the number of elements in this set (its cardinality),
- * <em>n</em>, where <code>0 <= </code><em>n</em><code> <= 65536</code>.
- *
- * @return the number of elements in this set (its cardinality).
- */
-int32_t UnicodeSet::size(void) const {
- int32_t n = 0;
- int32_t count = getRangeCount();
- for (int32_t i = 0; i < count; ++i) {
- n += getRangeEnd(i) - getRangeStart(i) + 1;
- }
- return n + strings->size();
-}
-
-/**
- * Returns <tt>true</tt> if this set contains no elements.
- *
- * @return <tt>true</tt> if this set contains no elements.
- */
-UBool UnicodeSet::isEmpty(void) const {
- return len == 1 && strings->size() == 0;
-}
-
-/**
- * Returns true if this set contains the given character.
- * @param c character to be checked for containment
- * @return true if the test condition is met
- */
-UBool UnicodeSet::contains(UChar32 c) const {
- // Set i to the index of the start item greater than ch
- // We know we will terminate without length test!
- // LATER: for large sets, add binary search
- //int32_t i = -1;
- //for (;;) {
- // if (c < list[++i]) break;
- //}
- if (c >= UNICODESET_HIGH) { // Don't need to check LOW bound
- return FALSE;
- }
- int32_t i = findCodePoint(c);
- return ((i & 1) != 0); // return true if odd
-}
-
-/**
- * Returns the smallest value i such that c < list[i]. Caller
- * must ensure that c is a legal value or this method will enter
- * an infinite loop. This method performs a binary search.
- * @param c a character in the range MIN_VALUE..MAX_VALUE
- * inclusive
- * @return the smallest integer i in the range 0..len-1,
- * inclusive, such that c < list[i]
- */
-int32_t UnicodeSet::findCodePoint(UChar32 c) const {
- /* Examples:
- findCodePoint(c)
- set list[] c=0 1 3 4 7 8
- === ============== ===========
- [] [110000] 0 0 0 0 0 0
- [\u0000-\u0003] [0, 4, 110000] 1 1 1 2 2 2
- [\u0004-\u0007] [4, 8, 110000] 0 0 0 1 1 2
- [:Any:] [0, 110000] 1 1 1 1 1 1
- */
-
- // Return the smallest i such that c < list[i]. Assume
- // list[len - 1] == HIGH and that c is legal (0..HIGH-1).
- if (c < list[0]) return 0;
- // High runner test. c is often after the last range, so an
- // initial check for this condition pays off.
- if (len >= 2 && c >= list[len-2]) return len-1;
- int32_t lo = 0;
- int32_t hi = len - 1;
- // invariant: c >= list[lo]
- // invariant: c < list[hi]
- for (;;) {
- int32_t i = (lo + hi) >> 1;
- if (i == lo) return hi;
- if (c < list[i]) {
- hi = i;
- } else {
- lo = i;
- }
- }
- return 0; // To make compiler happy; never reached
-}
-
-/**
- * Returns true if this set contains every character
- * of the given range.
- * @param start first character, inclusive, of the range
- * @param end last character, inclusive, of the range
- * @return true if the test condition is met
- */
-UBool UnicodeSet::contains(UChar32 start, UChar32 end) const {
- //int32_t i = -1;
- //for (;;) {
- // if (start < list[++i]) break;
- //}
- int32_t i = findCodePoint(start);
- return ((i & 1) != 0 && end < list[i]);
-}
-
-/**
- * Returns <tt>true</tt> if this set contains the given
- * multicharacter string.
- * @param s string to be checked for containment
- * @return <tt>true</tt> if this set contains the specified string
- */
-UBool UnicodeSet::contains(const UnicodeString& s) const {
- if (s.length() == 0) return FALSE;
- int32_t cp = getSingleCP(s);
- if (cp < 0) {
- return strings->contains((void*) &s);
- } else {
- return contains((UChar32) cp);
- }
+ return !c.hasStrings() || (strings != nullptr && strings->containsAll(*c.strings));
}
-/**
- * Returns true if this set contains all the characters and strings
- * of the given set.
- * @param c set to be checked for containment
- * @return true if the test condition is met
- */
-UBool UnicodeSet::containsAll(const UnicodeSet& c) const {
- // The specified set is a subset if all of its pairs are contained in
- // this set. It's possible to code this more efficiently in terms of
- // direct manipulation of the inversion lists if the need arises.
- int32_t n = c.getRangeCount();
- for (int i=0; i<n; ++i) {
- if (!contains(c.getRangeStart(i), c.getRangeEnd(i))) {
- return FALSE;
- }
- }
- if (!strings->containsAll(*c.strings)) return FALSE;
- return TRUE;
-}
-
/**
* Returns true if this set contains all the characters
* of the given string.
* @return true if the test condition is met
*/
UBool UnicodeSet::containsAll(const UnicodeString& s) const {
- UChar32 cp;
- for (int32_t i = 0; i < s.length(); i += UTF_CHAR_LENGTH(cp)) {
- cp = s.char32At(i);
- if (!contains(cp)) return FALSE;
- }
- return TRUE;
+ return (UBool)(span(s.getBuffer(), s.length(), USET_SPAN_CONTAINED) ==
+ s.length());
}
-
+
/**
* Returns true if this set contains none of the characters
* of the given range.
return FALSE;
}
}
- if (!strings->containsNone(*c.strings)) return FALSE;
- return TRUE;
+ return strings == nullptr || !c.hasStrings() || strings->containsNone(*c.strings);
}
-
+
/**
* Returns true if this set contains none of the characters
* of the given string.
* @return true if the test condition is met
*/
UBool UnicodeSet::containsNone(const UnicodeString& s) const {
- UChar32 cp;
- for (int32_t i = 0; i < s.length(); i += UTF_CHAR_LENGTH(cp)) {
- cp = s.char32At(i);
- if (contains(cp)) return FALSE;
- }
- return TRUE;
+ return (UBool)(span(s.getBuffer(), s.length(), USET_SPAN_NOT_CONTAINED) ==
+ s.length());
}
/**
* time zone month containment logic.)
*/
int32_t i;
- for (i=0; i<getRangeCount(); ++i) {
+ int32_t rangeCount=getRangeCount();
+ for (i=0; i<rangeCount; ++i) {
UChar32 low = getRangeStart(i);
UChar32 high = getRangeEnd(i);
if ((low & ~0xFF) == (high & ~0xFF)) {
return TRUE;
}
}
- if (strings->size() != 0) {
+ if (hasStrings()) {
for (i=0; i<strings->size(); ++i) {
const UnicodeString& s = *(const UnicodeString*)strings->elementAt(i);
//if (s.length() == 0) {
}
/**
- * Implementation of UnicodeMatcher::matches(). Always matches the
- * longest possible multichar string.
+ * Implementation of UnicodeMatcher::matches(). Always matches the
+ * longest possible multichar string.
*/
UMatchDegree UnicodeSet::matches(const Replaceable& text,
int32_t& offset,
return U_MISMATCH;
}
} else {
- if (strings->size() != 0) { // try strings first
-
+ if (hasStrings()) { // try strings first
+
// might separate forward and backward loops later
// for now they are combined
// forward direction.
if (forward && c > firstChar) break;
if (c != firstChar) continue;
-
+
int32_t matchLen = matchRest(text, offset, limit, trial);
if (incremental) {
}
/**
- * Adds the specified range to this set if it is not already
- * present. If this set already contains the specified range,
- * the call leaves this set unchanged. If <code>end > start</code>
- * then an empty range is added, leaving the set unchanged.
+ * Make this object represent the range <code>start - end</code>.
+ * If <code>end > start</code> then this object is set to an
+ * an empty range.
*
- * @param start first character, inclusive, of range to be added
- * to this set.
- * @param end last character, inclusive, of range to be added
+ * @param start first character in the set, inclusive
+ * @rparam end last character in the set, inclusive
+ */
+UnicodeSet& UnicodeSet::set(UChar32 start, UChar32 end) {
+ clear();
+ complement(start, end);
+ return *this;
+}
+
+/**
+ * Adds the specified range to this set if it is not already
+ * present. If this set already contains the specified range,
+ * the call leaves this set unchanged. If <code>end > start</code>
+ * then an empty range is added, leaving the set unchanged.
+ *
+ * @param start first character, inclusive, of range to be added
+ * to this set.
+ * @param end last character, inclusive, of range to be added
* to this set.
*/
UnicodeSet& UnicodeSet::add(UChar32 start, UChar32 end) {
if (pinCodePoint(start) < pinCodePoint(end)) {
- UChar32 range[3] = { start, end+1, UNICODESET_HIGH };
+ UChar32 limit = end + 1;
+ // Fast path for adding a new range after the last one.
+ // Odd list length: [..., lastStart, lastLimit, HIGH]
+ if ((len & 1) != 0) {
+ // If the list is empty, set lastLimit low enough to not be adjacent to 0.
+ UChar32 lastLimit = len == 1 ? -2 : list[len - 2];
+ if (lastLimit <= start && !isFrozen() && !isBogus()) {
+ if (lastLimit == start) {
+ // Extend the last range.
+ list[len - 2] = limit;
+ if (limit == UNICODESET_HIGH) {
+ --len;
+ }
+ } else {
+ list[len - 1] = start;
+ if (limit < UNICODESET_HIGH) {
+ if (ensureCapacity(len + 2)) {
+ list[len++] = limit;
+ list[len++] = UNICODESET_HIGH;
+ }
+ } else { // limit == UNICODESET_HIGH
+ if (ensureCapacity(len + 1)) {
+ list[len++] = UNICODESET_HIGH;
+ }
+ }
+ }
+ releasePattern();
+ return *this;
+ }
+ }
+ // This is slow. Could be much faster using findCodePoint(start)
+ // and modifying the list, dealing with adjacent & overlapping ranges.
+ UChar32 range[3] = { start, limit, UNICODESET_HIGH };
add(range, 2, 0);
} else if (start == end) {
add(start);
int32_t i = findCodePoint(pinCodePoint(c));
// already in set?
- if ((i & 1) != 0) return *this;
-
+ if ((i & 1) != 0 || isFrozen() || isBogus()) return *this;
+
// HIGH is 0x110000
// assert(list[len-1] == HIGH);
-
+
// empty = [HIGH]
// [start_0, limit_0, start_1, limit_1, HIGH]
-
+
// [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH]
// ^
// list[i]
list[i] = c;
// if we touched the HIGH mark, then add a new one
if (c == (UNICODESET_HIGH - 1)) {
- ensureCapacity(len+1);
+ if (!ensureCapacity(len+1)) {
+ // ensureCapacity will mark the object as Bogus if OOM failure happens.
+ return *this;
+ }
list[len++] = UNICODESET_HIGH;
}
if (i > 0 && c == list[i-1]) {
// ^
// list[i]
- ensureCapacity(len+2);
-
- //for (int32_t k=len-1; k>=i; --k) {
- // list[k+2] = list[k];
- //}
- UChar32* src = list + len;
- UChar32* dst = src + 2;
- UChar32* srclimit = list + i;
- while (src > srclimit) *(--dst) = *(--src);
+ if (!ensureCapacity(len+2)) {
+ // ensureCapacity will mark the object as Bogus if OOM failure happens.
+ return *this;
+ }
+ UChar32 *p = list + i;
+ uprv_memmove(p + 2, p, (len - i) * sizeof(*p));
list[i] = c;
list[i+1] = c+1;
len += 2;
}
-
+
#ifdef DEBUG_US_ADD
dump(list, len);
printf("\n");
printf("ERROR: list has been corrupted\n");
exit(1);
}
- }
+ }
#endif
-
- pat.truncate(0);
+
+ releasePattern();
return *this;
}
* @return the modified set, for chaining
*/
UnicodeSet& UnicodeSet::add(const UnicodeString& s) {
- if (s.length() == 0) return *this;
+ if (s.length() == 0 || isFrozen() || isBogus()) return *this;
int32_t cp = getSingleCP(s);
if (cp < 0) {
- if (!strings->contains((void*) &s)) {
+ if (!stringsContains(s)) {
_add(s);
- pat.truncate(0);
+ releasePattern();
}
} else {
- add((UChar32)cp, (UChar32)cp);
+ add((UChar32)cp);
}
return *this;
}
* already be in 'strings'.
*/
void UnicodeSet::_add(const UnicodeString& s) {
- UnicodeString* t = new UnicodeString(s);
+ if (isFrozen() || isBogus()) {
+ return;
+ }
UErrorCode ec = U_ZERO_ERROR;
+ if (strings == nullptr && !allocateStrings(ec)) {
+ setToBogus();
+ return;
+ }
+ UnicodeString* t = new UnicodeString(s);
+ if (t == NULL) { // Check for memory allocation error.
+ setToBogus();
+ return;
+ }
strings->sortedInsert(t, compareUnicodeString, ec);
+ if (U_FAILURE(ec)) {
+ setToBogus();
+ delete t;
+ }
}
/**
*/
UnicodeSet& UnicodeSet::addAll(const UnicodeString& s) {
UChar32 cp;
- for (int32_t i = 0; i < s.length(); i += UTF_CHAR_LENGTH(cp)) {
+ for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) {
cp = s.char32At(i);
- add(cp, cp);
+ add(cp);
}
return *this;
}
return *this;
}
+UnicodeSet& UnicodeSet::removeAllStrings() {
+ if (!isFrozen() && hasStrings()) {
+ strings->removeAllElements();
+ releasePattern();
+ }
+ return *this;
+}
+
+
/**
* Makes a set from a multicharacter string. Thus "ch" => {"ch"}
* <br><b>Warning: you cannot add an empty string ("") to a UnicodeSet.</b>
* @param the source string
* @return a newly created set containing the given string
*/
-UnicodeSet* UnicodeSet::createFrom(const UnicodeString& s) {
+UnicodeSet* U_EXPORT2 UnicodeSet::createFrom(const UnicodeString& s) {
UnicodeSet *set = new UnicodeSet();
- set->add(s);
+ if (set != NULL) { // Check for memory allocation error.
+ set->add(s);
+ }
return set;
}
* @param the source string
* @return a newly created set containing the given characters
*/
-UnicodeSet* UnicodeSet::createFromAll(const UnicodeString& s) {
+UnicodeSet* U_EXPORT2 UnicodeSet::createFromAll(const UnicodeString& s) {
UnicodeSet *set = new UnicodeSet();
- set->addAll(s);
+ if (set != NULL) { // Check for memory allocation error.
+ set->addAll(s);
+ }
return set;
}
* The set will not contain the specified range once the call
* returns. If <code>end > start</code> then an empty range is
* removed, leaving the set unchanged.
- *
+ *
* @param start first character, inclusive, of range to be removed
* from this set.
* @param end last character, inclusive, of range to be removed
* @return the modified set, for chaining
*/
UnicodeSet& UnicodeSet::remove(const UnicodeString& s) {
- if (s.length() == 0) return *this;
+ if (s.length() == 0 || isFrozen() || isBogus()) return *this;
int32_t cp = getSingleCP(s);
if (cp < 0) {
- strings->removeElement((void*) &s);
- pat.truncate(0);
+ if (strings != nullptr && strings->removeElement((void*) &s)) {
+ releasePattern();
+ }
} else {
remove((UChar32)cp, (UChar32)cp);
}
* from this set.
*/
UnicodeSet& UnicodeSet::complement(UChar32 start, UChar32 end) {
+ if (isFrozen() || isBogus()) {
+ return *this;
+ }
if (pinCodePoint(start) <= pinCodePoint(end)) {
UChar32 range[3] = { start, end+1, UNICODESET_HIGH };
exclusiveOr(range, 2, 0);
}
- pat.truncate(0);
+ releasePattern();
return *this;
}
* <code>complement(MIN_VALUE, MAX_VALUE)</code>.
*/
UnicodeSet& UnicodeSet::complement(void) {
- if (list[0] == UNICODESET_LOW) {
- ensureBufferCapacity(len-1);
- uprv_memcpy(buffer, list + 1, (len-1)*sizeof(UChar32));
+ if (isFrozen() || isBogus()) {
+ return *this;
+ }
+ if (list[0] == UNICODESET_LOW) {
+ uprv_memmove(list, list + 1, (size_t)(len-1)*sizeof(UChar32));
--len;
} else {
- ensureBufferCapacity(len+1);
- uprv_memcpy(buffer + 1, list, len*sizeof(UChar32));
- buffer[0] = UNICODESET_LOW;
+ if (!ensureCapacity(len+1)) {
+ return *this;
+ }
+ uprv_memmove(list + 1, list, (size_t)len*sizeof(UChar32));
+ list[0] = UNICODESET_LOW;
++len;
}
- swapBuffers();
- pat.truncate(0);
+ releasePattern();
return *this;
}
* @return this object, for chaining
*/
UnicodeSet& UnicodeSet::complement(const UnicodeString& s) {
- if (s.length() == 0) return *this;
+ if (s.length() == 0 || isFrozen() || isBogus()) return *this;
int32_t cp = getSingleCP(s);
if (cp < 0) {
- if (strings->contains((void*) &s)) {
+ if (stringsContains(s)) {
strings->removeElement((void*) &s);
} else {
_add(s);
}
- pat.truncate(0);
+ releasePattern();
} else {
complement((UChar32)cp, (UChar32)cp);
}
return *this;
-}
+}
/**
* Adds all of the elements in the specified set to this set if
* @see #add(char, char)
*/
UnicodeSet& UnicodeSet::addAll(const UnicodeSet& c) {
- add(c.list, c.len, 0);
+ if ( c.len>0 && c.list!=NULL ) {
+ add(c.list, c.len, 0);
+ }
- // Add strings in order
- for (int32_t i=0; i<c.strings->size(); ++i) {
- const UnicodeString* s = (const UnicodeString*)c.strings->elementAt(i);
- if (!strings->contains((void*) s)) {
- _add(*s);
+ // Add strings in order
+ if ( c.strings!=NULL ) {
+ for (int32_t i=0; i<c.strings->size(); ++i) {
+ const UnicodeString* s = (const UnicodeString*)c.strings->elementAt(i);
+ if (!stringsContains(*s)) {
+ _add(*s);
+ }
}
}
return *this;
* @param c set that defines which elements this set will retain.
*/
UnicodeSet& UnicodeSet::retainAll(const UnicodeSet& c) {
+ if (isFrozen() || isBogus()) {
+ return *this;
+ }
retain(c.list, c.len, 0);
- strings->retainAll(*c.strings);
+ if (hasStrings()) {
+ if (!c.hasStrings()) {
+ strings->removeAllElements();
+ } else {
+ strings->retainAll(*c.strings);
+ }
+ }
return *this;
}
* this set.
*/
UnicodeSet& UnicodeSet::removeAll(const UnicodeSet& c) {
+ if (isFrozen() || isBogus()) {
+ return *this;
+ }
retain(c.list, c.len, 2);
- strings->removeAll(*c.strings);
+ if (hasStrings() && c.hasStrings()) {
+ strings->removeAll(*c.strings);
+ }
return *this;
}
* this set.
*/
UnicodeSet& UnicodeSet::complementAll(const UnicodeSet& c) {
+ if (isFrozen() || isBogus()) {
+ return *this;
+ }
exclusiveOr(c.list, c.len, 0);
- for (int32_t i=0; i<c.strings->size(); ++i) {
- void* e = c.strings->elementAt(i);
- if (!strings->removeElement(e)) {
- _add(*(const UnicodeString*)e);
+ if (c.strings != nullptr) {
+ for (int32_t i=0; i<c.strings->size(); ++i) {
+ void* e = c.strings->elementAt(i);
+ if (strings == nullptr || !strings->removeElement(e)) {
+ _add(*(const UnicodeString*)e);
+ }
}
}
return *this;
* empty after this call returns.
*/
UnicodeSet& UnicodeSet::clear(void) {
+ if (isFrozen()) {
+ return *this;
+ }
list[0] = UNICODESET_HIGH;
len = 1;
- pat.truncate(0);
- strings->removeAllElements();
+ releasePattern();
+ if (strings != NULL) {
+ strings->removeAllElements();
+ }
+ // Remove bogus
+ fFlags = 0;
return *this;
}
return list[index*2 + 1] - 1;
}
-int32_t UnicodeSet::getStringCount() const {
- return strings->size();
-}
-
const UnicodeString* UnicodeSet::getString(int32_t index) const {
return (const UnicodeString*) strings->elementAt(index);
}
* possible space, without changing this object's value.
*/
UnicodeSet& UnicodeSet::compact() {
- if (len != capacity) {
- capacity = len;
- UChar32* temp = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- uprv_memcpy(temp, list, len*sizeof(UChar32));
+ if (isFrozen() || isBogus()) {
+ return *this;
+ }
+ // Delete buffer first to defragment memory less.
+ if (buffer != stackList) {
+ uprv_free(buffer);
+ buffer = NULL;
+ bufferCapacity = 0;
+ }
+ if (list == stackList) {
+ // pass
+ } else if (len <= INITIAL_CAPACITY) {
+ uprv_memcpy(stackList, list, len * sizeof(UChar32));
uprv_free(list);
- list = temp;
+ list = stackList;
+ capacity = INITIAL_CAPACITY;
+ } else if ((len + 7) < capacity) {
+ // If we have more than a little unused capacity, shrink it to len.
+ UChar32* temp = (UChar32*) uprv_realloc(list, sizeof(UChar32) * len);
+ if (temp) {
+ list = temp;
+ capacity = len;
+ }
+ // else what the heck happened?! We allocated less memory!
+ // Oh well. We'll keep our original array.
+ }
+ if (strings != nullptr && strings->isEmpty()) {
+ delete strings;
+ strings = nullptr;
}
- uprv_free(buffer);
- buffer = NULL;
return *this;
}
+#ifdef DEBUG_SERIALIZE
+#include <stdio.h>
+#endif
+
+/**
+ * Deserialize constructor.
+ */
+UnicodeSet::UnicodeSet(const uint16_t data[], int32_t dataLen, ESerialization serialization,
+ UErrorCode &ec) {
+
+ if(U_FAILURE(ec)) {
+ setToBogus();
+ return;
+ }
+
+ if( (serialization != kSerialized)
+ || (data==NULL)
+ || (dataLen < 1)) {
+ ec = U_ILLEGAL_ARGUMENT_ERROR;
+ setToBogus();
+ return;
+ }
+
+ // bmp?
+ int32_t headerSize = ((data[0]&0x8000)) ?2:1;
+ int32_t bmpLength = (headerSize==1)?data[0]:data[1];
+
+ int32_t newLength = (((data[0]&0x7FFF)-bmpLength)/2)+bmpLength;
+#ifdef DEBUG_SERIALIZE
+ printf("dataLen %d headerSize %d bmpLen %d len %d. data[0]=%X/%X/%X/%X\n", dataLen,headerSize,bmpLength,newLength, data[0],data[1],data[2],data[3]);
+#endif
+ if(!ensureCapacity(newLength + 1)) { // +1 for HIGH
+ return;
+ }
+ // copy bmp
+ int32_t i;
+ for(i = 0; i< bmpLength;i++) {
+ list[i] = data[i+headerSize];
+#ifdef DEBUG_SERIALIZE
+ printf("<<16@%d[%d] %X\n", i+headerSize, i, list[i]);
+#endif
+ }
+ // copy smp
+ for(i=bmpLength;i<newLength;i++) {
+ list[i] = ((UChar32)data[headerSize+bmpLength+(i-bmpLength)*2+0] << 16) +
+ ((UChar32)data[headerSize+bmpLength+(i-bmpLength)*2+1]);
+#ifdef DEBUG_SERIALIZE
+ printf("<<32@%d+[%d] %lX\n", headerSize+bmpLength+i, i, list[i]);
+#endif
+ }
+ U_ASSERT(i == newLength);
+ if (i == 0 || list[i - 1] != UNICODESET_HIGH) {
+ list[i++] = UNICODESET_HIGH;
+ }
+ len = i;
+}
+
+
int32_t UnicodeSet::serialize(uint16_t *dest, int32_t destCapacity, UErrorCode& ec) const {
int32_t bmpLength, length, destLength;
for (bmpLength=0; bmpLength<length && this->list[bmpLength]<=0xffff; ++bmpLength) {}
length=bmpLength+2*(length-bmpLength);
}
-
+#ifdef DEBUG_SERIALIZE
+ printf(">> bmpLength%d length%d len%d\n", bmpLength, length, len);
+#endif
/* length: number of 16-bit array units */
if (length>0x7fff) {
/* there are only 15 bits for the length in the first serialized word */
const UChar32 *p;
int32_t i;
+#ifdef DEBUG_SERIALIZE
+ printf("writeHdr\n");
+#endif
*dest=(uint16_t)length;
if (length>bmpLength) {
*dest|=0x8000;
/* write the BMP part of the array */
p=this->list;
for (i=0; i<bmpLength; ++i) {
+#ifdef DEBUG_SERIALIZE
+ printf("writebmp: %x\n", (int)*p);
+#endif
*dest++=(uint16_t)*p++;
}
/* write the supplementary part of the array */
for (; i<length; i+=2) {
+#ifdef DEBUG_SERIALIZE
+ printf("write32: %x\n", (int)*p);
+#endif
*dest++=(uint16_t)(*p>>16);
*dest++=(uint16_t)*p++;
}
}
//----------------------------------------------------------------
-// Implementation: Pattern parsing
+// Implementation: Utility methods
//----------------------------------------------------------------
/**
- * Parses the given pattern, starting at the given position. The
- * character at pattern.charAt(pos.getIndex()) must be '[', or the
- * parse fails. Parsing continues until the corresponding closing
- * ']'. If a syntax error is encountered between the opening and
- * closing brace, the parse fails. Upon return from a successful
- * parse, the ParsePosition is updated to point to the character
- * following the closing ']', and a StringBuffer containing a
- * pairs list for the parsed pattern is returned. This method calls
- * itself recursively to parse embedded subpatterns.
- *
- * @param pattern the string containing the pattern to be parsed.
- * The portion of the string from pos.getIndex(), which must be a
- * '[', to the corresponding closing ']', is parsed.
- * @param pos upon entry, the position at which to being parsing.
- * The character at pattern.charAt(pos.getIndex()) must be a '['.
- * Upon return from a U_SUCCESSful parse, pos.getIndex() is either
- * the character after the closing ']' of the parsed pattern, or
- * pattern.length() if the closing ']' is the last character of
- * the pattern string.
- * @return a StringBuffer containing a pairs list for the parsed
- * substring of <code>pattern</code>
- * @exception IllegalArgumentException if the parse fails.
+ * Allocate our strings vector and return TRUE if successful.
*/
-void UnicodeSet::applyPattern(const UnicodeString& pattern,
- ParsePosition& pos,
- uint32_t options,
- const SymbolTable* symbols,
- UErrorCode& status) {
+UBool UnicodeSet::allocateStrings(UErrorCode &status) {
if (U_FAILURE(status)) {
- return;
+ return FALSE;
}
-
- // Need to build the pattern in a temporary string because
- // _applyPattern calls add() etc., which set pat to empty.
- UnicodeString rebuiltPat;
- _applyPattern(pattern, pos, options, symbols, rebuiltPat, status);
- pat = rebuiltPat;
-}
-
-void UnicodeSet::_applyPattern(const UnicodeString& pattern,
- ParsePosition& pos,
- uint32_t options,
- const SymbolTable* symbols,
- UnicodeString& rebuiltPat,
- UErrorCode& status) {
-
- if (U_FAILURE(status)) {
- return;
+ strings = new UVector(uprv_deleteUObject,
+ uhash_compareUnicodeString, 1, status);
+ if (strings == NULL) { // Check for memory allocation error.
+ status = U_MEMORY_ALLOCATION_ERROR;
+ return FALSE;
}
+ if (U_FAILURE(status)) {
+ delete strings;
+ strings = NULL;
+ return FALSE;
+ }
+ return TRUE;
+}
- // If the pattern contains any of the following, we save a
- // rebuilt (variable-substituted) copy of the source pattern:
- // - a category
- // - an intersection or subtraction operator
- // - an anchor (trailing '$', indicating RBT ether)
- UBool rebuildPattern = FALSE;
- UnicodeString newPat(SET_OPEN);
- int32_t nestedPatStart = - 1; // see below for usage
- UBool nestedPatDone = FALSE; // see below for usage
- UnicodeString multiCharBuffer;
-
- UBool invert = FALSE;
- clear();
-
- const UChar32 NONE = (UChar32) -1;
- UChar32 lastChar = NONE; // This is either a char (0..10FFFF) or NONE
- UBool isLastLiteral = FALSE; // TRUE if lastChar was a literal
- UChar lastOp = 0;
-
- /* This loop iterates over the characters in the pattern. We start at
- * the position specified by pos. We exit the loop when either a
- * matching closing ']' is seen, or we read all characters of the
- * pattern. In the latter case an error will be thrown.
- */
-
- /* Pattern syntax:
- * pat := '[' '^'? elem* ']'
- * elem := a | a '-' a | set | set op set
- * set := pat | (a set variable)
- * op := '&' | '-'
- * a := (a character, possibly defined by a var)
- */
-
- // mode 0: No chars parsed yet; next must be '['
- // mode 1: '[' seen; if next is '^' or ':' then special
- // mode 15: "[^" seen; if next is '-' then literal
- // mode 2: '[' '^'? '-'? seen; parse pattern and close with ']'
- // mode 3: '[:' seen; parse category and close with ':]'
- // mode 4: ']' seen; parse complete
- // mode 5: Top-level property pattern seen
- int8_t mode = 0;
- int32_t i = pos.getIndex();
- int32_t limit = pattern.length();
- UnicodeSet nestedAux;
- const UnicodeSet* nestedSet; // never owned
- UnicodeString scratch;
- /* In the case of an embedded SymbolTable variable, we look it up and
- * then take characters from the resultant char[] array. These chars
- * are subjected to an extra level of lookup in the SymbolTable in case
- * they are stand-ins for a nested UnicodeSet. */
- const UnicodeString* varValueBuffer = NULL;
- int32_t ivarValueBuffer = 0;
- int32_t anchor = 0;
- UChar32 c;
- while (i<limit) {
- /* If the next element is a single character, c will be set to it,
- * and nestedSet will be null. In this case isLiteral indicates
- * whether the character should assume special meaning if it has
- * one. If the next element is a nested set, either via a variable
- * reference, or via an embedded "[..]" or "[:..:]" pattern, then
- * nestedSet will be set to the pairs list for the nested set, and
- * c's value should be ignored.
- */
- nestedSet = NULL;
- UBool isLiteral = FALSE;
- if (varValueBuffer != NULL) {
- if (ivarValueBuffer < varValueBuffer->length()) {
- c = varValueBuffer->char32At(ivarValueBuffer);
- ivarValueBuffer += UTF_CHAR_LENGTH(c);
- const UnicodeFunctor *m = symbols->lookupMatcher(c); // may be NULL
- if (m != NULL && m->getDynamicClassID() != UnicodeSet::getStaticClassID()) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- nestedSet = (UnicodeSet*) m;
- nestedPatDone = FALSE;
- } else {
- varValueBuffer = NULL;
- c = pattern.char32At(i);
- i += UTF_CHAR_LENGTH(c);
- }
- } else {
- c = pattern.char32At(i);
- i += UTF_CHAR_LENGTH(c);
- }
-
- if ((options & USET_IGNORE_SPACE) && uprv_isRuleWhiteSpace(c)) {
- continue;
- }
-
- // Keep track of the count of characters after an alleged anchor
- if (anchor > 0) {
- ++anchor;
- }
-
- // Parse the opening '[' and optional following '^'
- switch (mode) {
- case 0:
- if (resemblesPropertyPattern(pattern, i-1)) {
- mode = 3;
- break; // Fall through
- } else if (c == SET_OPEN) {
- mode = 1; // Next look for '^' or ':'
- continue;
- } else {
- // throw new IllegalArgumentException("Missing opening '['");
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- case 1:
- mode = 2;
- switch (c) {
- case COMPLEMENT:
- invert = TRUE;
- newPat.append(c);
- mode = 15;
- continue; // Back to top to fetch next character
- case HYPHEN:
- isLiteral = TRUE; // Treat leading '-' as a literal
- break; // Fall through
- }
- break;
- case 15:
- mode = 2;
- if (c == HYPHEN) {
- isLiteral = TRUE; // [^-...] starts with literal '-'
- }
- break;
- // else fall through and parse this character normally
- }
-
- // After opening matter is parsed ("[", "[^", or "[:"), the mode
- // will be 2 if we want a closing ']', or 3 if we should parse a
- // category and close with ":]".
-
- // Only process escapes, variable references, and nested sets
- // if we are _not_ retrieving characters from the variable
- // buffer. Characters in the variable buffer have already
- // benn through escape and variable reference processing.
- if (varValueBuffer == NULL) {
- /**
- * Handle property set patterns.
- */
- if (resemblesPropertyPattern(pattern, i-1)) {
- ParsePosition pp(i-1);
- nestedAux.applyPropertyPattern(pattern, pp, status);
- if (U_FAILURE(status)) {
- U_ASSERT(pp.getIndex() == i-1);
- //throw new IllegalArgumentException("Invalid property pattern " +
- // pattern.substring(i-1));
- return;
- }
- nestedSet = &nestedAux;
- nestedPatStart = newPat.length();
- nestedPatDone = TRUE; // we're going to do it just below
-
- switch (lastOp) {
- case HYPHEN:
- case INTERSECTION:
- newPat.append(lastOp);
- break;
- }
-
- // If we have a top-level property pattern, then trim
- // off the opening '[' and use the property pattern
- // as the entire pattern.
- if (mode == 3) {
- newPat.truncate(0);
- }
- UnicodeString str;
- pattern.extractBetween(i-1, pp.getIndex(), str);
- newPat.append(str);
- rebuildPattern = TRUE;
-
- i = pp.getIndex(); // advance past property pattern
-
- if (mode == 3) {
- // Entire pattern is a category; leave parse
- // loop. This is one of 2 ways we leave this
- // loop if the pattern is well-formed.
- *this = nestedAux;
- mode = 5;
- break;
- }
- }
-
- /* Handle escapes. If a character is escaped, then it assumes its
- * literal value. This is true for all characters, both special
- * characters and characters with no special meaning. We also
- * interpret '\\uxxxx' Unicode escapes here (as literals).
- */
- else if (c == BACKSLASH) {
- UChar32 escaped = pattern.unescapeAt(i);
- if (escaped == (UChar32) -1) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- isLiteral = TRUE;
- c = escaped;
- }
-
- /* Parse variable references. These are treated as literals. If a
- * variable refers to a UnicodeSet, its stand in character is
- * returned in the UChar[] buffer.
- * Variable names are only parsed if varNameToChar is not null.
- * Set variables are only looked up if varCharToSet is not null.
- */
- else if (symbols != NULL && !isLiteral && c == SymbolTable::SYMBOL_REF) {
- pos.setIndex(i);
- UnicodeString name = symbols->parseReference(pattern, pos, limit);
- if (name.length() != 0) {
- varValueBuffer = symbols->lookup(name);
- if (varValueBuffer == NULL) {
- //throw new IllegalArgumentException("Undefined variable: "
- // + name);
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- ivarValueBuffer = 0;
- i = pos.getIndex(); // Make i point PAST last char of var name
- } else {
- // Got a null; this means we have an isolated $.
- // Tentatively assume this is an anchor.
- anchor = 1;
- }
- continue; // Back to the top to get varValueBuffer[0]
- }
-
- /* An opening bracket indicates the first bracket of a nested
- * subpattern.
- */
- else if (!isLiteral && c == SET_OPEN) {
- // Record position before nested pattern
- nestedPatStart = newPat.length();
-
- // Recurse to get the pairs for this nested set.
- // Backup i to '['.
- pos.setIndex(--i);
- switch (lastOp) {
- case HYPHEN:
- case INTERSECTION:
- newPat.append(lastOp);
- break;
- }
- nestedAux._applyPattern(pattern, pos, options, symbols, newPat, status);
- nestedSet = &nestedAux;
- nestedPatDone = TRUE;
- if (U_FAILURE(status)) {
- return;
- }
- i = pos.getIndex();
- }
-
- else if (!isLiteral && c == OPEN_BRACE) {
- // start of a string. find the rest.
- int32_t length = 0;
- int32_t st = i;
- multiCharBuffer.truncate(0);
- while (i < pattern.length()) {
- UChar32 ch = pattern.char32At(i);
- i += UTF_CHAR_LENGTH(ch);
- if (ch == CLOSE_BRACE) {
- length = -length; // signal that we saw '}'
- break;
- } else if (ch == BACKSLASH) {
- ch = pattern.unescapeAt(i);
- if (ch == (UChar32) -1) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- }
- --length; // sic; see above
- multiCharBuffer.append(ch);
- }
- if (length < 1) {
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- // We have new string. Add it to set and continue;
- // we don't need to drop through to the further
- // processing
- add(multiCharBuffer);
- pattern.extractBetween(st, i, multiCharBuffer);
- newPat.append(OPEN_BRACE).append(multiCharBuffer);
- rebuildPattern = TRUE;
- continue;
- }
- }
-
- /* At this point we have either a character c, or a nested set. If
- * we have encountered a nested set, either embedded in the pattern,
- * or as a variable, we have a non-null nestedSet, and c should be
- * ignored. Otherwise c is the current character, and isLiteral
- * indicates whether it is an escaped literal (or variable) or a
- * normal unescaped character. Unescaped characters '-', '&', and
- * ']' have special meanings.
- */
- if (nestedSet != NULL) {
- if (lastChar != NONE) {
- if (lastOp != 0) {
- // throw new IllegalArgumentException("Illegal rhs for " + lastChar + lastOp);
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- add(lastChar, lastChar);
- if (nestedPatDone) {
- // If there was a character before the nested set,
- // then we need to insert it in newPat before the
- // pattern for the nested set. This position was
- // recorded in nestedPatStart.
- UnicodeString s;
- _appendToPat(s, lastChar, FALSE);
- newPat.insert(nestedPatStart, s);
- } else {
- _appendToPat(newPat, lastChar, FALSE);
- }
- lastChar = NONE;
- }
- switch (lastOp) {
- case HYPHEN:
- removeAll(*nestedSet);
- break;
- case INTERSECTION:
- retainAll(*nestedSet);
- break;
- case 0:
- addAll(*nestedSet);
- break;
- }
-
- // Get the pattern for the nested set, if we haven't done so
- // already.
- if (!nestedPatDone) {
- if (lastOp != 0) {
- newPat.append(lastOp);
- }
- nestedSet->_toPattern(newPat, FALSE);
- }
- rebuildPattern = TRUE;
-
- lastOp = 0;
-
- } else if (!isLiteral && c == SET_CLOSE) {
- // Final closing delimiter. This is one of 2 ways we
- // leave this loop if the pattern is well-formed.
- if (anchor > 2 || anchor == 1) {
- //throw new IllegalArgumentException("Syntax error near $" + pattern);
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- if (anchor == 2) {
- rebuildPattern = TRUE;
- newPat.append((UChar)SymbolTable::SYMBOL_REF);
- add(U_ETHER);
- }
- mode = 4;
- break;
- } else if (lastOp == 0 && !isLiteral && (c == HYPHEN || c == INTERSECTION)) {
- // assert(c <= 0xFFFF);
- lastOp = (UChar) c;
- } else if (lastOp == HYPHEN) {
- if (lastChar >= c || lastChar == NONE) {
- // Don't allow redundant (a-a) or empty (b-a) ranges;
- // these are most likely typos.
- //throw new IllegalArgumentException("Invalid range " + lastChar +
- // '-' + c);
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
- add(lastChar, c);
- _appendToPat(newPat, lastChar, FALSE);
- newPat.append(HYPHEN);
- _appendToPat(newPat, c, FALSE);
- lastOp = 0;
- lastChar = NONE;
- } else if (lastOp != 0) {
- // We have <set>&<char> or <char>&<char>
- // throw new IllegalArgumentException("Unquoted " + lastOp);
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- } else {
- if (lastChar != NONE) {
- // We have <char><char>
- add(lastChar, lastChar);
- _appendToPat(newPat, lastChar, FALSE);
- }
- lastChar = c;
- isLastLiteral = isLiteral;
+int32_t UnicodeSet::nextCapacity(int32_t minCapacity) {
+ // Grow exponentially to reduce the frequency of allocations.
+ if (minCapacity < INITIAL_CAPACITY) {
+ return minCapacity + INITIAL_CAPACITY;
+ } else if (minCapacity <= 2500) {
+ return 5 * minCapacity;
+ } else {
+ int32_t newCapacity = 2 * minCapacity;
+ if (newCapacity > MAX_LENGTH) {
+ newCapacity = MAX_LENGTH;
}
+ return newCapacity;
}
+}
- if (mode < 4) {
- // throw new IllegalArgumentException("Missing ']'");
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
- }
-
- // Treat a trailing '$' as indicating U_ETHER. This code is only
- // executed if symbols == NULL; otherwise other code parses the
- // anchor.
- if (lastChar == (UChar)SymbolTable::SYMBOL_REF && !isLastLiteral) {
- rebuildPattern = TRUE;
- newPat.append(lastChar);
- add(U_ETHER);
- }
-
- else if (lastChar != NONE) {
- add(lastChar, lastChar);
- _appendToPat(newPat, lastChar, FALSE);
+bool UnicodeSet::ensureCapacity(int32_t newLen) {
+ if (newLen > MAX_LENGTH) {
+ newLen = MAX_LENGTH;
}
-
- // Handle unprocessed stuff preceding the closing ']'
- if (lastOp == HYPHEN) {
- // Trailing '-' is treated as literal
- add(lastOp, lastOp);
- newPat.append(HYPHEN);
- } else if (lastOp == INTERSECTION) {
- // throw new IllegalArgumentException("Unquoted trailing " + lastOp);
- status = U_ILLEGAL_ARGUMENT_ERROR;
- return;
+ if (newLen <= capacity) {
+ return true;
}
-
- if (mode == 4) {
- newPat.append(SET_CLOSE);
+ int32_t newCapacity = nextCapacity(newLen);
+ UChar32* temp = (UChar32*) uprv_malloc(newCapacity * sizeof(UChar32));
+ if (temp == NULL) {
+ setToBogus(); // set the object to bogus state if an OOM failure occurred.
+ return false;
}
-
- /**
- * If this pattern should be compiled case-insensitive, then
- * we need to close over case BEFORE complementing. This
- * makes patterns like /[^abc]/i work.
- */
- if ((options & USET_CASE_INSENSITIVE) != 0) {
- closeOver(USET_CASE);
+ // Copy only the actual contents.
+ uprv_memcpy(temp, list, len * sizeof(UChar32));
+ if (list != stackList) {
+ uprv_free(list);
}
+ list = temp;
+ capacity = newCapacity;
+ return true;
+}
- /**
- * If we saw a '^' after the initial '[' of this pattern, then perform
- * the complement. (Inversion after '[:' is handled elsewhere.)
- */
- if (invert) {
- complement();
+bool UnicodeSet::ensureBufferCapacity(int32_t newLen) {
+ if (newLen > MAX_LENGTH) {
+ newLen = MAX_LENGTH;
}
-
- pos.setIndex(i);
-
- // Use the rebuilt pattern (newPat) only if necessary. Prefer the
- // generated pattern.
- if (rebuildPattern) {
- rebuiltPat.append(newPat);
- } else {
- _generatePattern(rebuiltPat, FALSE);
+ if (newLen <= bufferCapacity) {
+ return true;
}
-}
-
-//----------------------------------------------------------------
-// Implementation: Utility methods
-//----------------------------------------------------------------
-
-/**
- * Allocate our strings vector and return TRUE if successful.
- */
-UBool UnicodeSet::allocateStrings() {
- UErrorCode ec = U_ZERO_ERROR;
- strings = new UVector(uhash_deleteUnicodeString,
- uhash_compareUnicodeString, ec);
- if (U_FAILURE(ec)) {
- delete strings;
- strings = NULL;
- return FALSE;
+ int32_t newCapacity = nextCapacity(newLen);
+ UChar32* temp = (UChar32*) uprv_malloc(newCapacity * sizeof(UChar32));
+ if (temp == NULL) {
+ setToBogus();
+ return false;
}
- return TRUE;
-}
-
-void UnicodeSet::ensureCapacity(int32_t newLen) {
- if (newLen <= capacity)
- return;
- capacity = newLen + GROW_EXTRA;
- UChar32* temp = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
- uprv_memcpy(temp, list, len*sizeof(UChar32));
- uprv_free(list);
- list = temp;
-}
-
-void UnicodeSet::ensureBufferCapacity(int32_t newLen) {
- if (buffer != NULL && newLen <= bufferCapacity)
- return;
- if (buffer) {
+ // The buffer has no contents to be copied.
+ // It is always filled from scratch after this call.
+ if (buffer != stackList) {
uprv_free(buffer);
}
- bufferCapacity = newLen + GROW_EXTRA;
- buffer = (UChar32*) uprv_malloc(sizeof(UChar32) * bufferCapacity);
+ buffer = temp;
+ bufferCapacity = newCapacity;
+ return true;
}
/**
bufferCapacity = c;
}
+void UnicodeSet::setToBogus() {
+ clear(); // Remove everything in the set.
+ fFlags = kIsBogus;
+}
+
//----------------------------------------------------------------
// Implementation: Fundamental operators
//----------------------------------------------------------------
// polarity = 1, 2: x xor ~y == x === y
void UnicodeSet::exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity) {
- ensureBufferCapacity(len + otherLen);
+ if (isFrozen() || isBogus()) {
+ return;
+ }
+ if (!ensureBufferCapacity(len + otherLen)) {
+ return;
+ }
+
int32_t i = 0, j = 0, k = 0;
UChar32 a = list[i++];
UChar32 b;
}
}
swapBuffers();
- pat.truncate(0);
+ releasePattern();
}
// polarity = 0 is normal: x union y
// polarity = 3: ~x union ~y
void UnicodeSet::add(const UChar32* other, int32_t otherLen, int8_t polarity) {
- ensureBufferCapacity(len + otherLen);
+ if (isFrozen() || isBogus() || other==NULL) {
+ return;
+ }
+ if (!ensureBufferCapacity(len + otherLen)) {
+ return;
+ }
+
int32_t i = 0, j = 0, k = 0;
UChar32 a = list[i++];
UChar32 b = other[j++];
buffer[k++] = UNICODESET_HIGH; // terminate
len = k;
swapBuffers();
- pat.truncate(0);
+ releasePattern();
}
// polarity = 0 is normal: x intersect y
// polarity = 3: ~x intersect ~y
void UnicodeSet::retain(const UChar32* other, int32_t otherLen, int8_t polarity) {
- ensureBufferCapacity(len + otherLen);
- int32_t i = 0, j = 0, k = 0;
- UChar32 a = list[i++];
- UChar32 b = other[j++];
- // change from xor is that we have to check overlapping pairs
+ if (isFrozen() || isBogus()) {
+ return;
+ }
+ if (!ensureBufferCapacity(len + otherLen)) {
+ return;
+ }
+
+ int32_t i = 0, j = 0, k = 0;
+ UChar32 a = list[i++];
+ UChar32 b = other[j++];
+ // change from xor is that we have to check overlapping pairs
// polarity bit 1 means a is second, bit 2 means b is.
for (;;) {
switch (polarity) {
buffer[k++] = UNICODESET_HIGH; // terminate
len = k;
swapBuffers();
- pat.truncate(0);
-}
-
-//----------------------------------------------------------------
-// Property set implementation
-//----------------------------------------------------------------
-
-static UBool numericValueFilter(UChar32 ch, void* context) {
- return u_getNumericValue(ch) == *(double*)context;
-}
-
-static UBool generalCategoryMaskFilter(UChar32 ch, void* context) {
- int32_t value = *(int32_t*)context;
- return (U_GET_GC_MASK((UChar32) ch) & value) != 0;
-}
-
-static UBool versionFilter(UChar32 ch, void* context) {
- UVersionInfo v, none = { 0, 0, 0, 0};
- UVersionInfo* version = (UVersionInfo*)context;
- u_charAge(ch, v);
- return uprv_memcmp(&v, &none, sizeof(v)) > 0 && uprv_memcmp(&v, version, sizeof(v)) <= 0;
+ releasePattern();
}
-typedef struct {
- UProperty prop;
- int32_t value;
-} IntPropertyContext;
-
-static UBool intPropertyFilter(UChar32 ch, void* context) {
- IntPropertyContext* c = (IntPropertyContext*)context;
- return u_getIntPropertyValue((UChar32) ch, c->prop) == c->value;
-}
-
-
/**
- * Generic filter-based scanning code for UCD property UnicodeSets.
+ * Append the <code>toPattern()</code> representation of a
+ * string to the given <code>StringBuffer</code>.
*/
-void UnicodeSet::applyFilter(UnicodeSet::Filter filter,
- void* context,
- UErrorCode &status) {
- // Walk through all Unicode characters, noting the start
- // and end of each range for which filter.contain(c) is
- // true. Add each range to a set.
- //
- // To improve performance, use the INCLUSIONS set, which
- // encodes information about character ranges that are known
- // to have identical properties. INCLUSIONS contains
- // only the first characters of such ranges.
- //
- // TODO Where possible, instead of scanning over code points,
- // use internal property data to initialize UnicodeSets for
- // those properties. Scanning code points is slow.
- if (U_FAILURE(status)) return;
-
- const UnicodeSet* inclusions = getInclusions(status);
- if (U_FAILURE(status)) {
- return;
+void UnicodeSet::_appendToPat(UnicodeString& buf, const UnicodeString& s, UBool
+escapeUnprintable) {
+ UChar32 cp;
+ for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) {
+ _appendToPat(buf, cp = s.char32At(i), escapeUnprintable);
}
+}
- clear();
-
- UChar32 startHasProperty = -1;
- int limitRange = inclusions->getRangeCount();
-
- for (int j=0; j<limitRange; ++j) {
- // get current range
- UChar32 start = inclusions->getRangeStart(j);
- UChar32 end = inclusions->getRangeEnd(j);
-
- // for all the code points in the range, process
- for (UChar32 ch = start; ch <= end; ++ch) {
- // only add to this UnicodeSet on inflection points --
- // where the hasProperty value changes to false
- if ((*filter)(ch, context)) {
- if (startHasProperty < 0) {
- startHasProperty = ch;
- }
- } else if (startHasProperty >= 0) {
- add(startHasProperty, ch-1);
- startHasProperty = -1;
- }
+/**
+ * Append the <code>toPattern()</code> representation of a
+ * character to the given <code>StringBuffer</code>.
+ */
+void UnicodeSet::_appendToPat(UnicodeString& buf, UChar32 c, UBool
+escapeUnprintable) {
+ if (escapeUnprintable && ICU_Utility::isUnprintable(c)) {
+ // Use hex escape notation (\uxxxx or \Uxxxxxxxx) for anything
+ // unprintable
+ if (ICU_Utility::escapeUnprintable(buf, c)) {
+ return;
}
}
- if (startHasProperty >= 0) {
- add((UChar32)startHasProperty, (UChar32)0x10FFFF);
- }
-}
-
-static UBool mungeCharName(char* dst, const char* src, int32_t dstCapacity) {
- /* Note: we use ' ' in compiler code page */
- int32_t j = 0;
- char ch;
- --dstCapacity; /* make room for term. zero */
- while ((ch = *src++) != 0) {
- if (ch == ' ' && (j==0 || (j>0 && dst[j-1]==' '))) {
- continue;
+ // Okay to let ':' pass through
+ switch (c) {
+ case SET_OPEN:
+ case SET_CLOSE:
+ case HYPHEN:
+ case COMPLEMENT:
+ case INTERSECTION:
+ case BACKSLASH:
+ case OPEN_BRACE:
+ case CLOSE_BRACE:
+ case COLON:
+ case SymbolTable::SYMBOL_REF:
+ buf.append(BACKSLASH);
+ break;
+ default:
+ // Escape whitespace
+ if (PatternProps::isWhiteSpace(c)) {
+ buf.append(BACKSLASH);
}
- if (j >= dstCapacity) return FALSE;
- dst[j++] = ch;
+ break;
}
- if (j > 0 && dst[j-1] == ' ') --j;
- dst[j] = 0;
- return TRUE;
+ buf.append(c);
}
-//----------------------------------------------------------------
-// Property set API
-//----------------------------------------------------------------
-
-#define FAIL(ec) {ec=U_ILLEGAL_ARGUMENT_ERROR; return *this;}
-
-// TODO: Remove the following special-case code when
-// these four C99-compatibility properties are implemented
-// as enums/names.
-static UBool c99Filter(UChar32 ch, void* context) {
- struct _C99_Map* m = (struct _C99_Map*) context;
- return m->func(ch);
-}
-
-UnicodeSet&
-UnicodeSet::applyIntPropertyValue(UProperty prop, int32_t value, UErrorCode& ec) {
- if (U_FAILURE(ec)) return *this;
-
- if (prop == UCHAR_GENERAL_CATEGORY_MASK) {
- applyFilter(generalCategoryMaskFilter, &value, ec);
-#if UCONFIG_NO_NORMALIZATION
- } else if(prop == UCHAR_HANGUL_SYLLABLE_TYPE) {
- /*
- * Special code for when normalization is off.
- * HST is still available because it is hardcoded in uprops.c, but
- * the inclusions set does not have the necessary code points
- * for normalization properties.
- * I am hardcoding HST in this case because it is the only property
- * that prevents genbrk from compiling char.txt when normalization is off.
- * This saves me from turning off break iteration or making more
- * complicated changes in genbrk.
- *
- * This code is not efficient. For efficiency turn on normalization.
- *
- * markus 20030505
- */
- UChar32 c;
-
- clear();
- for(c=0x1100; c<=0xd7a3; ++c) {
- if(c==0x1200) {
- c=0xac00;
- }
- if(value == u_getIntPropertyValue(c, UCHAR_HANGUL_SYLLABLE_TYPE)) {
- add(c);
+/**
+ * Append a string representation of this set to result. This will be
+ * a cleaned version of the string passed to applyPattern(), if there
+ * is one. Otherwise it will be generated.
+ */
+UnicodeString& UnicodeSet::_toPattern(UnicodeString& result,
+ UBool escapeUnprintable) const
+{
+ if (pat != NULL) {
+ int32_t i;
+ int32_t backslashCount = 0;
+ for (i=0; i<patLen; ) {
+ UChar32 c;
+ U16_NEXT(pat, i, patLen, c);
+ if (escapeUnprintable && ICU_Utility::isUnprintable(c)) {
+ // If the unprintable character is preceded by an odd
+ // number of backslashes, then it has been escaped.
+ // Before unescaping it, we delete the final
+ // backslash.
+ if ((backslashCount % 2) == 1) {
+ result.truncate(result.length() - 1);
+ }
+ ICU_Utility::escapeUnprintable(result, c);
+ backslashCount = 0;
+ } else {
+ result.append(c);
+ if (c == BACKSLASH) {
+ ++backslashCount;
+ } else {
+ backslashCount = 0;
+ }
}
}
-#endif
- } else {
- IntPropertyContext c = {prop, value};
- applyFilter(intPropertyFilter, &c, ec);
+ return result;
}
- return *this;
+
+ return _generatePattern(result, escapeUnprintable);
}
-UnicodeSet&
-UnicodeSet::applyPropertyAlias(const UnicodeString& prop,
- const UnicodeString& value,
- UErrorCode& ec) {
- if (U_FAILURE(ec)) return *this;
+/**
+ * Returns a string representation of this set. If the result of
+ * calling this function is passed to a UnicodeSet constructor, it
+ * will produce another set that is equal to this one.
+ */
+UnicodeString& UnicodeSet::toPattern(UnicodeString& result,
+ UBool escapeUnprintable) const
+{
+ result.truncate(0);
+ return _toPattern(result, escapeUnprintable);
+}
- UProperty p;
- int32_t v;
- CharString pname(prop);
- CharString vname(value);
- UBool mustNotBeEmpty = FALSE;
+/**
+ * Generate and append a string representation of this set to result.
+ * This does not use this.pat, the cleaned up copy of the string
+ * passed to applyPattern().
+ */
+UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
+ UBool escapeUnprintable) const
+{
+ result.append(SET_OPEN);
- if (value.length() > 0) {
- p = u_getPropertyEnum(pname);
- if (p == UCHAR_INVALID_CODE) FAIL(ec);
+// // Check against the predefined categories. We implicitly build
+// // up ALL category sets the first time toPattern() is called.
+// for (int8_t cat=0; cat<Unicode::GENERAL_TYPES_COUNT; ++cat) {
+// if (*this == getCategorySet(cat)) {
+// result.append(COLON);
+// result.append(CATEGORY_NAMES, cat*2, 2);
+// return result.append(CATEGORY_CLOSE);
+// }
+// }
- // Treat gc as gcm
- if (p == UCHAR_GENERAL_CATEGORY) {
- p = UCHAR_GENERAL_CATEGORY_MASK;
- }
+ int32_t count = getRangeCount();
- if ((p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) ||
- (p >= UCHAR_INT_START && p < UCHAR_INT_LIMIT) ||
- (p >= UCHAR_MASK_START && p < UCHAR_MASK_LIMIT)) {
- v = u_getPropertyValueEnum(p, vname);
- if (v == UCHAR_INVALID_CODE) {
- // Handle numeric CCC
- if (p == UCHAR_CANONICAL_COMBINING_CLASS) {
- char* end;
- double value = uprv_strtod(vname, &end);
- v = (int32_t) value;
- if (v != value || v < 0 || *end != 0) {
- // non-integral or negative value, or trailing junk
- FAIL(ec);
- }
- // If the resultant set is empty then the numeric value
- // was invalid.
- mustNotBeEmpty = TRUE;
- } else {
- FAIL(ec);
- }
- }
- }
+ // If the set contains at least 2 intervals and includes both
+ // MIN_VALUE and MAX_VALUE, then the inverse representation will
+ // be more economical.
+ if (count > 1 &&
+ getRangeStart(0) == MIN_VALUE &&
+ getRangeEnd(count-1) == MAX_VALUE) {
- else {
+ // Emit the inverse
+ result.append(COMPLEMENT);
- switch (p) {
- case UCHAR_NUMERIC_VALUE:
- {
- char* end;
- double value = uprv_strtod(vname, &end);
- if (*end != 0) {
- FAIL(ec);
- }
- applyFilter(numericValueFilter, &value, ec);
- return *this;
- }
- break;
- case UCHAR_NAME:
- case UCHAR_UNICODE_1_NAME:
- {
- // Must munge name, since u_charFromName() does not do
- // 'loose' matching.
- char buf[128]; // it suffices that this be > uprv_getMaxCharNameLength
- if (!mungeCharName(buf, vname, sizeof(buf))) FAIL(ec);
- UCharNameChoice choice = (p == UCHAR_NAME) ?
- U_EXTENDED_CHAR_NAME : U_UNICODE_10_CHAR_NAME;
- UChar32 ch = u_charFromName(choice, buf, &ec);
- if (U_SUCCESS(ec)) {
- clear();
- add(ch);
- return *this;
- } else {
- FAIL(ec);
- }
- }
- break;
- case UCHAR_AGE:
- {
- // Must munge name, since u_versionFromString() does not do
- // 'loose' matching.
- char buf[128];
- if (!mungeCharName(buf, vname, sizeof(buf))) FAIL(ec);
- UVersionInfo version;
- u_versionFromString(version, buf);
- applyFilter(versionFilter, &version, ec);
- return *this;
+ for (int32_t i = 1; i < count; ++i) {
+ UChar32 start = getRangeEnd(i-1)+1;
+ UChar32 end = getRangeStart(i)-1;
+ _appendToPat(result, start, escapeUnprintable);
+ if (start != end) {
+ if ((start+1) != end) {
+ result.append(HYPHEN);
}
- break;
- default:
- // p is a non-binary, non-enumerated property that we
- // don't support (yet).
- FAIL(ec);
+ _appendToPat(result, end, escapeUnprintable);
}
}
}
+ // Default; emit the ranges as pairs
else {
- // value is empty. Interpret as General Category, Script, or
- // Binary property.
- p = UCHAR_GENERAL_CATEGORY_MASK;
- v = u_getPropertyValueEnum(p, pname);
- if (v == UCHAR_INVALID_CODE) {
- p = UCHAR_SCRIPT;
- v = u_getPropertyValueEnum(p, pname);
- if (v == UCHAR_INVALID_CODE) {
- p = u_getPropertyEnum(pname);
- if (p >= UCHAR_BINARY_START && p < UCHAR_BINARY_LIMIT) {
- v = 1;
- } else if (0 == uprv_comparePropertyNames(ANY, pname)) {
- set(MIN_VALUE, MAX_VALUE);
- return *this;
- } else if (0 == uprv_comparePropertyNames(ASCII, pname)) {
- set(0, 0x7F);
- return *this;
- } else {
-
- // TODO: Remove the following special-case code when
- // these four C99-compatibility properties are implemented
- // as enums/names.
- for (int32_t i=0; i<_C99_COUNT; ++i) {
- int32_t c = uprv_comparePropertyNames(pname, _C99_DISPATCH[i].name);
- if (c == 0) {
- applyFilter(c99Filter, (void*) &_C99_DISPATCH[i], ec);
- return *this;
- } else if (c < 0) {
- // Further entries will not match; bail out
- break;
- }
- }
-
- FAIL(ec);
+ for (int32_t i = 0; i < count; ++i) {
+ UChar32 start = getRangeStart(i);
+ UChar32 end = getRangeEnd(i);
+ _appendToPat(result, start, escapeUnprintable);
+ if (start != end) {
+ if ((start+1) != end) {
+ result.append(HYPHEN);
}
+ _appendToPat(result, end, escapeUnprintable);
}
}
}
-
- applyIntPropertyValue(p, v, ec);
- if (U_SUCCESS(ec) && (mustNotBeEmpty && isEmpty())) {
- // mustNotBeEmpty is set to true if an empty set indicates
- // invalid input.
- ec = U_ILLEGAL_ARGUMENT_ERROR;
+ if (strings != nullptr) {
+ for (int32_t i = 0; i<strings->size(); ++i) {
+ result.append(OPEN_BRACE);
+ _appendToPat(result,
+ *(const UnicodeString*) strings->elementAt(i),
+ escapeUnprintable);
+ result.append(CLOSE_BRACE);
+ }
}
-
- return *this;
+ return result.append(SET_CLOSE);
}
-//----------------------------------------------------------------
-// Property set patterns
-//----------------------------------------------------------------
-
/**
- * Return true if the given position, in the given pattern, appears
- * to be the start of a property set pattern.
- */
-UBool UnicodeSet::resemblesPropertyPattern(const UnicodeString& pattern,
- int32_t pos) {
- // Patterns are at least 5 characters long
- if ((pos+5) > pattern.length()) {
- return FALSE;
+* Release existing cached pattern
+*/
+void UnicodeSet::releasePattern() {
+ if (pat) {
+ uprv_free(pat);
+ pat = NULL;
+ patLen = 0;
}
-
- // Look for an opening [:, [:^, \p, or \P
- return isPOSIXOpen(pattern, pos) || isPerlOpen(pattern, pos) || isNameOpen(pattern, pos);
}
/**
- * Parse the given property pattern at the given parse position.
- */
-UnicodeSet& UnicodeSet::applyPropertyPattern(const UnicodeString& pattern,
- ParsePosition& ppos,
- UErrorCode &ec) {
- int32_t pos = ppos.getIndex();
-
- UBool posix = FALSE; // true for [:pat:], false for \p{pat} \P{pat} \N{pat}
- UBool isName = FALSE; // true for \N{pat}, o/w false
- UBool invert = FALSE;
-
- if (U_FAILURE(ec)) return *this;
-
- // Minimum length is 5 characters, e.g. \p{L}
- if ((pos+5) > pattern.length()) {
- FAIL(ec);
- }
-
- // On entry, ppos should point to one of the following locations:
- // Look for an opening [:, [:^, \p, or \P
- if (isPOSIXOpen(pattern, pos)) {
- posix = TRUE;
- pos += 2;
- pos = ICU_Utility::skipWhitespace(pattern, pos);
- if (pos < pattern.length() && pattern.charAt(pos) == COMPLEMENT) {
- ++pos;
- invert = TRUE;
+* Set the new pattern to cache.
+*/
+void UnicodeSet::setPattern(const char16_t *newPat, int32_t newPatLen) {
+ releasePattern();
+ pat = (UChar *)uprv_malloc((newPatLen + 1) * sizeof(UChar));
+ if (pat) {
+ patLen = newPatLen;
+ u_memcpy(pat, newPat, patLen);
+ pat[patLen] = 0;
+ }
+ // else we don't care if malloc failed. This was just a nice cache.
+ // We can regenerate an equivalent pattern later when requested.
+}
+
+UnicodeFunctor *UnicodeSet::freeze() {
+ if(!isFrozen() && !isBogus()) {
+ compact();
+
+ // Optimize contains() and span() and similar functions.
+ if (hasStrings()) {
+ stringSpan = new UnicodeSetStringSpan(*this, *strings, UnicodeSetStringSpan::ALL);
+ if (stringSpan == nullptr) {
+ setToBogus();
+ return this;
+ } else if (!stringSpan->needsStringSpanUTF16()) {
+ // All strings are irrelevant for span() etc. because
+ // all of each string's code points are contained in this set.
+ // Do not check needsStringSpanUTF8() because UTF-8 has at most as
+ // many relevant strings as UTF-16.
+ // (Thus needsStringSpanUTF8() implies needsStringSpanUTF16().)
+ delete stringSpan;
+ stringSpan = NULL;
+ }
}
- } else if (isPerlOpen(pattern, pos) || isNameOpen(pattern, pos)) {
- UChar c = pattern.charAt(pos+1);
- invert = (c == UPPER_P);
- isName = (c == UPPER_N);
- pos += 2;
- pos = ICU_Utility::skipWhitespace(pattern, pos);
- if (pos == pattern.length() || pattern.charAt(pos++) != OPEN_BRACE) {
- // Syntax error; "\p" or "\P" not followed by "{"
- FAIL(ec);
+ if (stringSpan == NULL) {
+ // No span-relevant strings: Optimize for code point spans.
+ bmpSet=new BMPSet(list, len);
+ if (bmpSet == NULL) { // Check for memory allocation error.
+ setToBogus();
+ }
}
- } else {
- // Open delimiter not seen
- FAIL(ec);
}
+ return this;
+}
- // Look for the matching close delimiter, either :] or }
- int32_t close = pattern.indexOf(posix ? POSIX_CLOSE : PERL_CLOSE, pos);
- if (close < 0) {
- // Syntax error; close delimiter missing
- FAIL(ec);
+int32_t UnicodeSet::span(const UChar *s, int32_t length, USetSpanCondition spanCondition) const {
+ if(length>0 && bmpSet!=NULL) {
+ return (int32_t)(bmpSet->span(s, s+length, spanCondition)-s);
}
-
- // Look for an '=' sign. If this is present, we will parse a
- // medium \p{gc=Cf} or long \p{GeneralCategory=Format}
- // pattern.
- int32_t equals = pattern.indexOf(EQUALS, pos);
- UnicodeString propName, valueName;
- if (equals >= 0 && equals < close && !isName) {
- // Equals seen; parse medium/long pattern
- pattern.extractBetween(pos, equals, propName);
- pattern.extractBetween(equals+1, close, valueName);
+ if(length<0) {
+ length=u_strlen(s);
}
-
- else {
- // Handle case where no '=' is seen, and \N{}
- pattern.extractBetween(pos, close, propName);
-
- // Handle \N{name}
- if (isName) {
- // This is a little inefficient since it means we have to
- // parse NAME_PROP back to UCHAR_NAME even though we already
- // know it's UCHAR_NAME. If we refactor the API to
- // support args of (UProperty, char*) then we can remove
- // NAME_PROP and make this a little more efficient.
- valueName = propName;
- propName = NAME_PROP;
- }
+ if(length==0) {
+ return 0;
}
-
- applyPropertyAlias(propName, valueName, ec);
-
- if (U_SUCCESS(ec)) {
- if (invert) {
- complement();
+ if(stringSpan!=NULL) {
+ return stringSpan->span(s, length, spanCondition);
+ } else if(hasStrings()) {
+ uint32_t which= spanCondition==USET_SPAN_NOT_CONTAINED ?
+ UnicodeSetStringSpan::FWD_UTF16_NOT_CONTAINED :
+ UnicodeSetStringSpan::FWD_UTF16_CONTAINED;
+ UnicodeSetStringSpan strSpan(*this, *strings, which);
+ if(strSpan.needsStringSpanUTF16()) {
+ return strSpan.span(s, length, spanCondition);
}
-
- // Move to the limit position after the close delimiter if the
- // parse succeeded.
- ppos.setIndex(close + (posix ? 2 : 1));
}
- return *this;
-}
-
-//----------------------------------------------------------------
-// Inclusions list
-//----------------------------------------------------------------
+ if(spanCondition!=USET_SPAN_NOT_CONTAINED) {
+ spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values.
+ }
-const UnicodeSet* UnicodeSet::getInclusions(UErrorCode &status) {
- umtx_lock(NULL);
- UBool f = (INCLUSIONS == NULL);
- umtx_unlock(NULL);
- if (f) {
- UnicodeSet* incl = new UnicodeSet();
- if (incl != NULL) {
- uprv_getInclusions((USet*)incl, &status);
- if (U_SUCCESS(status)) {
- umtx_lock(NULL);
- if (INCLUSIONS == NULL) {
- INCLUSIONS = incl;
- incl = NULL;
- }
- umtx_unlock(NULL);
- }
- delete incl;
- } else {
- status = U_MEMORY_ALLOCATION_ERROR;
+ UChar32 c;
+ int32_t start=0, prev=0;
+ do {
+ U16_NEXT(s, start, length, c);
+ if(spanCondition!=contains(c)) {
+ break;
}
- }
- return INCLUSIONS;
+ } while((prev=start)<length);
+ return prev;
}
-/**
- * Cleanup function for UnicodeSet
- */
-U_CFUNC UBool uset_cleanup(void) {
- if (INCLUSIONS != NULL) {
- delete INCLUSIONS;
- INCLUSIONS = NULL;
+int32_t UnicodeSet::spanBack(const UChar *s, int32_t length, USetSpanCondition spanCondition) const {
+ if(length>0 && bmpSet!=NULL) {
+ return (int32_t)(bmpSet->spanBack(s, s+length, spanCondition)-s);
}
-
- if (CASE_EQUIV_HASH != NULL) {
- delete CASE_EQUIV_HASH;
- CASE_EQUIV_HASH = NULL;
+ if(length<0) {
+ length=u_strlen(s);
}
-
- if (CASE_EQUIV_CBA != NULL) {
- ucmp8_close(CASE_EQUIV_CBA);
- CASE_EQUIV_CBA = NULL;
+ if(length==0) {
+ return 0;
}
-
- return TRUE;
-}
-
-//----------------------------------------------------------------
-// Case folding API
-//----------------------------------------------------------------
-
-UnicodeSet& UnicodeSet::closeOver(int32_t attribute) {
- if ((attribute & USET_CASE) != 0) {
- UnicodeSet foldSet;
- UnicodeString str;
- int32_t n = getRangeCount();
- for (int32_t i=0; i<n; ++i) {
- UChar32 start = getRangeStart(i);
- UChar32 end = getRangeEnd(i);
- for (UChar32 cp=start; cp<=end; ++cp) {
- str.truncate(0);
- str.append(u_foldCase(cp, U_FOLD_CASE_DEFAULT));
- foldSet.caseCloseOne(str);
- }
- }
- if (strings != NULL && strings->size() > 0) {
- for (int32_t j=0; j<strings->size(); ++j) {
- str = * (const UnicodeString*) strings->elementAt(j);
- foldSet.caseCloseOne(str.foldCase());
- }
+ if(stringSpan!=NULL) {
+ return stringSpan->spanBack(s, length, spanCondition);
+ } else if(hasStrings()) {
+ uint32_t which= spanCondition==USET_SPAN_NOT_CONTAINED ?
+ UnicodeSetStringSpan::BACK_UTF16_NOT_CONTAINED :
+ UnicodeSetStringSpan::BACK_UTF16_CONTAINED;
+ UnicodeSetStringSpan strSpan(*this, *strings, which);
+ if(strSpan.needsStringSpanUTF16()) {
+ return strSpan.spanBack(s, length, spanCondition);
}
- *this = foldSet;
}
- return *this;
-}
-
-//----------------------------------------------------------------
-// Case folding implementation
-//----------------------------------------------------------------
-
-/**
- * Data structure representing a case-fold equivalency class. It is a
- * SET containing 0 or more code units, and 0 or more strings of
- * length 2 code units or longer.
- *
- * This class is implemented as a 8-UChar buffer with a few
- * convenience methods on it. The format of the buffer:
- * - All single code units in this set, followed by a terminating
- * zero. If none, then just a terminating zero.
- * - Zero or more 0-terminated strings, each of length >= 2
- * code units.
- * - A single terminating (UChar)0.
- *
- * Usage:
- *
- * const CaseEquivClass& c = ...;
- * const UChar* p;
- * for (c.getStrings(p); *p; c.nextString(p)) {
- * foo(p);
- * }
- */
-class CaseEquivClass {
-public:
- UChar data[8];
- /**
- * Return the string of single code units. May be "". Will never
- * be NULL.
- */
- const UChar* getSingles() const {
- return data;
+ if(spanCondition!=USET_SPAN_NOT_CONTAINED) {
+ spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values.
}
- /**
- * Return the first multi-code-unit string. May be "" if there
- * are none. Will never be NULL.
- * @param p pointer to be set to point to the first string.
- */
- void getStrings(const UChar*& p) const {
- p = data;
- nextString(p);
- }
+ UChar32 c;
+ int32_t prev=length;
+ do {
+ U16_PREV(s, 0, length, c);
+ if(spanCondition!=contains(c)) {
+ break;
+ }
+ } while((prev=length)>0);
+ return prev;
+}
- /**
- * Advance a pointer from one multi-code-unit string to the next.
- * May advance 'p' to point to "" if there are no more.
- * Do NOT call if *p == 0.
- * @param p pointer to be advanced to point to the next string.
- */
- static void nextString(const UChar*& p) {
- while (*p++) {}
+int32_t UnicodeSet::spanUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const {
+ if(length>0 && bmpSet!=NULL) {
+ const uint8_t *s0=(const uint8_t *)s;
+ return (int32_t)(bmpSet->spanUTF8(s0, length, spanCondition)-s0);
}
-};
-
-/**
- * IMPORTANT: The following two static data arrays represent the
- * information used to do case closure. The first array is an array
- * of pairs. That is, for each even index e, entries [e] and [e+1]
- * form a pair of case equivalent code units. The entry at [e] is the
- * folded one, that is, the one for which u_foldCase(x)==x.
- *
- * The second static array is an array of CaseEquivClass objects.
- * Since these objects are just adorned UChar[] arrays, they can be
- * initialized in place in the array, and all of them can live in a
- * single piece of static memory, with no heap allocation.
- */
-
-// MACHINE-GENERATED: Do not edit (see com.ibm.icu.dev.tools.translit.UnicodeSetCloseOver)
-static const UChar CASE_PAIRS[] = {
- 0x0061,0x0041,0x0062,0x0042,0x0063,0x0043,0x0064,0x0044,0x0065,0x0045,
- 0x0066,0x0046,0x0067,0x0047,0x0068,0x0048,0x0069,0x0049,0x006A,0x004A,
- 0x006C,0x004C,0x006D,0x004D,0x006E,0x004E,0x006F,0x004F,0x0070,0x0050,
- 0x0071,0x0051,0x0072,0x0052,0x0074,0x0054,0x0075,0x0055,0x0076,0x0056,
- 0x0077,0x0057,0x0078,0x0058,0x0079,0x0059,0x007A,0x005A,0x00E0,0x00C0,
- 0x00E1,0x00C1,0x00E2,0x00C2,0x00E3,0x00C3,0x00E4,0x00C4,0x00E6,0x00C6,
- 0x00E7,0x00C7,0x00E8,0x00C8,0x00E9,0x00C9,0x00EA,0x00CA,0x00EB,0x00CB,
- 0x00EC,0x00CC,0x00ED,0x00CD,0x00EE,0x00CE,0x00EF,0x00CF,0x00F0,0x00D0,
- 0x00F1,0x00D1,0x00F2,0x00D2,0x00F3,0x00D3,0x00F4,0x00D4,0x00F5,0x00D5,
- 0x00F6,0x00D6,0x00F8,0x00D8,0x00F9,0x00D9,0x00FA,0x00DA,0x00FB,0x00DB,
- 0x00FC,0x00DC,0x00FD,0x00DD,0x00FE,0x00DE,0x00FF,0x0178,0x0101,0x0100,
- 0x0103,0x0102,0x0105,0x0104,0x0107,0x0106,0x0109,0x0108,0x010B,0x010A,
- 0x010D,0x010C,0x010F,0x010E,0x0111,0x0110,0x0113,0x0112,0x0115,0x0114,
- 0x0117,0x0116,0x0119,0x0118,0x011B,0x011A,0x011D,0x011C,0x011F,0x011E,
- 0x0121,0x0120,0x0123,0x0122,0x0125,0x0124,0x0127,0x0126,0x0129,0x0128,
- 0x012B,0x012A,0x012D,0x012C,0x012F,0x012E,0x0133,0x0132,0x0135,0x0134,
- 0x0137,0x0136,0x013A,0x0139,0x013C,0x013B,0x013E,0x013D,0x0140,0x013F,
- 0x0142,0x0141,0x0144,0x0143,0x0146,0x0145,0x0148,0x0147,0x014B,0x014A,
- 0x014D,0x014C,0x014F,0x014E,0x0151,0x0150,0x0153,0x0152,0x0155,0x0154,
- 0x0157,0x0156,0x0159,0x0158,0x015B,0x015A,0x015D,0x015C,0x015F,0x015E,
- 0x0161,0x0160,0x0163,0x0162,0x0165,0x0164,0x0167,0x0166,0x0169,0x0168,
- 0x016B,0x016A,0x016D,0x016C,0x016F,0x016E,0x0171,0x0170,0x0173,0x0172,
- 0x0175,0x0174,0x0177,0x0176,0x017A,0x0179,0x017C,0x017B,0x017E,0x017D,
- 0x0183,0x0182,0x0185,0x0184,0x0188,0x0187,0x018C,0x018B,0x0192,0x0191,
- 0x0195,0x01F6,0x0199,0x0198,0x019E,0x0220,0x01A1,0x01A0,0x01A3,0x01A2,
- 0x01A5,0x01A4,0x01A8,0x01A7,0x01AD,0x01AC,0x01B0,0x01AF,0x01B4,0x01B3,
- 0x01B6,0x01B5,0x01B9,0x01B8,0x01BD,0x01BC,0x01BF,0x01F7,0x01CE,0x01CD,
- 0x01D0,0x01CF,0x01D2,0x01D1,0x01D4,0x01D3,0x01D6,0x01D5,0x01D8,0x01D7,
- 0x01DA,0x01D9,0x01DC,0x01DB,0x01DD,0x018E,0x01DF,0x01DE,0x01E1,0x01E0,
- 0x01E3,0x01E2,0x01E5,0x01E4,0x01E7,0x01E6,0x01E9,0x01E8,0x01EB,0x01EA,
- 0x01ED,0x01EC,0x01EF,0x01EE,0x01F5,0x01F4,0x01F9,0x01F8,0x01FB,0x01FA,
- 0x01FD,0x01FC,0x01FF,0x01FE,0x0201,0x0200,0x0203,0x0202,0x0205,0x0204,
- 0x0207,0x0206,0x0209,0x0208,0x020B,0x020A,0x020D,0x020C,0x020F,0x020E,
- 0x0211,0x0210,0x0213,0x0212,0x0215,0x0214,0x0217,0x0216,0x0219,0x0218,
- 0x021B,0x021A,0x021D,0x021C,0x021F,0x021E,0x0223,0x0222,0x0225,0x0224,
- 0x0227,0x0226,0x0229,0x0228,0x022B,0x022A,0x022D,0x022C,0x022F,0x022E,
- 0x0231,0x0230,0x0233,0x0232,0x0253,0x0181,0x0254,0x0186,0x0256,0x0189,
- 0x0257,0x018A,0x0259,0x018F,0x025B,0x0190,0x0260,0x0193,0x0263,0x0194,
- 0x0268,0x0197,0x0269,0x0196,0x026F,0x019C,0x0272,0x019D,0x0275,0x019F,
- 0x0280,0x01A6,0x0283,0x01A9,0x0288,0x01AE,0x028A,0x01B1,0x028B,0x01B2,
- 0x0292,0x01B7,0x03AC,0x0386,0x03AD,0x0388,0x03AE,0x0389,0x03AF,0x038A,
- 0x03B1,0x0391,0x03B3,0x0393,0x03B4,0x0394,0x03B6,0x0396,0x03B7,0x0397,
- 0x03BB,0x039B,0x03BD,0x039D,0x03BE,0x039E,0x03BF,0x039F,0x03C4,0x03A4,
- 0x03C5,0x03A5,0x03C7,0x03A7,0x03C8,0x03A8,0x03CA,0x03AA,0x03CB,0x03AB,
- 0x03CC,0x038C,0x03CD,0x038E,0x03CE,0x038F,0x03D9,0x03D8,0x03DB,0x03DA,
- 0x03DD,0x03DC,0x03DF,0x03DE,0x03E1,0x03E0,0x03E3,0x03E2,0x03E5,0x03E4,
- 0x03E7,0x03E6,0x03E9,0x03E8,0x03EB,0x03EA,0x03ED,0x03EC,0x03EF,0x03EE,
- 0x0430,0x0410,0x0431,0x0411,0x0432,0x0412,0x0433,0x0413,0x0434,0x0414,
- 0x0435,0x0415,0x0436,0x0416,0x0437,0x0417,0x0438,0x0418,0x0439,0x0419,
- 0x043A,0x041A,0x043B,0x041B,0x043C,0x041C,0x043D,0x041D,0x043E,0x041E,
- 0x043F,0x041F,0x0440,0x0420,0x0441,0x0421,0x0442,0x0422,0x0443,0x0423,
- 0x0444,0x0424,0x0445,0x0425,0x0446,0x0426,0x0447,0x0427,0x0448,0x0428,
- 0x0449,0x0429,0x044A,0x042A,0x044B,0x042B,0x044C,0x042C,0x044D,0x042D,
- 0x044E,0x042E,0x044F,0x042F,0x0450,0x0400,0x0451,0x0401,0x0452,0x0402,
- 0x0453,0x0403,0x0454,0x0404,0x0455,0x0405,0x0456,0x0406,0x0457,0x0407,
- 0x0458,0x0408,0x0459,0x0409,0x045A,0x040A,0x045B,0x040B,0x045C,0x040C,
- 0x045D,0x040D,0x045E,0x040E,0x045F,0x040F,0x0461,0x0460,0x0463,0x0462,
- 0x0465,0x0464,0x0467,0x0466,0x0469,0x0468,0x046B,0x046A,0x046D,0x046C,
- 0x046F,0x046E,0x0471,0x0470,0x0473,0x0472,0x0475,0x0474,0x0477,0x0476,
- 0x0479,0x0478,0x047B,0x047A,0x047D,0x047C,0x047F,0x047E,0x0481,0x0480,
- 0x048B,0x048A,0x048D,0x048C,0x048F,0x048E,0x0491,0x0490,0x0493,0x0492,
- 0x0495,0x0494,0x0497,0x0496,0x0499,0x0498,0x049B,0x049A,0x049D,0x049C,
- 0x049F,0x049E,0x04A1,0x04A0,0x04A3,0x04A2,0x04A5,0x04A4,0x04A7,0x04A6,
- 0x04A9,0x04A8,0x04AB,0x04AA,0x04AD,0x04AC,0x04AF,0x04AE,0x04B1,0x04B0,
- 0x04B3,0x04B2,0x04B5,0x04B4,0x04B7,0x04B6,0x04B9,0x04B8,0x04BB,0x04BA,
- 0x04BD,0x04BC,0x04BF,0x04BE,0x04C2,0x04C1,0x04C4,0x04C3,0x04C6,0x04C5,
- 0x04C8,0x04C7,0x04CA,0x04C9,0x04CC,0x04CB,0x04CE,0x04CD,0x04D1,0x04D0,
- 0x04D3,0x04D2,0x04D5,0x04D4,0x04D7,0x04D6,0x04D9,0x04D8,0x04DB,0x04DA,
- 0x04DD,0x04DC,0x04DF,0x04DE,0x04E1,0x04E0,0x04E3,0x04E2,0x04E5,0x04E4,
- 0x04E7,0x04E6,0x04E9,0x04E8,0x04EB,0x04EA,0x04ED,0x04EC,0x04EF,0x04EE,
- 0x04F1,0x04F0,0x04F3,0x04F2,0x04F5,0x04F4,0x04F9,0x04F8,0x0501,0x0500,
- 0x0503,0x0502,0x0505,0x0504,0x0507,0x0506,0x0509,0x0508,0x050B,0x050A,
- 0x050D,0x050C,0x050F,0x050E,0x0561,0x0531,0x0562,0x0532,0x0563,0x0533,
- 0x0564,0x0534,0x0565,0x0535,0x0566,0x0536,0x0567,0x0537,0x0568,0x0538,
- 0x0569,0x0539,0x056A,0x053A,0x056B,0x053B,0x056C,0x053C,0x056D,0x053D,
- 0x056E,0x053E,0x056F,0x053F,0x0570,0x0540,0x0571,0x0541,0x0572,0x0542,
- 0x0573,0x0543,0x0574,0x0544,0x0575,0x0545,0x0576,0x0546,0x0577,0x0547,
- 0x0578,0x0548,0x0579,0x0549,0x057A,0x054A,0x057B,0x054B,0x057C,0x054C,
- 0x057D,0x054D,0x057E,0x054E,0x057F,0x054F,0x0580,0x0550,0x0581,0x0551,
- 0x0582,0x0552,0x0583,0x0553,0x0584,0x0554,0x0585,0x0555,0x0586,0x0556,
- 0x1E01,0x1E00,0x1E03,0x1E02,0x1E05,0x1E04,0x1E07,0x1E06,0x1E09,0x1E08,
- 0x1E0B,0x1E0A,0x1E0D,0x1E0C,0x1E0F,0x1E0E,0x1E11,0x1E10,0x1E13,0x1E12,
- 0x1E15,0x1E14,0x1E17,0x1E16,0x1E19,0x1E18,0x1E1B,0x1E1A,0x1E1D,0x1E1C,
- 0x1E1F,0x1E1E,0x1E21,0x1E20,0x1E23,0x1E22,0x1E25,0x1E24,0x1E27,0x1E26,
- 0x1E29,0x1E28,0x1E2B,0x1E2A,0x1E2D,0x1E2C,0x1E2F,0x1E2E,0x1E31,0x1E30,
- 0x1E33,0x1E32,0x1E35,0x1E34,0x1E37,0x1E36,0x1E39,0x1E38,0x1E3B,0x1E3A,
- 0x1E3D,0x1E3C,0x1E3F,0x1E3E,0x1E41,0x1E40,0x1E43,0x1E42,0x1E45,0x1E44,
- 0x1E47,0x1E46,0x1E49,0x1E48,0x1E4B,0x1E4A,0x1E4D,0x1E4C,0x1E4F,0x1E4E,
- 0x1E51,0x1E50,0x1E53,0x1E52,0x1E55,0x1E54,0x1E57,0x1E56,0x1E59,0x1E58,
- 0x1E5B,0x1E5A,0x1E5D,0x1E5C,0x1E5F,0x1E5E,0x1E63,0x1E62,0x1E65,0x1E64,
- 0x1E67,0x1E66,0x1E69,0x1E68,0x1E6B,0x1E6A,0x1E6D,0x1E6C,0x1E6F,0x1E6E,
- 0x1E71,0x1E70,0x1E73,0x1E72,0x1E75,0x1E74,0x1E77,0x1E76,0x1E79,0x1E78,
- 0x1E7B,0x1E7A,0x1E7D,0x1E7C,0x1E7F,0x1E7E,0x1E81,0x1E80,0x1E83,0x1E82,
- 0x1E85,0x1E84,0x1E87,0x1E86,0x1E89,0x1E88,0x1E8B,0x1E8A,0x1E8D,0x1E8C,
- 0x1E8F,0x1E8E,0x1E91,0x1E90,0x1E93,0x1E92,0x1E95,0x1E94,0x1EA1,0x1EA0,
- 0x1EA3,0x1EA2,0x1EA5,0x1EA4,0x1EA7,0x1EA6,0x1EA9,0x1EA8,0x1EAB,0x1EAA,
- 0x1EAD,0x1EAC,0x1EAF,0x1EAE,0x1EB1,0x1EB0,0x1EB3,0x1EB2,0x1EB5,0x1EB4,
- 0x1EB7,0x1EB6,0x1EB9,0x1EB8,0x1EBB,0x1EBA,0x1EBD,0x1EBC,0x1EBF,0x1EBE,
- 0x1EC1,0x1EC0,0x1EC3,0x1EC2,0x1EC5,0x1EC4,0x1EC7,0x1EC6,0x1EC9,0x1EC8,
- 0x1ECB,0x1ECA,0x1ECD,0x1ECC,0x1ECF,0x1ECE,0x1ED1,0x1ED0,0x1ED3,0x1ED2,
- 0x1ED5,0x1ED4,0x1ED7,0x1ED6,0x1ED9,0x1ED8,0x1EDB,0x1EDA,0x1EDD,0x1EDC,
- 0x1EDF,0x1EDE,0x1EE1,0x1EE0,0x1EE3,0x1EE2,0x1EE5,0x1EE4,0x1EE7,0x1EE6,
- 0x1EE9,0x1EE8,0x1EEB,0x1EEA,0x1EED,0x1EEC,0x1EEF,0x1EEE,0x1EF1,0x1EF0,
- 0x1EF3,0x1EF2,0x1EF5,0x1EF4,0x1EF7,0x1EF6,0x1EF9,0x1EF8,0x1F00,0x1F08,
- 0x1F01,0x1F09,0x1F02,0x1F0A,0x1F03,0x1F0B,0x1F04,0x1F0C,0x1F05,0x1F0D,
- 0x1F06,0x1F0E,0x1F07,0x1F0F,0x1F10,0x1F18,0x1F11,0x1F19,0x1F12,0x1F1A,
- 0x1F13,0x1F1B,0x1F14,0x1F1C,0x1F15,0x1F1D,0x1F20,0x1F28,0x1F21,0x1F29,
- 0x1F22,0x1F2A,0x1F23,0x1F2B,0x1F24,0x1F2C,0x1F25,0x1F2D,0x1F26,0x1F2E,
- 0x1F27,0x1F2F,0x1F30,0x1F38,0x1F31,0x1F39,0x1F32,0x1F3A,0x1F33,0x1F3B,
- 0x1F34,0x1F3C,0x1F35,0x1F3D,0x1F36,0x1F3E,0x1F37,0x1F3F,0x1F40,0x1F48,
- 0x1F41,0x1F49,0x1F42,0x1F4A,0x1F43,0x1F4B,0x1F44,0x1F4C,0x1F45,0x1F4D,
- 0x1F51,0x1F59,0x1F53,0x1F5B,0x1F55,0x1F5D,0x1F57,0x1F5F,0x1F60,0x1F68,
- 0x1F61,0x1F69,0x1F62,0x1F6A,0x1F63,0x1F6B,0x1F64,0x1F6C,0x1F65,0x1F6D,
- 0x1F66,0x1F6E,0x1F67,0x1F6F,0x1F70,0x1FBA,0x1F71,0x1FBB,0x1F72,0x1FC8,
- 0x1F73,0x1FC9,0x1F74,0x1FCA,0x1F75,0x1FCB,0x1F76,0x1FDA,0x1F77,0x1FDB,
- 0x1F78,0x1FF8,0x1F79,0x1FF9,0x1F7A,0x1FEA,0x1F7B,0x1FEB,0x1F7C,0x1FFA,
- 0x1F7D,0x1FFB,0x1FB0,0x1FB8,0x1FB1,0x1FB9,0x1FD0,0x1FD8,0x1FD1,0x1FD9,
- 0x1FE0,0x1FE8,0x1FE1,0x1FE9,0x1FE5,0x1FEC,0x2170,0x2160,0x2171,0x2161,
- 0x2172,0x2162,0x2173,0x2163,0x2174,0x2164,0x2175,0x2165,0x2176,0x2166,
- 0x2177,0x2167,0x2178,0x2168,0x2179,0x2169,0x217A,0x216A,0x217B,0x216B,
- 0x217C,0x216C,0x217D,0x216D,0x217E,0x216E,0x217F,0x216F,0x24D0,0x24B6,
- 0x24D1,0x24B7,0x24D2,0x24B8,0x24D3,0x24B9,0x24D4,0x24BA,0x24D5,0x24BB,
- 0x24D6,0x24BC,0x24D7,0x24BD,0x24D8,0x24BE,0x24D9,0x24BF,0x24DA,0x24C0,
- 0x24DB,0x24C1,0x24DC,0x24C2,0x24DD,0x24C3,0x24DE,0x24C4,0x24DF,0x24C5,
- 0x24E0,0x24C6,0x24E1,0x24C7,0x24E2,0x24C8,0x24E3,0x24C9,0x24E4,0x24CA,
- 0x24E5,0x24CB,0x24E6,0x24CC,0x24E7,0x24CD,0x24E8,0x24CE,0x24E9,0x24CF,
- 0xFF41,0xFF21,0xFF42,0xFF22,0xFF43,0xFF23,0xFF44,0xFF24,0xFF45,0xFF25,
- 0xFF46,0xFF26,0xFF47,0xFF27,0xFF48,0xFF28,0xFF49,0xFF29,0xFF4A,0xFF2A,
- 0xFF4B,0xFF2B,0xFF4C,0xFF2C,0xFF4D,0xFF2D,0xFF4E,0xFF2E,0xFF4F,0xFF2F,
- 0xFF50,0xFF30,0xFF51,0xFF31,0xFF52,0xFF32,0xFF53,0xFF33,0xFF54,0xFF34,
- 0xFF55,0xFF35,0xFF56,0xFF36,0xFF57,0xFF37,0xFF58,0xFF38,0xFF59,0xFF39,
- 0xFF5A,0xFF3A,
-};
-
-// MACHINE-GENERATED: Do not edit (see com.ibm.icu.dev.tools.translit.UnicodeSetCloseOver)
-static const CaseEquivClass CASE_NONPAIRS[] = {
- {{0x1E9A,0, 0x0061,0x02BE,0, 0}},
- {{0xFB00,0, 0x0066,0x0066,0, 0}},
- {{0xFB03,0, 0x0066,0x0066,0x0069,0, 0}},
- {{0xFB04,0, 0x0066,0x0066,0x006C,0, 0}},
- {{0xFB01,0, 0x0066,0x0069,0, 0}},
- {{0xFB02,0, 0x0066,0x006C,0, 0}},
- {{0x1E96,0, 0x0068,0x0331,0, 0}},
- {{0x0130,0, 0x0069,0x0307,0, 0}},
- {{0x01F0,0, 0x006A,0x030C,0, 0}},
- {{0x004B,0x006B,0x212A,0, 0}},
- {{0x0053,0x0073,0x017F,0, 0}},
- {{0x00DF,0, 0x0073,0x0073,0, 0}},
- {{0xFB05,0xFB06,0, 0x0073,0x0074,0, 0}},
- {{0x1E97,0, 0x0074,0x0308,0, 0}},
- {{0x1E98,0, 0x0077,0x030A,0, 0}},
- {{0x1E99,0, 0x0079,0x030A,0, 0}},
- {{0x00C5,0x00E5,0x212B,0, 0}},
- {{0x01C4,0x01C5,0x01C6,0, 0}},
- {{0x01C7,0x01C8,0x01C9,0, 0}},
- {{0x01CA,0x01CB,0x01CC,0, 0}},
- {{0x01F1,0x01F2,0x01F3,0, 0}},
- {{0x0149,0, 0x02BC,0x006E,0, 0}},
- {{0x1FB4,0, 0x03AC,0x03B9,0, 0}},
- {{0x1FC4,0, 0x03AE,0x03B9,0, 0}},
- {{0x1FB6,0, 0x03B1,0x0342,0, 0}},
- {{0x1FB7,0, 0x03B1,0x0342,0x03B9,0, 0}},
- {{0x1FB3,0x1FBC,0, 0x03B1,0x03B9,0, 0}},
- {{0x0392,0x03B2,0x03D0,0, 0}},
- {{0x0395,0x03B5,0x03F5,0, 0}},
- {{0x1FC6,0, 0x03B7,0x0342,0, 0}},
- {{0x1FC7,0, 0x03B7,0x0342,0x03B9,0, 0}},
- {{0x1FC3,0x1FCC,0, 0x03B7,0x03B9,0, 0}},
- {{0x0398,0x03B8,0x03D1,0x03F4,0, 0}},
- {{0x0345,0x0399,0x03B9,0x1FBE,0, 0}},
- {{0x1FD2,0, 0x03B9,0x0308,0x0300,0, 0}},
- {{0x0390,0x1FD3,0, 0x03B9,0x0308,0x0301,0, 0}},
- {{0x1FD7,0, 0x03B9,0x0308,0x0342,0, 0}},
- {{0x1FD6,0, 0x03B9,0x0342,0, 0}},
- {{0x039A,0x03BA,0x03F0,0, 0}},
- {{0x00B5,0x039C,0x03BC,0, 0}},
- {{0x03A0,0x03C0,0x03D6,0, 0}},
- {{0x03A1,0x03C1,0x03F1,0, 0}},
- {{0x1FE4,0, 0x03C1,0x0313,0, 0}},
- {{0x03A3,0x03C2,0x03C3,0x03F2,0, 0}},
- {{0x1FE2,0, 0x03C5,0x0308,0x0300,0, 0}},
- {{0x03B0,0x1FE3,0, 0x03C5,0x0308,0x0301,0, 0}},
- {{0x1FE7,0, 0x03C5,0x0308,0x0342,0, 0}},
- {{0x1F50,0, 0x03C5,0x0313,0, 0}},
- {{0x1F52,0, 0x03C5,0x0313,0x0300,0, 0}},
- {{0x1F54,0, 0x03C5,0x0313,0x0301,0, 0}},
- {{0x1F56,0, 0x03C5,0x0313,0x0342,0, 0}},
- {{0x1FE6,0, 0x03C5,0x0342,0, 0}},
- {{0x03A6,0x03C6,0x03D5,0, 0}},
- {{0x03A9,0x03C9,0x2126,0, 0}},
- {{0x1FF6,0, 0x03C9,0x0342,0, 0}},
- {{0x1FF7,0, 0x03C9,0x0342,0x03B9,0, 0}},
- {{0x1FF3,0x1FFC,0, 0x03C9,0x03B9,0, 0}},
- {{0x1FF4,0, 0x03CE,0x03B9,0, 0}},
- {{0x0587,0, 0x0565,0x0582,0, 0}},
- {{0xFB14,0, 0x0574,0x0565,0, 0}},
- {{0xFB15,0, 0x0574,0x056B,0, 0}},
- {{0xFB17,0, 0x0574,0x056D,0, 0}},
- {{0xFB13,0, 0x0574,0x0576,0, 0}},
- {{0xFB16,0, 0x057E,0x0576,0, 0}},
- {{0x1E60,0x1E61,0x1E9B,0, 0}},
- {{0x1F80,0x1F88,0, 0x1F00,0x03B9,0, 0}},
- {{0x1F81,0x1F89,0, 0x1F01,0x03B9,0, 0}},
- {{0x1F82,0x1F8A,0, 0x1F02,0x03B9,0, 0}},
- {{0x1F83,0x1F8B,0, 0x1F03,0x03B9,0, 0}},
- {{0x1F84,0x1F8C,0, 0x1F04,0x03B9,0, 0}},
- {{0x1F85,0x1F8D,0, 0x1F05,0x03B9,0, 0}},
- {{0x1F86,0x1F8E,0, 0x1F06,0x03B9,0, 0}},
- {{0x1F87,0x1F8F,0, 0x1F07,0x03B9,0, 0}},
- {{0x1F90,0x1F98,0, 0x1F20,0x03B9,0, 0}},
- {{0x1F91,0x1F99,0, 0x1F21,0x03B9,0, 0}},
- {{0x1F92,0x1F9A,0, 0x1F22,0x03B9,0, 0}},
- {{0x1F93,0x1F9B,0, 0x1F23,0x03B9,0, 0}},
- {{0x1F94,0x1F9C,0, 0x1F24,0x03B9,0, 0}},
- {{0x1F95,0x1F9D,0, 0x1F25,0x03B9,0, 0}},
- {{0x1F96,0x1F9E,0, 0x1F26,0x03B9,0, 0}},
- {{0x1F97,0x1F9F,0, 0x1F27,0x03B9,0, 0}},
- {{0x1FA0,0x1FA8,0, 0x1F60,0x03B9,0, 0}},
- {{0x1FA1,0x1FA9,0, 0x1F61,0x03B9,0, 0}},
- {{0x1FA2,0x1FAA,0, 0x1F62,0x03B9,0, 0}},
- {{0x1FA3,0x1FAB,0, 0x1F63,0x03B9,0, 0}},
- {{0x1FA4,0x1FAC,0, 0x1F64,0x03B9,0, 0}},
- {{0x1FA5,0x1FAD,0, 0x1F65,0x03B9,0, 0}},
- {{0x1FA6,0x1FAE,0, 0x1F66,0x03B9,0, 0}},
- {{0x1FA7,0x1FAF,0, 0x1F67,0x03B9,0, 0}},
- {{0x1FB2,0, 0x1F70,0x03B9,0, 0}},
- {{0x1FC2,0, 0x1F74,0x03B9,0, 0}},
- {{0x1FF2,0, 0x1F7C,0x03B9,0, 0}},
- {{0, 0xD801,0xDC00,0, 0xD801,0xDC28,0, 0}},
- {{0, 0xD801,0xDC01,0, 0xD801,0xDC29,0, 0}},
- {{0, 0xD801,0xDC02,0, 0xD801,0xDC2A,0, 0}},
- {{0, 0xD801,0xDC03,0, 0xD801,0xDC2B,0, 0}},
- {{0, 0xD801,0xDC04,0, 0xD801,0xDC2C,0, 0}},
- {{0, 0xD801,0xDC05,0, 0xD801,0xDC2D,0, 0}},
- {{0, 0xD801,0xDC06,0, 0xD801,0xDC2E,0, 0}},
- {{0, 0xD801,0xDC07,0, 0xD801,0xDC2F,0, 0}},
- {{0, 0xD801,0xDC08,0, 0xD801,0xDC30,0, 0}},
- {{0, 0xD801,0xDC09,0, 0xD801,0xDC31,0, 0}},
- {{0, 0xD801,0xDC0A,0, 0xD801,0xDC32,0, 0}},
- {{0, 0xD801,0xDC0B,0, 0xD801,0xDC33,0, 0}},
- {{0, 0xD801,0xDC0C,0, 0xD801,0xDC34,0, 0}},
- {{0, 0xD801,0xDC0D,0, 0xD801,0xDC35,0, 0}},
- {{0, 0xD801,0xDC0E,0, 0xD801,0xDC36,0, 0}},
- {{0, 0xD801,0xDC0F,0, 0xD801,0xDC37,0, 0}},
- {{0, 0xD801,0xDC10,0, 0xD801,0xDC38,0, 0}},
- {{0, 0xD801,0xDC11,0, 0xD801,0xDC39,0, 0}},
- {{0, 0xD801,0xDC12,0, 0xD801,0xDC3A,0, 0}},
- {{0, 0xD801,0xDC13,0, 0xD801,0xDC3B,0, 0}},
- {{0, 0xD801,0xDC14,0, 0xD801,0xDC3C,0, 0}},
- {{0, 0xD801,0xDC15,0, 0xD801,0xDC3D,0, 0}},
- {{0, 0xD801,0xDC16,0, 0xD801,0xDC3E,0, 0}},
- {{0, 0xD801,0xDC17,0, 0xD801,0xDC3F,0, 0}},
- {{0, 0xD801,0xDC18,0, 0xD801,0xDC40,0, 0}},
- {{0, 0xD801,0xDC19,0, 0xD801,0xDC41,0, 0}},
- {{0, 0xD801,0xDC1A,0, 0xD801,0xDC42,0, 0}},
- {{0, 0xD801,0xDC1B,0, 0xD801,0xDC43,0, 0}},
- {{0, 0xD801,0xDC1C,0, 0xD801,0xDC44,0, 0}},
- {{0, 0xD801,0xDC1D,0, 0xD801,0xDC45,0, 0}},
- {{0, 0xD801,0xDC1E,0, 0xD801,0xDC46,0, 0}},
- {{0, 0xD801,0xDC1F,0, 0xD801,0xDC47,0, 0}},
- {{0, 0xD801,0xDC20,0, 0xD801,0xDC48,0, 0}},
- {{0, 0xD801,0xDC21,0, 0xD801,0xDC49,0, 0}},
- {{0, 0xD801,0xDC22,0, 0xD801,0xDC4A,0, 0}},
- {{0, 0xD801,0xDC23,0, 0xD801,0xDC4B,0, 0}},
- {{0, 0xD801,0xDC24,0, 0xD801,0xDC4C,0, 0}},
- {{0, 0xD801,0xDC25,0, 0xD801,0xDC4D,0, 0}}
-};
-
-#define CASE_PAIRS_LENGTH (sizeof(CASE_PAIRS)/sizeof(CASE_PAIRS[0]))
-#define CASE_NONPAIRS_LENGTH (sizeof(CASE_NONPAIRS)/sizeof(CASE_NONPAIRS[0]))
-
-/**
- * Add to this set all members of the case fold equivalency class
- * that contains 'folded'.
- * @param folded a string within a case fold equivalency class.
- * It must have the property that UCharacter.foldCase(folded,
- * DEFAULT_CASE_MAP).equals(folded).
- */
-void UnicodeSet::caseCloseOne(const UnicodeString& folded) {
- if (folded.length() == 1) {
- caseCloseOne(folded.charAt(0));
- return;
+ if(length<0) {
+ length=(int32_t)uprv_strlen(s);
}
-
- const CaseEquivClass* c = getCaseMapOf(folded);
- if (c != NULL) {
- caseCloseOne(*c);
- return;
+ if(length==0) {
+ return 0;
}
-
- // Add 'folded' itself; it belongs to no equivalency class.
- add(folded);
-}
-
-/**
- * Add to this set all members of the case fold equivalency class
- * that contains 'folded'.
- * @param folded a code UNIT within a case fold equivalency class.
- * It must have the property that uchar_foldCase(folded,
- * DEFAULT_CASE_MAP) == folded.
- */
-void UnicodeSet::caseCloseOne(UChar folded) {
- // We must do a DOUBLE LOOKUP, first in the CompactByteArray that
- // indexes into CASE_NONPAIRS[] and then into the CASE_PAIRS[]
- // sorted array. A character will occur in one or the other, or
- // neither, but not both.
-
- // Look in the CompactByteArray.
- const CaseEquivClass* c = getCaseMapOf(folded);
- if (c != NULL) {
- caseCloseOne(*c);
- return;
+ if(stringSpan!=NULL) {
+ return stringSpan->spanUTF8((const uint8_t *)s, length, spanCondition);
+ } else if(hasStrings()) {
+ uint32_t which= spanCondition==USET_SPAN_NOT_CONTAINED ?
+ UnicodeSetStringSpan::FWD_UTF8_NOT_CONTAINED :
+ UnicodeSetStringSpan::FWD_UTF8_CONTAINED;
+ UnicodeSetStringSpan strSpan(*this, *strings, which);
+ if(strSpan.needsStringSpanUTF8()) {
+ return strSpan.spanUTF8((const uint8_t *)s, length, spanCondition);
+ }
}
- // Binary search in pairs array, looking at only even entries.
- // The indices low, high, and x will be halved with respect to
- // CASE_PAIRS[]; that is, they must be doubled before indexing.
+ if(spanCondition!=USET_SPAN_NOT_CONTAINED) {
+ spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values.
+ }
- // CASE_PAIRS has 1312 elements, of 656 pairs, so the search
- // takes no more than 10 passes.
- int32_t low = 0;
- int32_t high = (CASE_PAIRS_LENGTH >> 1) - 1;
- int32_t x;
+ UChar32 c;
+ int32_t start=0, prev=0;
do {
- x = (low + high) >> 1;
- UChar ch = CASE_PAIRS[x << 1];
- if (folded < ch) {
- high = x - 1;
- } else if (folded > ch) {
- low = x + 1;
- } else {
+ U8_NEXT_OR_FFFD(s, start, length, c);
+ if(spanCondition!=contains(c)) {
break;
}
- } while (low < high);
-
- x = (low + high) & ~1; // ((low + high) >> 1) << 1
- if (folded == CASE_PAIRS[x]) {
- add(CASE_PAIRS[x]);
- add(CASE_PAIRS[x+1]);
- } else {
- // If the search fails, then add folded itself; it is a
- // case-unique code unit.
- add(folded);
- }
+ } while((prev=start)<length);
+ return prev;
}
-/**
- * Add to this set all members of the given CaseEquivClass object.
- */
-void UnicodeSet::caseCloseOne(const CaseEquivClass& c) {
- const UChar* p = c.getSingles();
- while (*p) {
- add(*p++); // add all single code units
+int32_t UnicodeSet::spanBackUTF8(const char *s, int32_t length, USetSpanCondition spanCondition) const {
+ if(length>0 && bmpSet!=NULL) {
+ const uint8_t *s0=(const uint8_t *)s;
+ return bmpSet->spanBackUTF8(s0, length, spanCondition);
}
- for (c.getStrings(p); *p; c.nextString(p)) {
- add(p); // add all strings
+ if(length<0) {
+ length=(int32_t)uprv_strlen(s);
}
-}
-
-/**
- * Given a folded string of length >= 2 code units, return the
- * CaseEquivClass containing this string, or NULL if none.
- */
-const CaseEquivClass* UnicodeSet::getCaseMapOf(const UnicodeString& folded) {
- umtx_lock(NULL);
- UBool f = (CASE_EQUIV_HASH == NULL);
- umtx_unlock(NULL);
-
- if (f) {
- // Create the Hashtable, which maps UnicodeStrings to index
- // values into CASE_NONPAIRS.
- UErrorCode ec = U_ZERO_ERROR;
- Hashtable* hash = new Hashtable();
- if (hash != NULL) {
- int32_t i;
- for (i=0; i<(int32_t)CASE_NONPAIRS_LENGTH; ++i) {
- const CaseEquivClass* c = &CASE_NONPAIRS[i];
- const UChar* p;
- for (c->getStrings(p); *p; c->nextString(p)) {
- hash->put(UnicodeString(p), (void*) c, ec);
- }
- }
- if (U_SUCCESS(ec)) {
- umtx_lock(NULL);
- if (CASE_EQUIV_HASH == NULL) {
- CASE_EQUIV_HASH = hash;
- hash = NULL;
- }
- umtx_unlock(NULL);
- }
- delete hash;
- }
+ if(length==0) {
+ return 0;
}
-
- return (CASE_EQUIV_HASH != NULL) ?
- (const CaseEquivClass*) CASE_EQUIV_HASH->get(folded) : NULL;
-}
-
-/**
- * Given a folded code unit, return the CaseEquivClass containing it,
- * or NULL if none.
- */
-const CaseEquivClass* UnicodeSet::getCaseMapOf(UChar folded) {
- umtx_lock(NULL);
- UBool f = (CASE_EQUIV_CBA == NULL);
- umtx_unlock(NULL);
-
- if (f) {
- // Create the CompactByteArray, which maps single code units
- // to index values into CASE_NONPAIRS.
- CompactByteArray* cba = ucmp8_open(-1);
- if (ucmp8_isBogus(cba)) {
- ucmp8_close(cba);
- cba = NULL;
- } else {
- int32_t i;
- for (i=0; i<(int32_t)CASE_NONPAIRS_LENGTH; ++i) {
- const UChar* p = CASE_NONPAIRS[i].getSingles();
- UChar ch;
- while ((ch = *p++) != 0) {
- ucmp8_set(cba, ch, (int8_t) i);
- }
- }
- ucmp8_compact(cba, 256);
+ if(stringSpan!=NULL) {
+ return stringSpan->spanBackUTF8((const uint8_t *)s, length, spanCondition);
+ } else if(hasStrings()) {
+ uint32_t which= spanCondition==USET_SPAN_NOT_CONTAINED ?
+ UnicodeSetStringSpan::BACK_UTF8_NOT_CONTAINED :
+ UnicodeSetStringSpan::BACK_UTF8_CONTAINED;
+ UnicodeSetStringSpan strSpan(*this, *strings, which);
+ if(strSpan.needsStringSpanUTF8()) {
+ return strSpan.spanBackUTF8((const uint8_t *)s, length, spanCondition);
}
+ }
- umtx_lock(NULL);
- if (CASE_EQUIV_CBA == NULL) {
- CASE_EQUIV_CBA = cba;
- cba = NULL;
- }
- umtx_unlock(NULL);
- if (cba != NULL) {
- ucmp8_close(cba);
- }
+ if(spanCondition!=USET_SPAN_NOT_CONTAINED) {
+ spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values.
}
- if (CASE_EQUIV_CBA != NULL) {
- int32_t index = ucmp8_getu(CASE_EQUIV_CBA, folded);
- if (index != 255) {
- return &CASE_NONPAIRS[index];
+ UChar32 c;
+ int32_t prev=length;
+ do {
+ U8_PREV_OR_FFFD(s, 0, length, c);
+ if(spanCondition!=contains(c)) {
+ break;
}
- }
- return NULL;
+ } while((prev=length)>0);
+ return prev;
}
U_NAMESPACE_END
projects / apple / icu.git / blobdiff