0N/A

0N/Apackage sun.text.normalizer;

0N/A

0N/Aimport java.text.ParsePosition;

1091N/Aimport java.util.Iterator;

0N/Aimport java.util.TreeSet;

0N/A

0N/Apublic class UnicodeSet implements UnicodeMatcher {

0N/A

0N/A private static final int LOW = 0x000000; // LOW <= all valid values. ZERO for codepoints

0N/A private static final int HIGH = 0x110000; // HIGH > all valid values. 10000 for code units.

0N/A // 110000 for codepoints

0N/A

0N/A /**

0N/A public static final int MIN_VALUE = LOW;

0N/A

0N/A /**

0N/A public static final int MAX_VALUE = HIGH - 1;

0N/A

0N/A private int len; // length used; list may be longer to minimize reallocs

0N/A private int[] list; // MUST be terminated with HIGH

0N/A private int[] rangeList; // internal buffer

0N/A private int[] buffer; // internal buffer

0N/A

0N/A // NOTE: normally the field should be of type SortedSet; but that is missing a public clone!!

0N/A // is not private so that UnicodeSetIterator can get access

0N/A TreeSet strings = new TreeSet();

0N/A

0N/A /**

0N/A private String pat = null;

0N/A

0N/A private static final int START_EXTRA = 16; // initial storage. Must be >= 0

0N/A private static final int GROW_EXTRA = START_EXTRA; // extra amount for growth. Must be >= 0

0N/A

0N/A /**

1091N/A private static UnicodeSet INCLUSIONS[] = null;

0N/A

0N/A //----------------------------------------------------------------

0N/A // Public API

0N/A //----------------------------------------------------------------

0N/A

0N/A /**

0N/A public UnicodeSet() {

0N/A list = new int[1 + START_EXTRA];

0N/A list[len++] = HIGH;

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet(int start, int end) {

0N/A this();

0N/A complement(start, end);

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet(String pattern) {

0N/A this();

0N/A applyPattern(pattern, null, null, IGNORE_SPACE);

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet set(UnicodeSet other) {

0N/A list = (int[]) other.list.clone();

0N/A len = other.len;

0N/A pat = other.pat;

0N/A strings = (TreeSet)other.strings.clone();

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public final UnicodeSet applyPattern(String pattern) {

0N/A return applyPattern(pattern, null, null, IGNORE_SPACE);

0N/A }

0N/A

0N/A /**

0N/A private static void _appendToPat(StringBuffer buf, String s, boolean escapeUnprintable) {

0N/A for (int i = 0; i < s.length(); i += UTF16.getCharCount(i)) {

0N/A _appendToPat(buf, UTF16.charAt(s, i), escapeUnprintable);

0N/A }

0N/A }

0N/A

0N/A /**

0N/A private static void _appendToPat(StringBuffer buf, int c, boolean escapeUnprintable) {

0N/A if (escapeUnprintable && Utility.isUnprintable(c)) {

0N/A // Use hex escape notation (<backslash>uxxxx or <backslash>Uxxxxxxxx) for anything

0N/A // unprintable

0N/A if (Utility.escapeUnprintable(buf, c)) {

0N/A return;

0N/A }

0N/A }

0N/A // Okay to let ':' pass through

0N/A switch (c) {

0N/A case '[': // SET_OPEN:

0N/A case ']': // SET_CLOSE:

0N/A case '-': // HYPHEN:

0N/A case '^': // COMPLEMENT:

0N/A case '&': // INTERSECTION:

0N/A case '\\': //BACKSLASH:

0N/A case '{':

0N/A case '}':

0N/A case '$':

0N/A case ':':

0N/A buf.append('\\');

0N/A break;

0N/A default:

0N/A // Escape whitespace

0N/A if (UCharacterProperty.isRuleWhiteSpace(c)) {

0N/A buf.append('\\');

0N/A }

0N/A break;

0N/A }

0N/A UTF16.append(buf, c);

0N/A }

0N/A

0N/A /**

0N/A private StringBuffer _toPattern(StringBuffer result,

0N/A boolean escapeUnprintable) {

0N/A if (pat != null) {

0N/A int i;

0N/A int backslashCount = 0;

0N/A for (i=0; i<pat.length(); ) {

0N/A int c = UTF16.charAt(pat, i);

0N/A i += UTF16.getCharCount(c);

0N/A if (escapeUnprintable && Utility.isUnprintable(c)) {

0N/A // If the unprintable character is preceded by an odd

0N/A // number of backslashes, then it has been escaped.

0N/A // Before unescaping it, we delete the final

0N/A // backslash.

0N/A if ((backslashCount % 2) == 1) {

0N/A result.setLength(result.length() - 1);

0N/A }

0N/A Utility.escapeUnprintable(result, c);

0N/A backslashCount = 0;

0N/A } else {

0N/A UTF16.append(result, c);

0N/A if (c == '\\') {

0N/A ++backslashCount;

0N/A } else {

0N/A backslashCount = 0;

0N/A }

0N/A }

0N/A }

0N/A return result;

0N/A }

0N/A

1091N/A return _generatePattern(result, escapeUnprintable, true);

0N/A }

0N/A

0N/A /**

0N/A public StringBuffer _generatePattern(StringBuffer result,

1091N/A boolean escapeUnprintable, boolean includeStrings) {

0N/A result.append('[');

0N/A

0N/A int count = getRangeCount();

0N/A

0N/A // If the set contains at least 2 intervals and includes both

0N/A // MIN_VALUE and MAX_VALUE, then the inverse representation will

0N/A // be more economical.

0N/A if (count > 1 &&

0N/A getRangeStart(0) == MIN_VALUE &&

0N/A getRangeEnd(count-1) == MAX_VALUE) {

0N/A

0N/A // Emit the inverse

0N/A result.append('^');

0N/A

0N/A for (int i = 1; i < count; ++i) {

0N/A int start = getRangeEnd(i-1)+1;

0N/A int end = getRangeStart(i)-1;

0N/A _appendToPat(result, start, escapeUnprintable);

0N/A if (start != end) {

0N/A if ((start+1) != end) {

0N/A result.append('-');

0N/A }

0N/A _appendToPat(result, end, escapeUnprintable);

0N/A }

0N/A }

0N/A }

0N/A

0N/A // Default; emit the ranges as pairs

0N/A else {

0N/A for (int i = 0; i < count; ++i) {

0N/A int start = getRangeStart(i);

0N/A int end = getRangeEnd(i);

0N/A _appendToPat(result, start, escapeUnprintable);

0N/A if (start != end) {

0N/A if ((start+1) != end) {

0N/A result.append('-');

0N/A }

0N/A _appendToPat(result, end, escapeUnprintable);

0N/A }

0N/A }

0N/A }

0N/A

1091N/A if (includeStrings && strings.size() > 0) {

0N/A Iterator it = strings.iterator();

0N/A while (it.hasNext()) {

0N/A result.append('{');

0N/A _appendToPat(result, (String) it.next(), escapeUnprintable);

0N/A result.append('}');

0N/A }

0N/A }

0N/A return result.append(']');

0N/A }

0N/A

1091N/A // for internal use, after checkFrozen has been called

1091N/A private UnicodeSet add_unchecked(int start, int end) {

0N/A if (start < MIN_VALUE || start > MAX_VALUE) {

0N/A throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));

0N/A }

0N/A if (end < MIN_VALUE || end > MAX_VALUE) {

0N/A throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));

0N/A }

0N/A if (start < end) {

0N/A add(range(start, end), 2, 0);

0N/A } else if (start == end) {

0N/A add(start);

0N/A }

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public final UnicodeSet add(int c) {

1091N/A return add_unchecked(c);

1091N/A }

1091N/A

1091N/A // for internal use only, after checkFrozen has been called

1091N/A private final UnicodeSet add_unchecked(int c) {

0N/A if (c < MIN_VALUE || c > MAX_VALUE) {

0N/A throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(c, 6));

0N/A }

0N/A

0N/A // find smallest i such that c < list[i]

0N/A // if odd, then it is IN the set

0N/A // if even, then it is OUT of the set

0N/A int i = findCodePoint(c);

0N/A

0N/A // already in set?

0N/A if ((i & 1) != 0) return this;

0N/A

0N/A // HIGH is 0x110000

0N/A // assert(list[len-1] == HIGH);

0N/A

0N/A // empty = [HIGH]

0N/A // [start_0, limit_0, start_1, limit_1, HIGH]

0N/A

0N/A // [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH]

0N/A // ^

0N/A // list[i]

0N/A

0N/A // i == 0 means c is before the first range

0N/A

0N/A if (c == list[i]-1) {

0N/A // c is before start of next range

0N/A list[i] = c;

0N/A // if we touched the HIGH mark, then add a new one

0N/A if (c == MAX_VALUE) {

0N/A ensureCapacity(len+1);

0N/A list[len++] = HIGH;

0N/A }

0N/A if (i > 0 && c == list[i-1]) {

0N/A // collapse adjacent ranges

0N/A

0N/A // [..., start_k-1, c, c, limit_k, ..., HIGH]

0N/A // ^

0N/A // list[i]

0N/A System.arraycopy(list, i+1, list, i-1, len-i-1);

0N/A len -= 2;

0N/A }

0N/A }

0N/A

0N/A else if (i > 0 && c == list[i-1]) {

0N/A // c is after end of prior range

0N/A list[i-1]++;

0N/A // no need to chcek for collapse here

0N/A }

0N/A

0N/A else {

0N/A // At this point we know the new char is not adjacent to

0N/A // any existing ranges, and it is not 10FFFF.

0N/A

0N/A

0N/A // [..., start_k-1, limit_k-1, start_k, limit_k, ..., HIGH]

0N/A // ^

0N/A // list[i]

0N/A

0N/A // [..., start_k-1, limit_k-1, c, c+1, start_k, limit_k, ..., HIGH]

0N/A // ^

0N/A // list[i]

0N/A

0N/A // Don't use ensureCapacity() to save on copying.

0N/A // NOTE: This has no measurable impact on performance,

0N/A // but it might help in some usage patterns.

0N/A if (len+2 > list.length) {

0N/A int[] temp = new int[len + 2 + GROW_EXTRA];

0N/A if (i != 0) System.arraycopy(list, 0, temp, 0, i);

0N/A System.arraycopy(list, i, temp, i+2, len-i);

0N/A list = temp;

0N/A } else {

0N/A System.arraycopy(list, i, list, i+2, len-i);

0N/A }

0N/A

0N/A list[i] = c;

0N/A list[i+1] = c+1;

0N/A len += 2;

0N/A }

0N/A

0N/A pat = null;

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public final UnicodeSet add(String s) {

0N/A int cp = getSingleCP(s);

0N/A if (cp < 0) {

0N/A strings.add(s);

0N/A pat = null;

0N/A } else {

1091N/A add_unchecked(cp, cp);

0N/A }

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A private static int getSingleCP(String s) {

0N/A if (s.length() < 1) {

0N/A throw new IllegalArgumentException("Can't use zero-length strings in UnicodeSet");

0N/A }

0N/A if (s.length() > 2) return -1;

0N/A if (s.length() == 1) return s.charAt(0);

0N/A

0N/A // at this point, len = 2

0N/A int cp = UTF16.charAt(s, 0);

0N/A if (cp > 0xFFFF) { // is surrogate pair

0N/A return cp;

0N/A }

0N/A return -1;

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet complement(int start, int end) {

0N/A if (start < MIN_VALUE || start > MAX_VALUE) {

0N/A throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));

0N/A }

0N/A if (end < MIN_VALUE || end > MAX_VALUE) {

0N/A throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));

0N/A }

0N/A if (start <= end) {

0N/A xor(range(start, end), 2, 0);

0N/A }

0N/A pat = null;

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet complement() {

0N/A if (list[0] == LOW) {

0N/A System.arraycopy(list, 1, list, 0, len-1);

0N/A --len;

0N/A } else {

0N/A ensureCapacity(len+1);

0N/A System.arraycopy(list, 0, list, 1, len);

0N/A list[0] = LOW;

0N/A ++len;

0N/A }

0N/A pat = null;

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public boolean contains(int c) {

0N/A if (c < MIN_VALUE || c > MAX_VALUE) {

0N/A throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(c, 6));

0N/A }

0N/A

0N/A /*

0N/A

0N/A int i = findCodePoint(c);

0N/A

0N/A return ((i & 1) != 0); // return true if odd

0N/A }

0N/A

0N/A /**

0N/A private final int findCodePoint(int c) {

0N/A /* Examples:

0N/A

0N/A // Return the smallest i such that c < list[i]. Assume

0N/A // list[len - 1] == HIGH and that c is legal (0..HIGH-1).

0N/A if (c < list[0]) return 0;

0N/A // High runner test. c is often after the last range, so an

0N/A // initial check for this condition pays off.

0N/A if (len >= 2 && c >= list[len-2]) return len-1;

0N/A int lo = 0;

0N/A int hi = len - 1;

0N/A // invariant: c >= list[lo]

0N/A // invariant: c < list[hi]

0N/A for (;;) {

0N/A int i = (lo + hi) >>> 1;

0N/A if (i == lo) return hi;

0N/A if (c < list[i]) {

0N/A hi = i;

0N/A } else {

0N/A lo = i;

0N/A }

0N/A }

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet addAll(UnicodeSet c) {

0N/A add(c.list, c.len, 0);

0N/A strings.addAll(c.strings);

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet retainAll(UnicodeSet c) {

0N/A retain(c.list, c.len, 0);

0N/A strings.retainAll(c.strings);

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet removeAll(UnicodeSet c) {

0N/A retain(c.list, c.len, 2);

0N/A strings.removeAll(c.strings);

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public UnicodeSet clear() {

0N/A list[0] = HIGH;

0N/A len = 1;

0N/A pat = null;

0N/A strings.clear();

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A public int getRangeCount() {

0N/A return len/2;

0N/A }

0N/A

0N/A /**

0N/A public int getRangeStart(int index) {

0N/A return list[index*2];

0N/A }

0N/A

0N/A /**

0N/A public int getRangeEnd(int index) {

0N/A return (list[index*2 + 1] - 1);

0N/A }

0N/A

0N/A //----------------------------------------------------------------

0N/A // Implementation: Pattern parsing

0N/A //----------------------------------------------------------------

0N/A

0N/A /**

0N/A UnicodeSet applyPattern(String pattern,

0N/A ParsePosition pos,

0N/A SymbolTable symbols,

0N/A int options) {

0N/A

0N/A // Need to build the pattern in a temporary string because

0N/A // _applyPattern calls add() etc., which set pat to empty.

0N/A boolean parsePositionWasNull = pos == null;

0N/A if (parsePositionWasNull) {

0N/A pos = new ParsePosition(0);

0N/A }

0N/A

0N/A StringBuffer rebuiltPat = new StringBuffer();

0N/A RuleCharacterIterator chars =

0N/A new RuleCharacterIterator(pattern, symbols, pos);

0N/A applyPattern(chars, symbols, rebuiltPat, options);

0N/A if (chars.inVariable()) {

0N/A syntaxError(chars, "Extra chars in variable value");

0N/A }

0N/A pat = rebuiltPat.toString();

0N/A if (parsePositionWasNull) {

0N/A int i = pos.getIndex();

0N/A

0N/A // Skip over trailing whitespace

0N/A if ((options & IGNORE_SPACE) != 0) {

0N/A i = Utility.skipWhitespace(pattern, i);

0N/A }

0N/A

0N/A if (i != pattern.length()) {

0N/A throw new IllegalArgumentException("Parse of \"" + pattern +

0N/A "\" failed at " + i);

0N/A }

0N/A }

0N/A return this;

0N/A }

0N/A

0N/A /**

0N/A void applyPattern(RuleCharacterIterator chars, SymbolTable symbols,

0N/A StringBuffer rebuiltPat, int options) {

0N/A // Syntax characters: [ ] ^ - & { }

0N/A

0N/A // Recognized special forms for chars, sets: c-c s-s s&s

0N/A

0N/A int opts = RuleCharacterIterator.PARSE_VARIABLES |

0N/A RuleCharacterIterator.PARSE_ESCAPES;

0N/A if ((options & IGNORE_SPACE) != 0) {

0N/A opts |= RuleCharacterIterator.SKIP_WHITESPACE;

0N/A }

0N/A

1091N/A StringBuffer patBuf = new StringBuffer(), buf = null;

0N/A boolean usePat = false;

0N/A UnicodeSet scratch = null;

0N/A Object backup = null;

0N/A

0N/A // mode: 0=before [, 1=between [...], 2=after ]

0N/A // lastItem: 0=none, 1=char, 2=set

0N/A int lastItem = 0, lastChar = 0, mode = 0;

0N/A char op = 0;

0N/A

0N/A boolean invert = false;

0N/A

0N/A clear();

0N/A

0N/A while (mode != 2 && !chars.atEnd()) {

0N/A if (false) {

0N/A // Debugging assertion

0N/A if (!((lastItem == 0 && op == 0) ||

0N/A (lastItem == 1 && (op == 0 || op == '-')) ||

0N/A (lastItem == 2 && (op == 0 || op == '-' || op == '&')))) {

0N/A throw new IllegalArgumentException();

0N/A }

0N/A }

0N/A

0N/A int c = 0;

0N/A boolean literal = false;

0N/A UnicodeSet nested = null;

0N/A

0N/A // -------- Check for property pattern

0N/A

0N/A // setMode: 0=none, 1=unicodeset, 2=propertypat, 3=preparsed

0N/A int setMode = 0;

0N/A if (resemblesPropertyPattern(chars, opts)) {

0N/A setMode = 2;

0N/A }

0N/A

0N/A // -------- Parse '[' of opening delimiter OR nested set.

0N/A // If there is a nested set, use `setMode' to define how

0N/A // the set should be parsed. If the '[' is part of the

0N/A // opening delimiter for this pattern, parse special

0N/A // strings "[", "[^", "[-", and "[^-". Check for stand-in

0N/A // characters representing a nested set in the symbol

0N/A // table.

0N/A

0N/A else {

0N/A // Prepare to backup if necessary

0N/A backup = chars.getPos(backup);

0N/A c = chars.next(opts);

0N/A literal = chars.isEscaped();

0N/A

0N/A if (c == '[' && !literal) {

0N/A if (mode == 1) {

0N/A chars.setPos(backup); // backup

0N/A setMode = 1;

0N/A } else {

0N/A // Handle opening '[' delimiter

0N/A mode = 1;

1091N/A patBuf.append('[');

0N/A backup = chars.getPos(backup); // prepare to backup

0N/A c = chars.next(opts);

0N/A literal = chars.isEscaped();

0N/A if (c == '^' && !literal) {

0N/A invert = true;

1091N/A patBuf.append('^');

0N/A backup = chars.getPos(backup); // prepare to backup

0N/A c = chars.next(opts);

0N/A literal = chars.isEscaped();

0N/A }

0N/A // Fall through to handle special leading '-';

0N/A // otherwise restart loop for nested [], \p{}, etc.

0N/A if (c == '-') {

0N/A literal = true;

0N/A // Fall through to handle literal '-' below

0N/A } else {

0N/A chars.setPos(backup); // backup

0N/A continue;

0N/A }

0N/A }

0N/A } else if (symbols != null) {

0N/A UnicodeMatcher m = symbols.lookupMatcher(c); // may be null

0N/A if (m != null) {

0N/A try {

0N/A nested = (UnicodeSet) m;

0N/A setMode = 3;

0N/A } catch (ClassCastException e) {

0N/A syntaxError(chars, "Syntax error");

0N/A }

0N/A }

0N/A }

0N/A }

0N/A

0N/A // -------- Handle a nested set. This either is inline in

0N/A // the pattern or represented by a stand-in that has

0N/A // previously been parsed and was looked up in the symbol

0N/A // table.

0N/A

0N/A if (setMode != 0) {

0N/A if (lastItem == 1) {

0N/A if (op != 0) {

0N/A syntaxError(chars, "Char expected after operator");

0N/A }

1091N/A add_unchecked(lastChar, lastChar);

1091N/A _appendToPat(patBuf, lastChar, false);

0N/A lastItem = op = 0;

0N/A }

0N/A

0N/A if (op == '-' || op == '&') {

1091N/A patBuf.append(op);

0N/A }

0N/A

0N/A if (nested == null) {

0N/A if (scratch == null) scratch = new UnicodeSet();

0N/A nested = scratch;

0N/A }

0N/A switch (setMode) {

0N/A case 1:

1091N/A nested.applyPattern(chars, symbols, patBuf, options);

0N/A break;

0N/A case 2:

0N/A chars.skipIgnored(opts);

1091N/A nested.applyPropertyPattern(chars, patBuf, symbols);

0N/A break;

0N/A case 3: // `nested' already parsed

1091N/A nested._toPattern(patBuf, false);

0N/A break;

0N/A }

0N/A

0N/A usePat = true;

0N/A

0N/A if (mode == 0) {

0N/A // Entire pattern is a category; leave parse loop

0N/A set(nested);

0N/A mode = 2;

0N/A break;

0N/A }

0N/A

0N/A switch (op) {

0N/A case '-':

0N/A removeAll(nested);

0N/A break;

0N/A case '&':

0N/A retainAll(nested);

0N/A break;

0N/A case 0:

0N/A addAll(nested);

0N/A break;

0N/A }

0N/A

0N/A op = 0;

0N/A lastItem = 2;

0N/A

0N/A continue;

0N/A }

0N/A

0N/A if (mode == 0) {

0N/A syntaxError(chars, "Missing '['");

0N/A }

0N/A

0N/A // -------- Parse special (syntax) characters. If the

0N/A // current character is not special, or if it is escaped,

0N/A // then fall through and handle it below.

0N/A

0N/A if (!literal) {

0N/A switch (c) {

0N/A case ']':

0N/A if (lastItem == 1) {

1091N/A add_unchecked(lastChar, lastChar);

1091N/A _appendToPat(patBuf, lastChar, false);

0N/A }

0N/A // Treat final trailing '-' as a literal

0N/A if (op == '-') {

1091N/A add_unchecked(op, op);

1091N/A patBuf.append(op);

0N/A } else if (op == '&') {

0N/A syntaxError(chars, "Trailing '&'");

0N/A }

1091N/A patBuf.append(']');

0N/A mode = 2;

0N/A continue;

0N/A case '-':

0N/A if (op == 0) {

0N/A if (lastItem != 0) {

0N/A op = (char) c;

0N/A continue;

0N/A } else {

0N/A // Treat final trailing '-' as a literal

1091N/A add_unchecked(c, c);

0N/A c = chars.next(opts);

0N/A literal = chars.isEscaped();

0N/A if (c == ']' && !literal) {

1091N/A patBuf.append("-]");

0N/A mode = 2;

0N/A continue;

0N/A }

0N/A }

0N/A }

0N/A syntaxError(chars, "'-' not after char or set");

0N/A case '&':

0N/A if (lastItem == 2 && op == 0) {

0N/A op = (char) c;

0N/A continue;

0N/A }

0N/A syntaxError(chars, "'&' not after set");

0N/A case '^':

0N/A syntaxError(chars, "'^' not after '['");

0N/A case '{':

0N/A if (op != 0) {

0N/A syntaxError(chars, "Missing operand after operator");

0N/A }

0N/A if (lastItem == 1) {

1091N/A add_unchecked(lastChar, lastChar);

1091N/A _appendToPat(patBuf, lastChar, false);

0N/A }

0N/A lastItem = 0;

0N/A if (buf == null) {

0N/A buf = new StringBuffer();

0N/A } else {

0N/A buf.setLength(0);

0N/A }

0N/A boolean ok = false;

0N/A while (!chars.atEnd()) {

0N/A c = chars.next(opts);

0N/A literal = chars.isEscaped();

0N/A if (c == '}' && !literal) {

0N/A ok = true;

0N/A break;

0N/A }

0N/A UTF16.append(buf, c);

0N/A }

0N/A if (buf.length() < 1 || !ok) {

0N/A syntaxError(chars, "Invalid multicharacter string");

0N/A }

0N/A // We have new string. Add it to set and continue;

0N/A // we don't need to drop through to the further

0N/A // processing

0N/A add(buf.toString());

1091N/A patBuf.append('{');

1091N/A _appendToPat(patBuf, buf.toString(), false);

1091N/A patBuf.append('}');

0N/A continue;

0N/A case SymbolTable.SYMBOL_REF:

0N/A // symbols nosymbols

0N/A // [a-$] error error (ambiguous)

0N/A // [a$] anchor anchor

0N/A // [a-$x] var "x"* literal '$'

0N/A // [a-$.] error literal '$'

0N/A // *We won't get here in the case of var "x"

0N/A backup = chars.getPos(backup);

0N/A c = chars.next(opts);

0N/A literal = chars.isEscaped();

0N/A boolean anchor = (c == ']' && !literal);

0N/A if (symbols == null && !anchor) {

0N/A c = SymbolTable.SYMBOL_REF;

0N/A chars.setPos(backup);

0N/A break; // literal '$'

0N/A }

0N/A if (anchor && op == 0) {

0N/A if (lastItem == 1) {

1091N/A add_unchecked(lastChar, lastChar);

1091N/A _appendToPat(patBuf, lastChar, false);

0N/A }

1091N/A add_unchecked(UnicodeMatcher.ETHER);

0N/A usePat = true;

1091N/A patBuf.append(SymbolTable.SYMBOL_REF).append(']');

0N/A mode = 2;

0N/A continue;

0N/A }

0N/A syntaxError(chars, "Unquoted '$'");

0N/A default:

0N/A break;

0N/A }

0N/A }

0N/A

0N/A // -------- Parse literal characters. This includes both

0N/A // escaped chars ("\u4E01") and non-syntax characters

0N/A // ("a").

0N/A

0N/A switch (lastItem) {

0N/A case 0:

0N/A lastItem = 1;

0N/A lastChar = c;

0N/A break;

0N/A case 1:

0N/A if (op == '-') {

0N/A if (lastChar >= c) {

0N/A // Don't allow redundant (a-a) or empty (b-a) ranges;

0N/A // these are most likely typos.

0N/A syntaxError(chars, "Invalid range");

0N/A }

1091N/A add_unchecked(lastChar, c);

1091N/A _appendToPat(patBuf, lastChar, false);

1091N/A patBuf.append(op);

1091N/A _appendToPat(patBuf, c, false);

0N/A lastItem = op = 0;

0N/A } else {

1091N/A add_unchecked(lastChar, lastChar);

1091N/A _appendToPat(patBuf, lastChar, false);

0N/A lastChar = c;

0N/A }

0N/A break;

0N/A case 2:

0N/A if (op != 0) {

0N/A syntaxError(chars, "Set expected after operator");

0N/A }

0N/A lastChar = c;

0N/A lastItem = 1;

0N/A break;

0N/A }

0N/A }

0N/A

0N/A if (mode != 2) {

0N/A syntaxError(chars, "Missing ']'");

0N/A }

0N/A

0N/A chars.skipIgnored(opts);

0N/A

0N/A if (invert) {

0N/A complement();

0N/A }

0N/A

0N/A // Use the rebuilt pattern (pat) only if necessary. Prefer the

0N/A // generated pattern.

0N/A if (usePat) {

1091N/A rebuiltPat.append(patBuf.toString());

0N/A } else {

1091N/A _generatePattern(rebuiltPat, false, true);

0N/A }

0N/A }

0N/A

0N/A private static void syntaxError(RuleCharacterIterator chars, String msg) {

0N/A throw new IllegalArgumentException("Error: " + msg + " at \"" +

0N/A Utility.escape(chars.toString()) +

0N/A '"');

0N/A }

0N/A

0N/A //----------------------------------------------------------------

0N/A // Implementation: Utility methods

0N/A //----------------------------------------------------------------

0N/A

0N/A private void ensureCapacity(int newLen) {

0N/A if (newLen <= list.length) return;

0N/A int[] temp = new int[newLen + GROW_EXTRA];

0N/A System.arraycopy(list, 0, temp, 0, len);

0N/A list = temp;

0N/A }

0N/A

0N/A private void ensureBufferCapacity(int newLen) {

0N/A if (buffer != null && newLen <= buffer.length) return;

0N/A buffer = new int[newLen + GROW_EXTRA];

0N/A }

0N/A

0N/A /**

0N/A private int[] range(int start, int end) {

0N/A if (rangeList == null) {

0N/A rangeList = new int[] { start, end+1, HIGH };

0N/A } else {

0N/A rangeList[0] = start;

0N/A rangeList[1] = end+1;

0N/A }

0N/A return rangeList;

0N/A }

0N/A

0N/A //----------------------------------------------------------------

0N/A // Implementation: Fundamental operations

0N/A //----------------------------------------------------------------

0N/A

0N/A // polarity = 0, 3 is normal: x xor y

0N/A // polarity = 1, 2: x xor ~y == x === y

0N/A

0N/A private UnicodeSet xor(int[] other, int otherLen, int polarity) {

0N/A ensureBufferCapacity(len + otherLen);

0N/A int i = 0, j = 0, k = 0;

0N/A int a = list[i++];

0N/A int b;

0N/A if (polarity == 1 || polarity == 2) {

0N/A b = LOW;

0N/A if (other[j] == LOW) { // skip base if already LOW

0N/A ++j;

0N/A b = other[j];

0N/A }

0N/A } else {

0N/A b = other[j++];

0N/A }

0N/A // simplest of all the routines

0N/A // sort the values, discarding identicals!

0N/A while (true) {

0N/A if (a < b) {

0N/A buffer[k++] = a;

0N/A a = list[i++];

0N/A } else if (b < a) {

0N/A buffer[k++] = b;

0N/A b = other[j++];