| // © 2016 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| /* |
| ********************************************************************** |
| * Copyright (C) 1999-2015, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * Date Name Description |
| * 10/20/99 alan Creation. |
| ********************************************************************** |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "unicode/parsepos.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 "cstring.h" |
| #include "patternprops.h" |
| #include "uelement.h" |
| #include "util.h" |
| #include "uvector.h" |
| #include "charstr.h" |
| #include "ustrfmt.h" |
| #include "uassert.h" |
| #include "bmpset.h" |
| #include "unisetspan.h" |
| |
| // HIGH_VALUE > all valid values. 110000 for codepoints |
| #define UNICODESET_HIGH 0x0110000 |
| |
| // LOW <= all valid values. ZERO for codepoints |
| #define UNICODESET_LOW 0x000000 |
| |
| /** Max list [0, 1, 2, ..., max code point, HIGH] */ |
| constexpr int32_t MAX_LENGTH = UNICODESET_HIGH + 1; |
| |
| U_NAMESPACE_BEGIN |
| |
| SymbolTable::~SymbolTable() {} |
| |
| UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeSet) |
| |
| /** |
| * Modify the given UChar32 variable so that it is in range, by |
| * pinning values < UNICODESET_LOW to UNICODESET_LOW, and |
| * pinning values > UNICODESET_HIGH-1 to UNICODESET_HIGH-1. |
| * It modifies its argument in-place and also returns it. |
| */ |
| static inline UChar32 pinCodePoint(UChar32& c) { |
| if (c < UNICODESET_LOW) { |
| c = UNICODESET_LOW; |
| } else if (c > (UNICODESET_HIGH-1)) { |
| c = (UNICODESET_HIGH-1); |
| } |
| return c; |
| } |
| |
| //---------------------------------------------------------------- |
| // Debugging |
| //---------------------------------------------------------------- |
| |
| // DO NOT DELETE THIS CODE. This code is used to debug memory leaks. |
| // To enable the debugging, define the symbol DEBUG_MEM in the line |
| // below. This will result in text being sent to stdout that looks |
| // like this: |
| // DEBUG UnicodeSet: ct 0x00A39B20; 397 [\u0A81-\u0A83\u0A85- |
| // DEBUG UnicodeSet: dt 0x00A39B20; 396 [\u0A81-\u0A83\u0A85- |
| // Each line lists a construction (ct) or destruction (dt) event, the |
| // object address, the number of outstanding objects after the event, |
| // and the pattern of the object in question. |
| |
| // #define DEBUG_MEM |
| |
| #ifdef DEBUG_MEM |
| #include <stdio.h> |
| static int32_t _dbgCount = 0; |
| |
| static inline void _dbgct(UnicodeSet* set) { |
| UnicodeString str; |
| set->toPattern(str, TRUE); |
| char buf[40]; |
| str.extract(0, 39, buf, ""); |
| printf("DEBUG UnicodeSet: ct 0x%08X; %d %s\n", set, ++_dbgCount, buf); |
| } |
| |
| static inline void _dbgdt(UnicodeSet* set) { |
| UnicodeString str; |
| set->toPattern(str, TRUE); |
| char buf[40]; |
| str.extract(0, 39, buf, ""); |
| printf("DEBUG UnicodeSet: dt 0x%08X; %d %s\n", set, --_dbgCount, buf); |
| } |
| |
| #else |
| |
| #define _dbgct(set) |
| #define _dbgdt(set) |
| |
| #endif |
| |
| //---------------------------------------------------------------- |
| // UnicodeString in UVector support |
| //---------------------------------------------------------------- |
| |
| static void U_CALLCONV cloneUnicodeString(UElement *dst, UElement *src) { |
| dst->pointer = new UnicodeString(*(UnicodeString*)src->pointer); |
| } |
| |
| static int32_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() { |
| list[0] = UNICODESET_HIGH; |
| _dbgct(this); |
| } |
| |
| /** |
| * Constructs a set containing the given range. If <code>end > |
| * start</code> then an empty set is created. |
| * |
| * @param start first character, inclusive, of range |
| * @param end last character, inclusive, of range |
| */ |
| UnicodeSet::UnicodeSet(UChar32 start, UChar32 end) { |
| list[0] = UNICODESET_HIGH; |
| add(start, end); |
| _dbgct(this); |
| } |
| |
| /** |
| * Constructs a set that is identical to the given UnicodeSet. |
| */ |
| UnicodeSet::UnicodeSet(const UnicodeSet& o) : UnicodeFilter(o) { |
| *this = o; |
| _dbgct(this); |
| } |
| |
| // 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); |
| } |
| } |
| |
| /** |
| * Destructs the set. |
| */ |
| UnicodeSet::~UnicodeSet() { |
| _dbgdt(this); // first! |
| 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) { |
| 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, (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. |
| */ |
| UnicodeSet* UnicodeSet::clone() const { |
| return new UnicodeSet(*this); |
| } |
| |
| UnicodeSet *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 |
| * have the same size, and every member of the specified set is |
| * contained in this set (or equivalently, every member of this set is |
| * contained in the specified set). |
| * |
| * @param o set to be compared for equality with this set. |
| * @return <tt>true</tt> if the specified set is equal to this set. |
| */ |
| UBool UnicodeSet::operator==(const UnicodeSet& o) const { |
| if (len != o.len) return FALSE; |
| for (int32_t i = 0; i < len; ++i) { |
| if (list[i] != o.list[i]) return FALSE; |
| } |
| if (hasStrings() != o.hasStrings()) { return FALSE; } |
| if (hasStrings() && *strings != *o.strings) return FALSE; |
| return TRUE; |
| } |
| |
| /** |
| * Returns the hash code value for this set. |
| * |
| * @return the hash code value for this set. |
| * @see Object#hashCode() |
| */ |
| int32_t UnicodeSet::hashCode(void) const { |
| uint32_t result = static_cast<uint32_t>(len); |
| for (int32_t i = 0; i < len; ++i) { |
| result *= 1000003u; |
| result += list[i]; |
| } |
| return static_cast<int32_t>(result); |
| } |
| |
| //---------------------------------------------------------------- |
| // Public API |
| //---------------------------------------------------------------- |
| |
| /** |
| * Returns the number of elements in this set (its cardinality), |
| * Note than the elements of a set may include both individual |
| * codepoints and strings. |
| * |
| * @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 + stringsSize(); |
| } |
| |
| /** |
| * 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 && !hasStrings(); |
| } |
| |
| /** |
| * 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 (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 |
| } |
| |
| /** |
| * 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. |
| 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; |
| } |
| } |
| return hi; |
| } |
| |
| /** |
| * 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 { |
| int32_t cp = getSingleCP(s); |
| if (cp < 0) { |
| return stringsContains(s); |
| } else { |
| return contains((UChar32) cp); |
| } |
| } |
| |
| /** |
| * 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; |
| } |
| } |
| return !c.hasStrings() || (strings != nullptr && strings->containsAll(*c.strings)); |
| } |
| |
| /** |
| * Returns true if this set contains all the characters |
| * of the given string. |
| * @param s string containing characters to be checked for containment |
| * @return true if the test condition is met |
| */ |
| UBool UnicodeSet::containsAll(const UnicodeString& s) const { |
| 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. |
| * @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::containsNone(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 true if this set contains none of 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::containsNone(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 (int32_t i=0; i<n; ++i) { |
| if (!containsNone(c.getRangeStart(i), c.getRangeEnd(i))) { |
| return FALSE; |
| } |
| } |
| return strings == nullptr || !c.hasStrings() || strings->containsNone(*c.strings); |
| } |
| |
| /** |
| * Returns true if this set contains none of the characters |
| * of the given string. |
| * @param s string containing characters to be checked for containment |
| * @return true if the test condition is met |
| */ |
| UBool UnicodeSet::containsNone(const UnicodeString& s) const { |
| return (UBool)(span(s.getBuffer(), s.length(), USET_SPAN_NOT_CONTAINED) == |
| s.length()); |
| } |
| |
| /** |
| * Returns <tt>true</tt> if this set contains any character whose low byte |
| * is the given value. This is used by <tt>RuleBasedTransliterator</tt> for |
| * indexing. |
| */ |
| UBool UnicodeSet::matchesIndexValue(uint8_t v) const { |
| /* The index value v, in the range [0,255], is contained in this set if |
| * it is contained in any pair of this set. Pairs either have the high |
| * bytes equal, or unequal. If the high bytes are equal, then we have |
| * aaxx..aayy, where aa is the high byte. Then v is contained if xx <= |
| * v <= yy. If the high bytes are unequal we have aaxx..bbyy, bb>aa. |
| * Then v is contained if xx <= v || v <= yy. (This is identical to the |
| * time zone month containment logic.) |
| */ |
| int32_t i; |
| int32_t rangeCount=getRangeCount(); |
| for (i=0; i<rangeCount; ++i) { |
| UChar32 low = getRangeStart(i); |
| UChar32 high = getRangeEnd(i); |
| if ((low & ~0xFF) == (high & ~0xFF)) { |
| if ((low & 0xFF) <= v && v <= (high & 0xFF)) { |
| return TRUE; |
| } |
| } else if ((low & 0xFF) <= v || v <= (high & 0xFF)) { |
| return TRUE; |
| } |
| } |
| if (hasStrings()) { |
| for (i=0; i<strings->size(); ++i) { |
| const UnicodeString& s = *(const UnicodeString*)strings->elementAt(i); |
| if (s.isEmpty()) { |
| continue; // skip the empty string |
| } |
| UChar32 c = s.char32At(0); |
| if ((c & 0xFF) == v) { |
| return TRUE; |
| } |
| } |
| } |
| return FALSE; |
| } |
| |
| /** |
| * Implementation of UnicodeMatcher::matches(). Always matches the |
| * longest possible multichar string. |
| */ |
| UMatchDegree UnicodeSet::matches(const Replaceable& text, |
| int32_t& offset, |
| int32_t limit, |
| UBool incremental) { |
| if (offset == limit) { |
| if (contains(U_ETHER)) { |
| return incremental ? U_PARTIAL_MATCH : U_MATCH; |
| } else { |
| return U_MISMATCH; |
| } |
| } else { |
| if (hasStrings()) { // try strings first |
| |
| // might separate forward and backward loops later |
| // for now they are combined |
| |
| // TODO Improve efficiency of this, at least in the forward |
| // direction, if not in both. In the forward direction we |
| // can assume the strings are sorted. |
| |
| int32_t i; |
| UBool forward = offset < limit; |
| |
| // firstChar is the leftmost char to match in the |
| // forward direction or the rightmost char to match in |
| // the reverse direction. |
| UChar firstChar = text.charAt(offset); |
| |
| // If there are multiple strings that can match we |
| // return the longest match. |
| int32_t highWaterLength = 0; |
| |
| for (i=0; i<strings->size(); ++i) { |
| const UnicodeString& trial = *(const UnicodeString*)strings->elementAt(i); |
| if (trial.isEmpty()) { |
| continue; // skip the empty string |
| } |
| |
| UChar c = trial.charAt(forward ? 0 : trial.length() - 1); |
| |
| // Strings are sorted, so we can optimize in the |
| // forward direction. |
| if (forward && c > firstChar) break; |
| if (c != firstChar) continue; |
| |
| int32_t matchLen = matchRest(text, offset, limit, trial); |
| |
| if (incremental) { |
| int32_t maxLen = forward ? limit-offset : offset-limit; |
| if (matchLen == maxLen) { |
| // We have successfully matched but only up to limit. |
| return U_PARTIAL_MATCH; |
| } |
| } |
| |
| if (matchLen == trial.length()) { |
| // We have successfully matched the whole string. |
| if (matchLen > highWaterLength) { |
| highWaterLength = matchLen; |
| } |
| // In the forward direction we know strings |
| // are sorted so we can bail early. |
| if (forward && matchLen < highWaterLength) { |
| break; |
| } |
| continue; |
| } |
| } |
| |
| // We've checked all strings without a partial match. |
| // If we have full matches, return the longest one. |
| if (highWaterLength != 0) { |
| offset += forward ? highWaterLength : -highWaterLength; |
| return U_MATCH; |
| } |
| } |
| return UnicodeFilter::matches(text, offset, limit, incremental); |
| } |
| } |
| |
| /** |
| * Returns the longest match for s in text at the given position. |
| * If limit > start then match forward from start+1 to limit |
| * matching all characters except s.charAt(0). If limit < start, |
| * go backward starting from start-1 matching all characters |
| * except s.charAt(s.length()-1). This method assumes that the |
| * first character, text.charAt(start), matches s, so it does not |
| * check it. |
| * @param text the text to match |
| * @param start the first character to match. In the forward |
| * direction, text.charAt(start) is matched against s.charAt(0). |
| * In the reverse direction, it is matched against |
| * s.charAt(s.length()-1). |
| * @param limit the limit offset for matching, either last+1 in |
| * the forward direction, or last-1 in the reverse direction, |
| * where last is the index of the last character to match. |
| * @return If part of s matches up to the limit, return |limit - |
| * start|. If all of s matches before reaching the limit, return |
| * s.length(). If there is a mismatch between s and text, return |
| * 0 |
| */ |
| int32_t UnicodeSet::matchRest(const Replaceable& text, |
| int32_t start, int32_t limit, |
| const UnicodeString& s) { |
| int32_t i; |
| int32_t maxLen; |
| int32_t slen = s.length(); |
| if (start < limit) { |
| maxLen = limit - start; |
| if (maxLen > slen) maxLen = slen; |
| for (i = 1; i < maxLen; ++i) { |
| if (text.charAt(start + i) != s.charAt(i)) return 0; |
| } |
| } else { |
| maxLen = start - limit; |
| if (maxLen > slen) maxLen = slen; |
| --slen; // <=> slen = s.length() - 1; |
| for (i = 1; i < maxLen; ++i) { |
| if (text.charAt(start - i) != s.charAt(slen - i)) return 0; |
| } |
| } |
| return maxLen; |
| } |
| |
| /** |
| * Implement of UnicodeMatcher |
| */ |
| void UnicodeSet::addMatchSetTo(UnicodeSet& toUnionTo) const { |
| toUnionTo.addAll(*this); |
| } |
| |
| /** |
| * Returns the index of the given character within this set, where |
| * the set is ordered by ascending code point. If the character |
| * is not in this set, return -1. The inverse of this method is |
| * <code>charAt()</code>. |
| * @return an index from 0..size()-1, or -1 |
| */ |
| int32_t UnicodeSet::indexOf(UChar32 c) const { |
| if (c < MIN_VALUE || c > MAX_VALUE) { |
| return -1; |
| } |
| int32_t i = 0; |
| int32_t n = 0; |
| for (;;) { |
| UChar32 start = list[i++]; |
| if (c < start) { |
| return -1; |
| } |
| UChar32 limit = list[i++]; |
| if (c < limit) { |
| return n + c - start; |
| } |
| n += limit - start; |
| } |
| } |
| |
| /** |
| * Returns the character at the given index within this set, where |
| * the set is ordered by ascending code point. If the index is |
| * out of range, return (UChar32)-1. The inverse of this method is |
| * <code>indexOf()</code>. |
| * @param index an index from 0..size()-1 |
| * @return the character at the given index, or (UChar32)-1. |
| */ |
| UChar32 UnicodeSet::charAt(int32_t index) const { |
| if (index >= 0) { |
| // len2 is the largest even integer <= len, that is, it is len |
| // for even values and len-1 for odd values. With odd values |
| // the last entry is UNICODESET_HIGH. |
| int32_t len2 = len & ~1; |
| for (int32_t i=0; i < len2;) { |
| UChar32 start = list[i++]; |
| int32_t count = list[i++] - start; |
| if (index < count) { |
| return (UChar32)(start + index); |
| } |
| index -= count; |
| } |
| } |
| return (UChar32)-1; |
| } |
| |
| /** |
| * 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 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 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); |
| } |
| return *this; |
| } |
| |
| // #define DEBUG_US_ADD |
| |
| #ifdef DEBUG_US_ADD |
| #include <stdio.h> |
| void dump(UChar32 c) { |
| if (c <= 0xFF) { |
| printf("%c", (char)c); |
| } else { |
| printf("U+%04X", c); |
| } |
| } |
| void dump(const UChar32* list, int32_t len) { |
| printf("["); |
| for (int32_t i=0; i<len; ++i) { |
| if (i != 0) printf(", "); |
| dump(list[i]); |
| } |
| printf("]"); |
| } |
| #endif |
| |
| /** |
| * Adds the specified character to this set if it is not already |
| * present. If this set already contains the specified character, |
| * the call leaves this set unchanged. |
| */ |
| UnicodeSet& UnicodeSet::add(UChar32 c) { |
| // find smallest i such that c < list[i] |
| // if odd, then it is IN the set |
| // if even, then it is OUT of the set |
| int32_t i = findCodePoint(pinCodePoint(c)); |
| |
| // already in set? |
| 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] |
| |
| // i == 0 means c is before the first range |
| |
| #ifdef DEBUG_US_ADD |
| printf("Add of "); |
| dump(c); |
| printf(" found at %d", i); |
| printf(": "); |
| dump(list, len); |
| printf(" => "); |
| #endif |
| |
| if (c == list[i]-1) { |
| // c is before start of next range |
| list[i] = c; |
| // if we touched the HIGH mark, then add a new one |
| if (c == (UNICODESET_HIGH - 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]) { |
| // collapse adjacent ranges |
| |
| // [..., start_k-1, c, c, limit_k, ..., HIGH] |
| // ^ |
| // list[i] |
| |
| //for (int32_t k=i-1; k<len-2; ++k) { |
| // list[k] = list[k+2]; |
| //} |
| UChar32* dst = list + i - 1; |
| UChar32* src = dst + 2; |
| UChar32* srclimit = list + len; |
| while (src < srclimit) *(dst++) = *(src++); |
| |
| len -= 2; |
| } |
| } |
| |
| else if (i > 0 && c == list[i-1]) { |
| // c is after end of prior range |
| list[i-1]++; |
| // no need to check for collapse here |
| } |
| |
| else { |
| // At this point we know the new char is not adjacent to |
| // any existing ranges, and it is not 10FFFF. |
| |
| |
| // [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH] |
| // ^ |
| // list[i] |
| |
| // [..., start_k-1, limit_k-1, c, c+1, start_k, limit_k, ..., HIGH] |
| // ^ |
| // list[i] |
| |
| 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"); |
| |
| for (i=1; i<len; ++i) { |
| if (list[i] <= list[i-1]) { |
| // Corrupt array! |
| printf("ERROR: list has been corrupted\n"); |
| exit(1); |
| } |
| } |
| #endif |
| |
| releasePattern(); |
| return *this; |
| } |
| |
| /** |
| * Adds the specified multicharacter to this set if it is not already |
| * present. If this set already contains the multicharacter, |
| * the call leaves this set unchanged. |
| * Thus "ch" => {"ch"} |
| * |
| * @param s the source string |
| * @return the modified set, for chaining |
| */ |
| UnicodeSet& UnicodeSet::add(const UnicodeString& s) { |
| if (isFrozen() || isBogus()) return *this; |
| int32_t cp = getSingleCP(s); |
| if (cp < 0) { |
| if (!stringsContains(s)) { |
| _add(s); |
| releasePattern(); |
| } |
| } else { |
| add((UChar32)cp); |
| } |
| return *this; |
| } |
| |
| /** |
| * Adds the given string, in order, to 'strings'. The given string |
| * must have been checked by the caller to not already be in 'strings'. |
| */ |
| void UnicodeSet::_add(const 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; |
| } |
| } |
| |
| /** |
| * @return a code point IF the string consists of a single one. |
| * otherwise returns -1. |
| * @param string to test |
| */ |
| int32_t UnicodeSet::getSingleCP(const UnicodeString& s) { |
| int32_t sLength = s.length(); |
| if (sLength == 1) return s.charAt(0); |
| if (sLength == 2) { |
| UChar32 cp = s.char32At(0); |
| if (cp > 0xFFFF) { // is surrogate pair |
| return cp; |
| } |
| } |
| return -1; |
| } |
| |
| /** |
| * Adds each of the characters in this string to the set. Thus "ch" => {"c", "h"} |
| * If this set already any particular character, it has no effect on that character. |
| * @param the source string |
| * @return the modified set, for chaining |
| */ |
| UnicodeSet& UnicodeSet::addAll(const UnicodeString& s) { |
| UChar32 cp; |
| for (int32_t i = 0; i < s.length(); i += U16_LENGTH(cp)) { |
| cp = s.char32At(i); |
| add(cp); |
| } |
| return *this; |
| } |
| |
| /** |
| * Retains EACH of the characters in this string. Note: "ch" == {"c", "h"} |
| * If this set already any particular character, it has no effect on that character. |
| * @param the source string |
| * @return the modified set, for chaining |
| */ |
| UnicodeSet& UnicodeSet::retainAll(const UnicodeString& s) { |
| UnicodeSet set; |
| set.addAll(s); |
| retainAll(set); |
| return *this; |
| } |
| |
| /** |
| * Complement EACH of the characters in this string. Note: "ch" == {"c", "h"} |
| * If this set already any particular character, it has no effect on that character. |
| * @param the source string |
| * @return the modified set, for chaining |
| */ |
| UnicodeSet& UnicodeSet::complementAll(const UnicodeString& s) { |
| UnicodeSet set; |
| set.addAll(s); |
| complementAll(set); |
| return *this; |
| } |
| |
| /** |
| * Remove EACH of the characters in this string. Note: "ch" == {"c", "h"} |
| * If this set already any particular character, it has no effect on that character. |
| * @param the source string |
| * @return the modified set, for chaining |
| */ |
| UnicodeSet& UnicodeSet::removeAll(const UnicodeString& s) { |
| UnicodeSet set; |
| set.addAll(s); |
| removeAll(set); |
| 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* U_EXPORT2 UnicodeSet::createFrom(const UnicodeString& s) { |
| UnicodeSet *set = new UnicodeSet(); |
| if (set != NULL) { // Check for memory allocation error. |
| set->add(s); |
| } |
| return set; |
| } |
| |
| |
| /** |
| * Makes a set from each of the characters in the string. Thus "ch" => {"c", "h"} |
| * @param the source string |
| * @return a newly created set containing the given characters |
| */ |
| UnicodeSet* U_EXPORT2 UnicodeSet::createFromAll(const UnicodeString& s) { |
| UnicodeSet *set = new UnicodeSet(); |
| if (set != NULL) { // Check for memory allocation error. |
| set->addAll(s); |
| } |
| return set; |
| } |
| |
| /** |
| * Retain only the elements in this set that are contained in the |
| * specified range. If <code>end > start</code> then an empty range is |
| * retained, leaving the set empty. |
| * |
| * @param start first character, inclusive, of range to be retained |
| * to this set. |
| * @param end last character, inclusive, of range to be retained |
| * to this set. |
| */ |
| UnicodeSet& UnicodeSet::retain(UChar32 start, UChar32 end) { |
| if (pinCodePoint(start) <= pinCodePoint(end)) { |
| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; |
| retain(range, 2, 0); |
| } else { |
| clear(); |
| } |
| return *this; |
| } |
| |
| UnicodeSet& UnicodeSet::retain(UChar32 c) { |
| return retain(c, c); |
| } |
| |
| UnicodeSet& UnicodeSet::retain(const UnicodeString &s) { |
| if (isFrozen() || isBogus()) { return *this; } |
| UChar32 cp = getSingleCP(s); |
| if (cp < 0) { |
| bool isIn = stringsContains(s); |
| // Check for getRangeCount() first to avoid somewhat-expensive size() |
| // when there are single code points. |
| if (isIn && getRangeCount() == 0 && size() == 1) { |
| return *this; |
| } |
| clear(); |
| if (isIn) { |
| _add(s); |
| } |
| } else { |
| retain(cp, cp); |
| } |
| return *this; |
| } |
| |
| /** |
| * Removes the specified range from this set if it is present. |
| * 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 |
| * from this set. |
| */ |
| UnicodeSet& UnicodeSet::remove(UChar32 start, UChar32 end) { |
| if (pinCodePoint(start) <= pinCodePoint(end)) { |
| UChar32 range[3] = { start, end+1, UNICODESET_HIGH }; |
| retain(range, 2, 2); |
| } |
| return *this; |
| } |
| |
| /** |
| * Removes the specified character from this set if it is present. |
| * The set will not contain the specified range once the call |
| * returns. |
| */ |
| UnicodeSet& UnicodeSet::remove(UChar32 c) { |
| return remove(c, c); |
| } |
| |
| /** |
| * Removes the specified string from this set if it is present. |
| * The set will not contain the specified character once the call |
| * returns. |
| * @param the source string |
| * @return the modified set, for chaining |
| */ |
| UnicodeSet& UnicodeSet::remove(const UnicodeString& s) { |
| if (isFrozen() || isBogus()) return *this; |
| int32_t cp = getSingleCP(s); |
| if (cp < 0) { |
| if (strings != nullptr && strings->removeElement((void*) &s)) { |
| releasePattern(); |
| } |
| } else { |
| remove((UChar32)cp, (UChar32)cp); |
| } |
| return *this; |
| } |
| |
| /** |
| * Complements the specified range in this set. Any character in |
| * the range will be removed if it is in this set, or will be |
| * added if it is not in this set. If <code>end > start</code> |
| * then an empty range is xor'ed, 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 |
| * 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); |
| } |
| releasePattern(); |
| return *this; |
| } |
| |
| UnicodeSet& UnicodeSet::complement(UChar32 c) { |
| return complement(c, c); |
| } |
| |
| /** |
| * This is equivalent to |
| * <code>complement(MIN_VALUE, MAX_VALUE)</code>. |
| */ |
| UnicodeSet& UnicodeSet::complement(void) { |
| if (isFrozen() || isBogus()) { |
| return *this; |
| } |
| if (list[0] == UNICODESET_LOW) { |
| uprv_memmove(list, list + 1, (size_t)(len-1)*sizeof(UChar32)); |
| --len; |
| } else { |
| if (!ensureCapacity(len+1)) { |
| return *this; |
| } |
| uprv_memmove(list + 1, list, (size_t)len*sizeof(UChar32)); |
| list[0] = UNICODESET_LOW; |
| ++len; |
| } |
| releasePattern(); |
| return *this; |
| } |
| |
| /** |
| * Complement the specified string in this set. |
| * The set will not contain the specified string once the call |
| * returns. |
| * |
| * @param s the string to complement |
| * @return this object, for chaining |
| */ |
| UnicodeSet& UnicodeSet::complement(const UnicodeString& s) { |
| if (isFrozen() || isBogus()) return *this; |
| int32_t cp = getSingleCP(s); |
| if (cp < 0) { |
| if (stringsContains(s)) { |
| strings->removeElement((void*) &s); |
| } else { |
| _add(s); |
| } |
| releasePattern(); |
| } else { |
| complement((UChar32)cp, (UChar32)cp); |
| } |
| return *this; |
| } |
| |
| /** |
| * Adds all of the elements in the specified set to this set if |
| * they're not already present. This operation effectively |
| * modifies this set so that its value is the <i>union</i> of the two |
| * sets. The behavior of this operation is unspecified if the specified |
| * collection is modified while the operation is in progress. |
| * |
| * @param c set whose elements are to be added to this set. |
| * @see #add(char, char) |
| */ |
| UnicodeSet& UnicodeSet::addAll(const UnicodeSet& c) { |
| if ( c.len>0 && c.list!=NULL ) { |
| add(c.list, c.len, 0); |
| } |
| |
| // 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; |
| } |
| |
| /** |
| * Retains only the elements in this set that are contained in the |
| * specified set. In other words, removes from this set all of |
| * its elements that are not contained in the specified set. This |
| * operation effectively modifies this set so that its value is |
| * the <i>intersection</i> of the two sets. |
| * |
| * @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); |
| if (hasStrings()) { |
| if (!c.hasStrings()) { |
| strings->removeAllElements(); |
| } else { |
| strings->retainAll(*c.strings); |
| } |
| } |
| return *this; |
| } |
| |
| /** |
| * Removes from this set all of its elements that are contained in the |
| * specified set. This operation effectively modifies this |
| * set so that its value is the <i>asymmetric set difference</i> of |
| * the two sets. |
| * |
| * @param c set that defines which elements will be removed from |
| * this set. |
| */ |
| UnicodeSet& UnicodeSet::removeAll(const UnicodeSet& c) { |
| if (isFrozen() || isBogus()) { |
| return *this; |
| } |
| retain(c.list, c.len, 2); |
| if (hasStrings() && c.hasStrings()) { |
| strings->removeAll(*c.strings); |
| } |
| return *this; |
| } |
| |
| /** |
| * Complements in this set all elements contained in the specified |
| * set. Any character in the other set will be removed if it is |
| * in this set, or will be added if it is not in this set. |
| * |
| * @param c set that defines which elements will be xor'ed from |
| * this set. |
| */ |
| UnicodeSet& UnicodeSet::complementAll(const UnicodeSet& c) { |
| if (isFrozen() || isBogus()) { |
| return *this; |
| } |
| exclusiveOr(c.list, c.len, 0); |
| |
| 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; |
| } |
| |
| /** |
| * Removes all of the elements from this set. This set will be |
| * empty after this call returns. |
| */ |
| UnicodeSet& UnicodeSet::clear(void) { |
| if (isFrozen()) { |
| return *this; |
| } |
| list[0] = UNICODESET_HIGH; |
| len = 1; |
| releasePattern(); |
| if (strings != NULL) { |
| strings->removeAllElements(); |
| } |
| // Remove bogus |
| fFlags = 0; |
| return *this; |
| } |
| |
| /** |
| * Iteration method that returns the number of ranges contained in |
| * this set. |
| * @see #getRangeStart |
| * @see #getRangeEnd |
| */ |
| int32_t UnicodeSet::getRangeCount() const { |
| return len/2; |
| } |
| |
| /** |
| * Iteration method that returns the first character in the |
| * specified range of this set. |
| * @see #getRangeCount |
| * @see #getRangeEnd |
| */ |
| UChar32 UnicodeSet::getRangeStart(int32_t index) const { |
| return list[index*2]; |
| } |
| |
| /** |
| * Iteration method that returns the last character in the |
| * specified range of this set. |
| * @see #getRangeStart |
| * @see #getRangeEnd |
| */ |
| UChar32 UnicodeSet::getRangeEnd(int32_t index) const { |
| return list[index*2 + 1] - 1; |
| } |
| |
| const UnicodeString* UnicodeSet::getString(int32_t index) const { |
| return (const UnicodeString*) strings->elementAt(index); |
| } |
| |
| /** |
| * Reallocate this objects internal structures to take up the least |
| * possible space, without changing this object's value. |
| */ |
| UnicodeSet& UnicodeSet::compact() { |
| 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 = 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; |
| } |
| 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; |
| |
| if (U_FAILURE(ec)) { |
| return 0; |
| } |
| |
| if (destCapacity<0 || (destCapacity>0 && dest==NULL)) { |
| ec=U_ILLEGAL_ARGUMENT_ERROR; |
| return 0; |
| } |
| |
| /* count necessary 16-bit units */ |
| length=this->len-1; // Subtract 1 to ignore final UNICODESET_HIGH |
| // assert(length>=0); |
| if (length==0) { |
| /* empty set */ |
| if (destCapacity>0) { |
| *dest=0; |
| } else { |
| ec=U_BUFFER_OVERFLOW_ERROR; |
| } |
| return 1; |
| } |
| /* now length>0 */ |
| |
| if (this->list[length-1]<=0xffff) { |
| /* all BMP */ |
| bmpLength=length; |
| } else if (this->list[0]>=0x10000) { |
| /* all supplementary */ |
| bmpLength=0; |
| length*=2; |
| } else { |
| /* some BMP, some supplementary */ |
| 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 */ |
| ec=U_INDEX_OUTOFBOUNDS_ERROR; |
| return 0; |
| } |
| |
| /* |
| * total serialized length: |
| * number of 16-bit array units (length) + |
| * 1 length unit (always) + |
| * 1 bmpLength unit (if there are supplementary values) |
| */ |
| destLength=length+((length>bmpLength)?2:1); |
| if (destLength<=destCapacity) { |
| const UChar32 *p; |
| int32_t i; |
| |
| #ifdef DEBUG_SERIALIZE |
| printf("writeHdr\n"); |
| #endif |
| *dest=(uint16_t)length; |
| if (length>bmpLength) { |
| *dest|=0x8000; |
| *++dest=(uint16_t)bmpLength; |
| } |
| ++dest; |
| |
| /* 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++; |
| } |
| } else { |
| ec=U_BUFFER_OVERFLOW_ERROR; |
| } |
| return destLength; |
| } |
| |
| //---------------------------------------------------------------- |
| // Implementation: Utility methods |
| //---------------------------------------------------------------- |
| |
| /** |
| * Allocate our strings vector and return TRUE if successful. |
| */ |
| UBool UnicodeSet::allocateStrings(UErrorCode &status) { |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| 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; |
| } |
| |
| 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; |
| } |
| } |
| |
| bool UnicodeSet::ensureCapacity(int32_t newLen) { |
| if (newLen > MAX_LENGTH) { |
| newLen = MAX_LENGTH; |
| } |
| if (newLen <= capacity) { |
| return true; |
| } |
| 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; |
| } |
| // Copy only the actual contents. |
| uprv_memcpy(temp, list, len * sizeof(UChar32)); |
| if (list != stackList) { |
| uprv_free(list); |
| } |
| list = temp; |
| capacity = newCapacity; |
| return true; |
| } |
| |
| bool UnicodeSet::ensureBufferCapacity(int32_t newLen) { |
| if (newLen > MAX_LENGTH) { |
| newLen = MAX_LENGTH; |
| } |
| if (newLen <= bufferCapacity) { |
| return true; |
| } |
| int32_t newCapacity = nextCapacity(newLen); |
| UChar32* temp = (UChar32*) uprv_malloc(newCapacity * sizeof(UChar32)); |
| if (temp == NULL) { |
| setToBogus(); |
| return false; |
| } |
| // The buffer has no contents to be copied. |
| // It is always filled from scratch after this call. |
| if (buffer != stackList) { |
| uprv_free(buffer); |
| } |
| buffer = temp; |
| bufferCapacity = newCapacity; |
| return true; |
| } |
| |
| /** |
| * Swap list and buffer. |
| */ |
| void UnicodeSet::swapBuffers(void) { |
| // swap list and buffer |
| UChar32* temp = list; |
| list = buffer; |
| buffer = temp; |
| |
| int32_t c = capacity; |
| capacity = bufferCapacity; |
| bufferCapacity = c; |
| } |
| |
| void UnicodeSet::setToBogus() { |
| clear(); // Remove everything in the set. |
| fFlags = kIsBogus; |
| } |
| |
| //---------------------------------------------------------------- |
| // Implementation: Fundamental operators |
| //---------------------------------------------------------------- |
| |
| static inline UChar32 max(UChar32 a, UChar32 b) { |
| return (a > b) ? a : b; |
| } |
| |
| // polarity = 0, 3 is normal: x xor y |
| // polarity = 1, 2: x xor ~y == x === y |
| |
| void UnicodeSet::exclusiveOr(const UChar32* other, int32_t otherLen, int8_t polarity) { |
| if (isFrozen() || isBogus()) { |
| return; |
| } |
| if (!ensureBufferCapacity(len + otherLen)) { |
| return; |
| } |
| |
| int32_t i = 0, j = 0, k = 0; |
| UChar32 a = list[i++]; |
| UChar32 b; |
| if (polarity == 1 || polarity == 2) { |
| b = UNICODESET_LOW; |
| if (other[j] == UNICODESET_LOW) { // skip base if already LOW |
| ++j; |
| b = other[j]; |
| } |
| } else { |
| b = other[j++]; |
| } |
| // simplest of all the routines |
| // sort the values, discarding identicals! |
| for (;;) { |
| if (a < b) { |
| buffer[k++] = a; |
| a = list[i++]; |
| } else if (b < a) { |
| buffer[k++] = b; |
| b = other[j++]; |
| } else if (a != UNICODESET_HIGH) { // at this point, a == b |
| // discard both values! |
| a = list[i++]; |
| b = other[j++]; |
| } else { // DONE! |
| buffer[k++] = UNICODESET_HIGH; |
| len = k; |
| break; |
| } |
| } |
| swapBuffers(); |
| releasePattern(); |
| } |
| |
| // polarity = 0 is normal: x union y |
| // polarity = 2: x union ~y |
| // polarity = 1: ~x union y |
| // polarity = 3: ~x union ~y |
| |
| void UnicodeSet::add(const UChar32* other, int32_t otherLen, int8_t polarity) { |
| 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++]; |
| // 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) { |
| case 0: // both first; take lower if unequal |
| if (a < b) { // take a |
| // Back up over overlapping ranges in buffer[] |
| if (k > 0 && a <= buffer[k-1]) { |
| // Pick latter end value in buffer[] vs. list[] |
| a = max(list[i], buffer[--k]); |
| } else { |
| // No overlap |
| buffer[k++] = a; |
| a = list[i]; |
| } |
| i++; // Common if/else code factored out |
| polarity ^= 1; |
| } else if (b < a) { // take b |
| if (k > 0 && b <= buffer[k-1]) { |
| b = max(other[j], buffer[--k]); |
| } else { |
| buffer[k++] = b; |
| b = other[j]; |
| } |
| j++; |
| polarity ^= 2; |
| } else { // a == b, take a, drop b |
| if (a == UNICODESET_HIGH) goto loop_end; |
| // This is symmetrical; it doesn't matter if |
| // we backtrack with a or b. - liu |
| if (k > 0 && a <= buffer[k-1]) { |
| a = max(list[i], buffer[--k]); |
| } else { |
| // No overlap |
| buffer[k++] = a; |
| a = list[i]; |
| } |
| i++; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| case 3: // both second; take higher if unequal, and drop other |
| if (b <= a) { // take a |
| if (a == UNICODESET_HIGH) goto loop_end; |
| buffer[k++] = a; |
| } else { // take b |
| if (b == UNICODESET_HIGH) goto loop_end; |
| buffer[k++] = b; |
| } |
| a = list[i++]; |
| polarity ^= 1; // factored common code |
| b = other[j++]; |
| polarity ^= 2; |
| break; |
| case 1: // a second, b first; if b < a, overlap |
| if (a < b) { // no overlap, take a |
| buffer[k++] = a; a = list[i++]; polarity ^= 1; |
| } else if (b < a) { // OVERLAP, drop b |
| b = other[j++]; |
| polarity ^= 2; |
| } else { // a == b, drop both! |
| if (a == UNICODESET_HIGH) goto loop_end; |
| a = list[i++]; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| case 2: // a first, b second; if a < b, overlap |
| if (b < a) { // no overlap, take b |
| buffer[k++] = b; |
| b = other[j++]; |
| polarity ^= 2; |
| } else if (a < b) { // OVERLAP, drop a |
| a = list[i++]; |
| polarity ^= 1; |
| } else { // a == b, drop both! |
| if (a == UNICODESET_HIGH) goto loop_end; |
| a = list[i++]; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| } |
| } |
| loop_end: |
| buffer[k++] = UNICODESET_HIGH; // terminate |
| len = k; |
| swapBuffers(); |
| releasePattern(); |
| } |
| |
| // polarity = 0 is normal: x intersect y |
| // polarity = 2: x intersect ~y == set-minus |
| // polarity = 1: ~x intersect y |
| // polarity = 3: ~x intersect ~y |
| |
| void UnicodeSet::retain(const UChar32* other, int32_t otherLen, int8_t polarity) { |
| 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) { |
| case 0: // both first; drop the smaller |
| if (a < b) { // drop a |
| a = list[i++]; |
| polarity ^= 1; |
| } else if (b < a) { // drop b |
| b = other[j++]; |
| polarity ^= 2; |
| } else { // a == b, take one, drop other |
| if (a == UNICODESET_HIGH) goto loop_end; |
| buffer[k++] = a; |
| a = list[i++]; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| case 3: // both second; take lower if unequal |
| if (a < b) { // take a |
| buffer[k++] = a; |
| a = list[i++]; |
| polarity ^= 1; |
| } else if (b < a) { // take b |
| buffer[k++] = b; |
| b = other[j++]; |
| polarity ^= 2; |
| } else { // a == b, take one, drop other |
| if (a == UNICODESET_HIGH) goto loop_end; |
| buffer[k++] = a; |
| a = list[i++]; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| case 1: // a second, b first; |
| if (a < b) { // NO OVERLAP, drop a |
| a = list[i++]; |
| polarity ^= 1; |
| } else if (b < a) { // OVERLAP, take b |
| buffer[k++] = b; |
| b = other[j++]; |
| polarity ^= 2; |
| } else { // a == b, drop both! |
| if (a == UNICODESET_HIGH) goto loop_end; |
| a = list[i++]; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| case 2: // a first, b second; if a < b, overlap |
| if (b < a) { // no overlap, drop b |
| b = other[j++]; |
| polarity ^= 2; |
| } else if (a < b) { // OVERLAP, take a |
| buffer[k++] = a; |
| a = list[i++]; |
| polarity ^= 1; |
| } else { // a == b, drop both! |
| if (a == UNICODESET_HIGH) goto loop_end; |
| a = list[i++]; |
| polarity ^= 1; |
| b = other[j++]; |
| polarity ^= 2; |
| } |
| break; |
| } |
| } |
| loop_end: |
| buffer[k++] = UNICODESET_HIGH; // terminate |
| len = k; |
| swapBuffers(); |
| releasePattern(); |
| } |
| |
| /** |
| * Append the <code>toPattern()</code> representation of a |
| * string to the given <code>StringBuffer</code>. |
| */ |
| 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); |
| } |
| } |
| |
| /** |
| * 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; |
| } |
| } |
| // Okay to let ':' pass through |
| switch (c) { |
| case u'[': |
| case u']': |
| case u'-': |
| case u'^': |
| case u'&': |
| case u'\\': |
| case u'{': |
| case u'}': |
| case u':': |
| case SymbolTable::SYMBOL_REF: |
| buf.append(u'\\'); |
| break; |
| default: |
| // Escape whitespace |
| if (PatternProps::isWhiteSpace(c)) { |
| buf.append(u'\\'); |
| } |
| break; |
| } |
| buf.append(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 == u'\\') { |
| ++backslashCount; |
| } else { |
| backslashCount = 0; |
| } |
| } |
| } |
| return result; |
| } |
| |
| return _generatePattern(result, escapeUnprintable); |
| } |
| |
| /** |
| * 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); |
| } |
| |
| /** |
| * 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(u'['); |
| |
| // // 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(u':'); |
| // 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(u'^'); |
| |
| 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(u'-'); |
| } |
| _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) { |
| if ((start+1) != end) { |
| result.append(u'-'); |
| } |
| _appendToPat(result, end, escapeUnprintable); |
| } |
| } |
| } |
| |
| if (strings != nullptr) { |
| for (int32_t i = 0; i<strings->size(); ++i) { |
| result.append(u'{'); |
| _appendToPat(result, |
| *(const UnicodeString*) strings->elementAt(i), |
| escapeUnprintable); |
| result.append(u'}'); |
| } |
| } |
| return result.append(u']'); |
| } |
| |
| /** |
| * Release existing cached pattern |
| */ |
| void UnicodeSet::releasePattern() { |
| if (pat) { |
| uprv_free(pat); |
| pat = NULL; |
| patLen = 0; |
| } |
| } |
| |
| /** |
| * 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. |
| } |
| |
| UnicodeSet *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; |
| } |
| } |
| 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(); |
| } |
| } |
| } |
| return this; |
| } |
| |
| 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); |
| } |
| if(length<0) { |
| length=u_strlen(s); |
| } |
| if(length==0) { |
| return 0; |
| } |
| 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); |
| } |
| } |
| |
| if(spanCondition!=USET_SPAN_NOT_CONTAINED) { |
| spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values. |
| } |
| |
| UChar32 c; |
| int32_t start=0, prev=0; |
| do { |
| U16_NEXT(s, start, length, c); |
| if(spanCondition!=contains(c)) { |
| break; |
| } |
| } while((prev=start)<length); |
| return prev; |
| } |
| |
| 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(length<0) { |
| length=u_strlen(s); |
| } |
| if(length==0) { |
| return 0; |
| } |
| 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); |
| } |
| } |
| |
| if(spanCondition!=USET_SPAN_NOT_CONTAINED) { |
| spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values. |
| } |
| |
| UChar32 c; |
| int32_t prev=length; |
| do { |
| U16_PREV(s, 0, length, c); |
| if(spanCondition!=contains(c)) { |
| break; |
| } |
| } while((prev=length)>0); |
| return prev; |
| } |
| |
| 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); |
| } |
| if(length<0) { |
| length=(int32_t)uprv_strlen(s); |
| } |
| if(length==0) { |
| return 0; |
| } |
| 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); |
| } |
| } |
| |
| if(spanCondition!=USET_SPAN_NOT_CONTAINED) { |
| spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values. |
| } |
| |
| UChar32 c; |
| int32_t start=0, prev=0; |
| do { |
| U8_NEXT_OR_FFFD(s, start, length, c); |
| if(spanCondition!=contains(c)) { |
| break; |
| } |
| } while((prev=start)<length); |
| return prev; |
| } |
| |
| 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); |
| } |
| if(length<0) { |
| length=(int32_t)uprv_strlen(s); |
| } |
| if(length==0) { |
| return 0; |
| } |
| 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); |
| } |
| } |
| |
| if(spanCondition!=USET_SPAN_NOT_CONTAINED) { |
| spanCondition=USET_SPAN_CONTAINED; // Pin to 0/1 values. |
| } |
| |
| UChar32 c; |
| int32_t prev=length; |
| do { |
| U8_PREV_OR_FFFD(s, 0, length, c); |
| if(spanCondition!=contains(c)) { |
| break; |
| } |
| } while((prev=length)>0); |
| return prev; |
| } |
| |
| U_NAMESPACE_END |
