#include "unicode/utypes.h"
#include "unicode/uniset.h"
#include "unicode/parsepos.h"
#include "unicode/symtable.h"
#include "ruleiter.h"
#include "cmemory.h"
#include "uhash.h"
#include "util.h"
#include "uvector.h"
#include "charstr.h"
#include "ustrfmt.h"
#include "mutex.h"
#include "uassert.h"
#include "hash.h"
#define SET_OPEN ((UChar)0x005B)
#define SET_CLOSE ((UChar)0x005D)
#define HYPHEN ((UChar)0x002D)
#define COMPLEMENT ((UChar)0x005E)
#define COLON ((UChar)0x003A)
#define BACKSLASH ((UChar)0x005C)
#define INTERSECTION ((UChar)0x0026)
#define UPPER_U ((UChar)0x0055)
#define LOWER_U ((UChar)0x0075)
#define OPEN_BRACE ((UChar)123)
#define CLOSE_BRACE ((UChar)125)
#define UPPER_P ((UChar)0x0050)
#define LOWER_P ((UChar)0x0070)
#define UPPER_N ((UChar)78)
#define EQUALS ((UChar)0x003D)
#define UNICODESET_HIGH 0x0110000
#define UNICODESET_LOW 0x000000
#define START_EXTRA 16
#define GROW_EXTRA START_EXTRA
U_NAMESPACE_BEGIN
SymbolTable::~SymbolTable() {}
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(UnicodeSet)
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;
}
#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
static void U_CALLCONV cloneUnicodeString(UHashTok *dst, UHashTok *src) {
dst->pointer = new UnicodeString(*(UnicodeString*)src->pointer);
}
static int8_t U_CALLCONV compareUnicodeString(UHashTok t1, UHashTok t2) {
const UnicodeString &a = *(const UnicodeString*)t1.pointer;
const UnicodeString &b = *(const UnicodeString*)t2.pointer;
return a.compare(b);
}
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();
_dbgct(this);
}
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);
}
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); uprv_free(list);
if (buffer) {
uprv_free(buffer);
}
delete strings;
}
UnicodeSet& UnicodeSet::operator=(const UnicodeSet& o) {
ensureCapacity(o.len);
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;
return *this;
}
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 (*strings != *o.strings) return FALSE;
return TRUE;
}
UnicodeFunctor* UnicodeSet::clone() const {
return new UnicodeSet(*this);
}
int32_t UnicodeSet::hashCode(void) const {
int32_t result = len;
for (int32_t i = 0; i < len; ++i) {
result *= 1000003;
result += list[i];
}
return result;
}
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 + strings->size();
}
UBool UnicodeSet::isEmpty(void) const {
return len == 1 && strings->size() == 0;
}
UBool UnicodeSet::contains(UChar32 c) const {
if (c >= UNICODESET_HIGH) { return FALSE;
}
int32_t i = findCodePoint(c);
return ((i & 1) != 0); }
int32_t UnicodeSet::findCodePoint(UChar32 c) const {
if (c < list[0])
return 0;
if (len >= 2 && c >= list[len-2])
return len-1;
int32_t lo = 0;
int32_t hi = len - 1;
for (;;) {
int32_t i = (lo + hi) >> 1;
if (i == lo) {
break; } else if (c < list[i]) {
hi = i;
} else {
lo = i;
}
}
return hi;
}
UBool UnicodeSet::contains(UChar32 start, UChar32 end) const {
int32_t i = findCodePoint(start);
return ((i & 1) != 0 && end < list[i]);
}
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);
}
}
UBool UnicodeSet::containsAll(const UnicodeSet& c) const {
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;
}
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;
}
UBool UnicodeSet::containsNone(UChar32 start, UChar32 end) const {
int32_t i = findCodePoint(start);
return ((i & 1) == 0 && end < list[i]);
}
UBool UnicodeSet::containsNone(const UnicodeSet& c) const {
int32_t n = c.getRangeCount();
for (int32_t i=0; i<n; ++i) {
if (!containsNone(c.getRangeStart(i), c.getRangeEnd(i))) {
return FALSE;
}
}
if (!strings->containsNone(*c.strings)) return FALSE;
return TRUE;
}
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;
}
UBool UnicodeSet::matchesIndexValue(uint8_t v) const {
int32_t i;
for (i=0; i<getRangeCount(); ++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 (strings->size() != 0) {
for (i=0; i<strings->size(); ++i) {
const UnicodeString& s = *(const UnicodeString*)strings->elementAt(i);
UChar32 c = s.char32At(0);
if ((c & 0xFF) == v) {
return TRUE;
}
}
}
return FALSE;
}
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 (strings->size() != 0) {
int32_t i;
UBool forward = offset < limit;
UChar firstChar = text.charAt(offset);
int32_t highWaterLength = 0;
for (i=0; i<strings->size(); ++i) {
const UnicodeString& trial = *(const UnicodeString*)strings->elementAt(i);
UChar c = trial.charAt(forward ? 0 : trial.length() - 1);
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) {
return U_PARTIAL_MATCH;
}
}
if (matchLen == trial.length()) {
if (matchLen > highWaterLength) {
highWaterLength = matchLen;
}
if (forward && matchLen < highWaterLength) {
break;
}
continue;
}
}
if (highWaterLength != 0) {
offset += forward ? highWaterLength : -highWaterLength;
return U_MATCH;
}
}
return UnicodeFilter::matches(text, offset, limit, incremental);
}
}
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; for (i = 1; i < maxLen; ++i) {
if (text.charAt(start - i) != s.charAt(slen - i)) return 0;
}
}
return maxLen;
}
void UnicodeSet::addMatchSetTo(UnicodeSet& toUnionTo) const {
toUnionTo.addAll(*this);
}
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;
}
}
UChar32 UnicodeSet::charAt(int32_t index) const {
if (index >= 0) {
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;
}
UnicodeSet& UnicodeSet::add(UChar32 start, UChar32 end) {
if (pinCodePoint(start) < pinCodePoint(end)) {
UChar32 range[3] = { start, end+1, UNICODESET_HIGH };
add(range, 2, 0);
} else if (start == end) {
add(start);
}
return *this;
}
#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
UnicodeSet& UnicodeSet::add(UChar32 c) {
int32_t i = findCodePoint(pinCodePoint(c));
if ((i & 1) != 0) return *this;
#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) {
list[i] = c;
if (c == (UNICODESET_HIGH - 1)) {
ensureCapacity(len+1);
list[len++] = UNICODESET_HIGH;
}
if (i > 0 && c == list[i-1]) {
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]) {
list[i-1]++;
}
else {
ensureCapacity(len+2);
UChar32* src = list + len;
UChar32* dst = src + 2;
UChar32* srclimit = list + i;
while (src > srclimit) *(--dst) = *(--src);
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]) {
printf("ERROR: list has been corrupted\n");
exit(1);
}
}
#endif
pat.truncate(0);
return *this;
}
UnicodeSet& UnicodeSet::add(const UnicodeString& s) {
if (s.length() == 0) return *this;
int32_t cp = getSingleCP(s);
if (cp < 0) {
if (!strings->contains((void*) &s)) {
_add(s);
pat.truncate(0);
}
} else {
add((UChar32)cp, (UChar32)cp);
}
return *this;
}
void UnicodeSet::_add(const UnicodeString& s) {
UnicodeString* t = new UnicodeString(s);
UErrorCode ec = U_ZERO_ERROR;
strings->sortedInsert(t, compareUnicodeString, ec);
}
int32_t UnicodeSet::getSingleCP(const UnicodeString& s) {
if (s.length() > 2) return -1;
if (s.length() == 1) return s.charAt(0);
UChar32 cp = s.char32At(0);
if (cp > 0xFFFF) { return cp;
}
return -1;
}
UnicodeSet& UnicodeSet::addAll(const UnicodeString& s) {
UChar32 cp;
for (int32_t i = 0; i < s.length(); i += UTF_CHAR_LENGTH(cp)) {
cp = s.char32At(i);
add(cp, cp);
}
return *this;
}
UnicodeSet& UnicodeSet::retainAll(const UnicodeString& s) {
UnicodeSet set;
set.addAll(s);
retainAll(set);
return *this;
}
UnicodeSet& UnicodeSet::complementAll(const UnicodeString& s) {
UnicodeSet set;
set.addAll(s);
complementAll(set);
return *this;
}
UnicodeSet& UnicodeSet::removeAll(const UnicodeString& s) {
UnicodeSet set;
set.addAll(s);
removeAll(set);
return *this;
}
UnicodeSet* U_EXPORT2 UnicodeSet::createFrom(const UnicodeString& s) {
UnicodeSet *set = new UnicodeSet();
set->add(s);
return set;
}
UnicodeSet* U_EXPORT2 UnicodeSet::createFromAll(const UnicodeString& s) {
UnicodeSet *set = new UnicodeSet();
set->addAll(s);
return 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::remove(UChar32 start, UChar32 end) {
if (pinCodePoint(start) <= pinCodePoint(end)) {
UChar32 range[3] = { start, end+1, UNICODESET_HIGH };
retain(range, 2, 2);
}
return *this;
}
UnicodeSet& UnicodeSet::remove(UChar32 c) {
return remove(c, c);
}
UnicodeSet& UnicodeSet::remove(const UnicodeString& s) {
if (s.length() == 0) return *this;
int32_t cp = getSingleCP(s);
if (cp < 0) {
strings->removeElement((void*) &s);
pat.truncate(0);
} else {
remove((UChar32)cp, (UChar32)cp);
}
return *this;
}
UnicodeSet& UnicodeSet::complement(UChar32 start, UChar32 end) {
if (pinCodePoint(start) <= pinCodePoint(end)) {
UChar32 range[3] = { start, end+1, UNICODESET_HIGH };
exclusiveOr(range, 2, 0);
}
pat.truncate(0);
return *this;
}
UnicodeSet& UnicodeSet::complement(UChar32 c) {
return complement(c, c);
}
UnicodeSet& UnicodeSet::complement(void) {
if (list[0] == UNICODESET_LOW) {
ensureBufferCapacity(len-1);
uprv_memcpy(buffer, list + 1, (len-1)*sizeof(UChar32));
--len;
} else {
ensureBufferCapacity(len+1);
uprv_memcpy(buffer + 1, list, len*sizeof(UChar32));
buffer[0] = UNICODESET_LOW;
++len;
}
swapBuffers();
pat.truncate(0);
return *this;
}
UnicodeSet& UnicodeSet::complement(const UnicodeString& s) {
if (s.length() == 0) return *this;
int32_t cp = getSingleCP(s);
if (cp < 0) {
if (strings->contains((void*) &s)) {
strings->removeElement((void*) &s);
} else {
_add(s);
}
pat.truncate(0);
} else {
complement((UChar32)cp, (UChar32)cp);
}
return *this;
}
UnicodeSet& UnicodeSet::addAll(const UnicodeSet& c) {
add(c.list, c.len, 0);
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);
}
}
return *this;
}
UnicodeSet& UnicodeSet::retainAll(const UnicodeSet& c) {
retain(c.list, c.len, 0);
strings->retainAll(*c.strings);
return *this;
}
UnicodeSet& UnicodeSet::removeAll(const UnicodeSet& c) {
retain(c.list, c.len, 2);
strings->removeAll(*c.strings);
return *this;
}
UnicodeSet& UnicodeSet::complementAll(const UnicodeSet& c) {
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);
}
}
return *this;
}
UnicodeSet& UnicodeSet::clear(void) {
list[0] = UNICODESET_HIGH;
len = 1;
pat.truncate(0);
strings->removeAllElements();
return *this;
}
int32_t UnicodeSet::getRangeCount() const {
return len/2;
}
UChar32 UnicodeSet::getRangeStart(int32_t index) const {
return list[index*2];
}
UChar32 UnicodeSet::getRangeEnd(int32_t index) const {
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);
}
UnicodeSet& UnicodeSet::compact() {
if (len != capacity) {
capacity = len;
UChar32* temp = (UChar32*) uprv_malloc(sizeof(UChar32) * capacity);
uprv_memcpy(temp, list, len*sizeof(UChar32));
uprv_free(list);
list = temp;
}
uprv_free(buffer);
buffer = NULL;
return *this;
}
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;
}
length=this->len-1; if (length==0) {
if (destCapacity>0) {
*dest=0;
} else {
ec=U_BUFFER_OVERFLOW_ERROR;
}
return 1;
}
if (this->list[length-1]<=0xffff) {
bmpLength=length;
} else if (this->list[0]>=0x10000) {
bmpLength=0;
length*=2;
} else {
for (bmpLength=0; bmpLength<length && this->list[bmpLength]<=0xffff; ++bmpLength) {}
length=bmpLength+2*(length-bmpLength);
}
if (length>0x7fff) {
ec=U_INDEX_OUTOFBOUNDS_ERROR;
return 0;
}
destLength=length+((length>bmpLength)?2:1);
if (destLength<=destCapacity) {
const UChar32 *p;
int32_t i;
*dest=(uint16_t)length;
if (length>bmpLength) {
*dest|=0x8000;
*++dest=(uint16_t)bmpLength;
}
++dest;
p=this->list;
for (i=0; i<bmpLength; ++i) {
*dest++=(uint16_t)*p++;
}
for (; i<length; i+=2) {
*dest++=(uint16_t)(*p>>16);
*dest++=(uint16_t)*p++;
}
} else {
ec=U_BUFFER_OVERFLOW_ERROR;
}
return destLength;
}
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;
}
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) {
uprv_free(buffer);
}
bufferCapacity = newLen + GROW_EXTRA;
buffer = (UChar32*) uprv_malloc(sizeof(UChar32) * bufferCapacity);
}
void UnicodeSet::swapBuffers(void) {
UChar32* temp = list;
list = buffer;
buffer = temp;
int32_t c = capacity;
capacity = bufferCapacity;
bufferCapacity = c;
}
static inline UChar32 max(UChar32 a, UChar32 b) {
return (a > b) ? a : b;
}
void UnicodeSet::exclusiveOr(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;
if (polarity == 1 || polarity == 2) {
b = UNICODESET_LOW;
if (other[j] == UNICODESET_LOW) { ++j;
b = other[j];
}
} else {
b = other[j++];
}
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) { a = list[i++];
b = other[j++];
} else { buffer[k++] = UNICODESET_HIGH;
len = k;
break;
}
}
swapBuffers();
pat.truncate(0);
}
void UnicodeSet::add(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++];
for (;;) {
switch (polarity) {
case 0: if (a < b) { if (k > 0 && a <= buffer[k-1]) {
a = max(list[i], buffer[--k]);
} else {
buffer[k++] = a;
a = list[i];
}
i++; polarity ^= 1;
} else if (b < a) { if (k > 0 && b <= buffer[k-1]) {
b = max(other[j], buffer[--k]);
} else {
buffer[k++] = b;
b = other[j];
}
j++;
polarity ^= 2;
} else { if (a == UNICODESET_HIGH) goto loop_end;
if (k > 0 && a <= buffer[k-1]) {
a = max(list[i], buffer[--k]);
} else {
buffer[k++] = a;
a = list[i];
}
i++;
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
case 3: if (b <= a) { if (a == UNICODESET_HIGH) goto loop_end;
buffer[k++] = a;
} else { if (b == UNICODESET_HIGH) goto loop_end;
buffer[k++] = b;
}
a = list[i++];
polarity ^= 1; b = other[j++];
polarity ^= 2;
break;
case 1: if (a < b) { buffer[k++] = a; a = list[i++]; polarity ^= 1;
} else if (b < a) { b = other[j++];
polarity ^= 2;
} else { if (a == UNICODESET_HIGH) goto loop_end;
a = list[i++];
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
case 2: if (b < a) { buffer[k++] = b;
b = other[j++];
polarity ^= 2;
} else if (a < b) { a = list[i++];
polarity ^= 1;
} else { if (a == UNICODESET_HIGH) goto loop_end;
a = list[i++];
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
}
}
loop_end:
buffer[k++] = UNICODESET_HIGH; len = k;
swapBuffers();
pat.truncate(0);
}
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++];
for (;;) {
switch (polarity) {
case 0: if (a < b) { a = list[i++];
polarity ^= 1;
} else if (b < a) { b = other[j++];
polarity ^= 2;
} else { if (a == UNICODESET_HIGH) goto loop_end;
buffer[k++] = a;
a = list[i++];
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
case 3: if (a < b) { buffer[k++] = a;
a = list[i++];
polarity ^= 1;
} else if (b < a) { buffer[k++] = b;
b = other[j++];
polarity ^= 2;
} else { if (a == UNICODESET_HIGH) goto loop_end;
buffer[k++] = a;
a = list[i++];
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
case 1: if (a < b) { a = list[i++];
polarity ^= 1;
} else if (b < a) { buffer[k++] = b;
b = other[j++];
polarity ^= 2;
} else { if (a == UNICODESET_HIGH) goto loop_end;
a = list[i++];
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
case 2: if (b < a) { b = other[j++];
polarity ^= 2;
} else if (a < b) { buffer[k++] = a;
a = list[i++];
polarity ^= 1;
} else { if (a == UNICODESET_HIGH) goto loop_end;
a = list[i++];
polarity ^= 1;
b = other[j++];
polarity ^= 2;
}
break;
}
}
loop_end:
buffer[k++] = UNICODESET_HIGH; len = k;
swapBuffers();
pat.truncate(0);
}
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);
}
}
void UnicodeSet::_appendToPat(UnicodeString& buf, UChar32 c, UBool
escapeUnprintable) {
if (escapeUnprintable && ICU_Utility::isUnprintable(c)) {
if (ICU_Utility::escapeUnprintable(buf, c)) {
return;
}
}
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:
if (uprv_isRuleWhiteSpace(c)) {
buf.append(BACKSLASH);
}
break;
}
buf.append(c);
}
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 ((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);
}
UnicodeString& UnicodeSet::toPattern(UnicodeString& result,
UBool escapeUnprintable) const {
result.truncate(0);
return _toPattern(result, escapeUnprintable);
}
UnicodeString& UnicodeSet::_generatePattern(UnicodeString& result,
UBool escapeUnprintable) const {
result.append(SET_OPEN);
int32_t count = getRangeCount();
if (count > 1 &&
getRangeStart(0) == MIN_VALUE &&
getRangeEnd(count-1) == MAX_VALUE) {
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) {
if ((start+1) != end) {
result.append(HYPHEN);
}
_appendToPat(result, end, escapeUnprintable);
}
}
}
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(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);
}
U_NAMESPACE_END