820 lines
28 KiB
Java
820 lines
28 KiB
Java
/*
|
|
* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* (C) Copyright Taligent, Inc. 1996, 1997 - All Rights Reserved
|
|
* (C) Copyright IBM Corp. 1996 - 2002 - All Rights Reserved
|
|
*
|
|
* The original version of this source code and documentation
|
|
* is copyrighted and owned by Taligent, Inc., a wholly-owned
|
|
* subsidiary of IBM. These materials are provided under terms
|
|
* of a License Agreement between Taligent and Sun. This technology
|
|
* is protected by multiple US and International patents.
|
|
*
|
|
* This notice and attribution to Taligent may not be removed.
|
|
* Taligent is a registered trademark of Taligent, Inc.
|
|
*/
|
|
|
|
package build.tools.generatebreakiteratordata;
|
|
|
|
import java.util.Arrays;
|
|
import java.util.Hashtable;
|
|
|
|
/**
|
|
* An object representing a set of characters. (This is a "set" in the
|
|
* mathematical sense: an unduplicated list of characters on which set
|
|
* operations such as union and intersection can be performed.) The
|
|
* set information is stored in compressed, optimized form: The object
|
|
* contains an integer array with an even number of characters. Each
|
|
* pair of characters represents a range of characters contained in the set
|
|
* (a pair of the same character represents a single character). The
|
|
* characters are sorted in increasing order.
|
|
*/
|
|
class CharSet {
|
|
/**
|
|
* The structure containing the set information. The characters
|
|
* in this array are organized into pairs, each pair representing
|
|
* a range of characters contained in the set
|
|
*/
|
|
private int[] chars;
|
|
|
|
//==========================================================================
|
|
// parseString() and associated routines
|
|
//==========================================================================
|
|
/**
|
|
* A cache which is used to speed up parseString() whenever it is
|
|
* used to parse a description that has been parsed before
|
|
*/
|
|
private static Hashtable<String, CharSet> expressionCache = null;
|
|
|
|
/**
|
|
* Builds a CharSet based on a textual description. For the syntax of
|
|
* the description, see the documentation of RuleBasedBreakIterator.
|
|
* @see java.text.RuleBasedBreakIterator
|
|
*/
|
|
public static CharSet parseString(String s) {
|
|
CharSet result = null;
|
|
|
|
// if "s" is in the expression cache, pull the result out
|
|
// of the expresison cache
|
|
if (expressionCache != null) {
|
|
result = expressionCache.get(s);
|
|
}
|
|
|
|
// otherwise, use doParseString() to actually parse the string,
|
|
// and then add a corresponding entry to the expression cache
|
|
if (result == null) {
|
|
result = doParseString(s);
|
|
if (expressionCache == null) {
|
|
expressionCache = new Hashtable<>();
|
|
}
|
|
expressionCache.put(s, result);
|
|
}
|
|
result = (CharSet)(result.clone());
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* This function is used by parseString() to actually parse the string
|
|
*/
|
|
private static CharSet doParseString(String s) {
|
|
CharSet result = new CharSet();
|
|
int p = 0;
|
|
|
|
boolean haveDash = false;
|
|
boolean haveTilde = false;
|
|
boolean wIsReal = false;
|
|
int w = 0x0000;
|
|
|
|
// for each character in the description...
|
|
while (p < s.length()) {
|
|
int c = s.codePointAt(p);
|
|
|
|
// if it's an opening bracket...
|
|
if (c == '[') {
|
|
// flush the single-character cache
|
|
if (wIsReal) {
|
|
result.internalUnion(new CharSet(w));
|
|
}
|
|
|
|
// locate the matching closing bracket
|
|
int bracketLevel = 1;
|
|
int q = p + 1;
|
|
while (bracketLevel != 0) {
|
|
// if no matching bracket by end of string then...
|
|
if (q >= s.length()) {
|
|
throw new IllegalArgumentException("Parse error at position " + p + " in " + s);
|
|
}
|
|
int ch = s.codePointAt(q);
|
|
switch (ch) {
|
|
case '\\': // need to step over next character
|
|
ch = s.codePointAt(++q);
|
|
break;
|
|
case '[':
|
|
++bracketLevel;
|
|
break;
|
|
case ']':
|
|
--bracketLevel;
|
|
break;
|
|
}
|
|
q += Character.charCount(ch);
|
|
}
|
|
--q;
|
|
|
|
// call parseString() recursively to parse the text inside
|
|
// the brackets, then either add or subtract the result from
|
|
// our running result depending on whether or not the []
|
|
// expresison was preceded by a ^
|
|
if (!haveTilde) {
|
|
result.internalUnion(CharSet.parseString(s.substring(p + 1, q)));
|
|
}
|
|
else {
|
|
result.internalDifference(CharSet.parseString(s.substring(p + 1, q)));
|
|
}
|
|
haveTilde = false;
|
|
haveDash = false;
|
|
wIsReal = false;
|
|
p = q + 1;
|
|
}
|
|
|
|
// if the character is a colon...
|
|
else if (c == ':') {
|
|
// flush the single-character cache
|
|
if (wIsReal) {
|
|
result.internalUnion(new CharSet(w));
|
|
}
|
|
|
|
// locate the matching colon (and throw an error if there
|
|
// isn't one)
|
|
int q = s.indexOf(':', p + 1);
|
|
if (q == -1) {
|
|
throw new IllegalArgumentException("Parse error at position " + p + " in " + s);
|
|
}
|
|
|
|
// use charSetForCategory() to parse the text in the colons,
|
|
// and either add or substract the result from our running
|
|
// result depending on whether the :: expression was
|
|
// preceded by a ^
|
|
if (!haveTilde) {
|
|
result.internalUnion(charSetForCategory(s.substring(p + 1, q)));
|
|
}
|
|
else {
|
|
result.internalDifference(charSetForCategory(s.substring(p + 1, q)));
|
|
}
|
|
|
|
// reset everything and advance to the next character
|
|
haveTilde = false;
|
|
haveDash = false;
|
|
wIsReal = false;
|
|
p = q + 1;
|
|
}
|
|
|
|
// if the character is a dash, set an appropriate flag
|
|
else if (c == '-') {
|
|
if (wIsReal) {
|
|
haveDash = true;
|
|
}
|
|
++p;
|
|
}
|
|
|
|
// if the character is a caret, flush the single-character
|
|
// cache and set an appropriate flag. If the set is empty
|
|
// (i.e., if the expression begins with ^), invert the set
|
|
// (i.e., set it to include everything). The idea here is
|
|
// that a set that includes nothing but ^ expressions
|
|
// means "everything but these things".
|
|
else if (c == '^') {
|
|
if (wIsReal) {
|
|
result.internalUnion(new CharSet(w));
|
|
wIsReal = false;
|
|
}
|
|
haveTilde = true;
|
|
++p;
|
|
if (result.empty()) {
|
|
result.internalComplement();
|
|
}
|
|
}
|
|
|
|
// throw an exception on an illegal character
|
|
else if (c >= ' ' && c < '\u007f' && !Character.isLetter((char)c)
|
|
&& !Character.isDigit((char)c) && c != '\\') {
|
|
throw new IllegalArgumentException("Parse error at position " + p + " in " + s);
|
|
}
|
|
|
|
// otherwise, we end up here...
|
|
else {
|
|
// on a backslash, advance to the next character
|
|
if (c == '\\') {
|
|
++p;
|
|
}
|
|
|
|
// if the preceding character was a dash, this character
|
|
// defines the end of a range. Add or subtract that range
|
|
// from the running result depending on whether or not it
|
|
// was preceded by a ^
|
|
if (haveDash) {
|
|
if (s.codePointAt(p) < w) {
|
|
throw new IllegalArgumentException("U+" +
|
|
Integer.toHexString(s.codePointAt(p))
|
|
+ " is less than U+" + Integer.toHexString(w) + ". Dash expressions "
|
|
+ "can't have their endpoints in reverse order.");
|
|
}
|
|
|
|
int ch = s.codePointAt(p);
|
|
if (!haveTilde) {
|
|
result.internalUnion(new CharSet(w, ch));
|
|
}
|
|
else {
|
|
result.internalDifference(new CharSet(w, ch));
|
|
}
|
|
p += Character.charCount(ch);
|
|
haveDash = false;
|
|
haveTilde = false;
|
|
wIsReal = false;
|
|
}
|
|
|
|
// if the preceding character was a caret, remove this character
|
|
// from the running result
|
|
else if (haveTilde) {
|
|
w = s.codePointAt(p);
|
|
result.internalDifference(new CharSet(w));
|
|
p += Character.charCount(w);
|
|
haveTilde = false;
|
|
wIsReal = false;
|
|
}
|
|
|
|
// otherwise, flush the single-character cache and then
|
|
// put this character into the cache
|
|
else if (wIsReal) {
|
|
result.internalUnion(new CharSet(w));
|
|
w = s.codePointAt(p);
|
|
p += Character.charCount(w);
|
|
wIsReal = true;
|
|
} else {
|
|
w = s.codePointAt(p);
|
|
p += Character.charCount(w);
|
|
wIsReal = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// finally, flush the single-character cache one last time
|
|
if (wIsReal) {
|
|
result.internalUnion(new CharSet(w));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Creates a CharSet containing all the characters in a particular
|
|
* Unicode category. The text is either a two-character code from
|
|
* the Unicode database or a single character that begins one or more
|
|
* two-character codes.
|
|
*/
|
|
private static CharSet charSetForCategory(String category) {
|
|
// throw an exception if we have anything other than one or two
|
|
// characters inside the colons
|
|
if (category.length() == 0 || category.length() >= 3) {
|
|
throw new IllegalArgumentException("Invalid character category: " + category);
|
|
}
|
|
|
|
// if we have two characters, search the category map for that code
|
|
// and either construct and return a CharSet from the data in the
|
|
// category map or throw an exception
|
|
if (category.length() == 2) {
|
|
for (int i = 0; i < CharacterCategory.categoryNames.length; i++) {
|
|
if (CharacterCategory.categoryNames[i].equals(category)) {
|
|
return new CharSet(CharacterCategory.getCategoryMap(i));
|
|
}
|
|
}
|
|
throw new IllegalArgumentException("Invalid character category: " + category);
|
|
}
|
|
|
|
// if we have one character, search the category map for codes beginning
|
|
// with that letter, and union together all of the matching sets that
|
|
// we find (or throw an exception if there are no matches)
|
|
else if (category.length() == 1) {
|
|
CharSet result = new CharSet();
|
|
for (int i = 0; i < CharacterCategory.categoryNames.length; i++) {
|
|
if (CharacterCategory.categoryNames[i].startsWith(category)) {
|
|
result = result.union(new CharSet(CharacterCategory.getCategoryMap(i)));
|
|
}
|
|
}
|
|
if (result.empty()) {
|
|
throw new IllegalArgumentException("Invalid character category: " + category);
|
|
}
|
|
else {
|
|
return result;
|
|
}
|
|
}
|
|
return new CharSet(); // should never get here, but to make the compiler happy...
|
|
}
|
|
|
|
/**
|
|
* Returns a copy of CharSet's expression cache and sets CharSet's
|
|
* expression cache to empty.
|
|
*/
|
|
public static Hashtable<String, CharSet> releaseExpressionCache() {
|
|
Hashtable<String, CharSet> result = expressionCache;
|
|
expressionCache = null;
|
|
return result;
|
|
}
|
|
|
|
//==========================================================================
|
|
// CharSet manipulation
|
|
//==========================================================================
|
|
/**
|
|
* Creates an empty CharSet.
|
|
*/
|
|
public CharSet() {
|
|
chars = new int[0];
|
|
}
|
|
|
|
/**
|
|
* Creates a CharSet containing a single character.
|
|
* @param c The character to put into the CharSet
|
|
*/
|
|
public CharSet(int c) {
|
|
chars = new int[2];
|
|
chars[0] = c;
|
|
chars[1] = c;
|
|
}
|
|
|
|
/**
|
|
* Creates a CharSet containing a range of characters.
|
|
* @param lo The lowest-numbered character to include in the range
|
|
* @param hi The highest-numbered character to include in the range
|
|
*/
|
|
public CharSet(int lo, int hi) {
|
|
chars = new int[2];
|
|
if (lo <= hi) {
|
|
chars[0] = lo;
|
|
chars[1] = hi;
|
|
}
|
|
else {
|
|
chars[0] = hi;
|
|
chars[1] = lo;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a CharSet, initializing it from the internal storage
|
|
* of another CharSet (this function performs no error checking
|
|
* on "chars", so if it's malformed, undefined behavior will result)
|
|
*/
|
|
private CharSet(int[] chars) {
|
|
this.chars = chars;
|
|
}
|
|
|
|
/**
|
|
* Returns a CharSet representing the union of two CharSets.
|
|
*/
|
|
public CharSet union(CharSet that) {
|
|
return new CharSet(doUnion(that.chars));
|
|
}
|
|
|
|
/**
|
|
* Adds the characters in "that" to this CharSet
|
|
*/
|
|
private void internalUnion(CharSet that) {
|
|
chars = doUnion(that.chars);
|
|
}
|
|
|
|
/**
|
|
* The actual implementation of the union functions
|
|
*/
|
|
private int[] doUnion(int[] c2) {
|
|
int[] result = new int[chars.length+c2.length];
|
|
|
|
int i = 0;
|
|
int j = 0;
|
|
int index = 0;
|
|
|
|
// consider all the characters in both strings
|
|
while (i < chars.length && j < c2.length) {
|
|
int ub;
|
|
|
|
// the first character in the result is the lower of the
|
|
// starting characters of the two strings, and "ub" gets
|
|
// set to the upper bound of that range
|
|
if (chars[i] < c2[j]) {
|
|
result[index++] = chars[i];
|
|
ub = chars[++i];
|
|
}
|
|
else {
|
|
result[index++] = c2[j];
|
|
ub = c2[++j];
|
|
}
|
|
|
|
// for as long as one of our two pointers is pointing to a range's
|
|
// end point, or i is pointing to a character that is less than
|
|
// "ub" plus one (the "plus one" stitches touching ranges together)...
|
|
while (i % 2 == 1 ||
|
|
j % 2 == 1 ||
|
|
(i < chars.length && chars[i] <= ub + 1)) {
|
|
|
|
// advance i to the first character that is greater than
|
|
// "ub" plus one
|
|
while (i < chars.length && chars[i] <= ub + 1) {
|
|
++i;
|
|
}
|
|
|
|
// if i points to the endpoint of a range, update "ub"
|
|
// to that character, or if i points to the start of
|
|
// a range and the endpoint of the preceding range is
|
|
// greater than "ub", update "up" to _that_ character
|
|
if (i % 2 == 1) {
|
|
ub = chars[i];
|
|
}
|
|
else if (i > 0 && chars[i - 1] > ub) {
|
|
ub = chars[i - 1];
|
|
}
|
|
|
|
// now advance j to the first character that is greater
|
|
// that "ub" plus one
|
|
while (j < c2.length && c2[j] <= ub + 1) {
|
|
++j;
|
|
}
|
|
|
|
// if j points to the endpoint of a range, update "ub"
|
|
// to that character, or if j points to the start of
|
|
// a range and the endpoint of the preceding range is
|
|
// greater than "ub", update "up" to _that_ character
|
|
if (j % 2 == 1) {
|
|
ub = c2[j];
|
|
}
|
|
else if (j > 0 && c2[j - 1] > ub) {
|
|
ub = c2[j - 1];
|
|
}
|
|
}
|
|
// when we finally fall out of this loop, we will have stitched
|
|
// together a series of ranges that overlap or touch, i and j
|
|
// will both point to starting points of ranges, and "ub" will
|
|
// be the endpoint of the range we're working on. Write "ub"
|
|
// to the result
|
|
result[index++] = ub;
|
|
|
|
// loop back around to create the next range in the result
|
|
}
|
|
|
|
// we fall out to here when we've exhausted all the characters in
|
|
// one of the operands. We can append all of the remaining characters
|
|
// in the other operand without doing any extra work.
|
|
if (i < chars.length) {
|
|
for (int k = i; k < chars.length; k++) {
|
|
result[index++] = chars[k];
|
|
}
|
|
}
|
|
if (j < c2.length) {
|
|
for (int k = j; k < c2.length; k++) {
|
|
result[index++] = c2[k];
|
|
}
|
|
}
|
|
|
|
if (result.length > index) {
|
|
int[] tmpbuf = new int[index];
|
|
System.arraycopy(result, 0, tmpbuf, 0, index);
|
|
return tmpbuf;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns the intersection of two CharSets.
|
|
*/
|
|
public CharSet intersection(CharSet that) {
|
|
return new CharSet(doIntersection(that.chars));
|
|
}
|
|
|
|
/**
|
|
* Removes from this CharSet any characters that aren't also in "that"
|
|
*/
|
|
private void internalIntersection(CharSet that) {
|
|
chars = doIntersection(that.chars);
|
|
}
|
|
|
|
/**
|
|
* The internal implementation of the two intersection functions
|
|
*/
|
|
private int[] doIntersection(int[] c2) {
|
|
int[] result = new int[chars.length+c2.length];
|
|
|
|
int i = 0;
|
|
int j = 0;
|
|
int oldI;
|
|
int oldJ;
|
|
int index = 0;
|
|
|
|
// iterate until we've exhausted one of the operands
|
|
while (i < chars.length && j < c2.length) {
|
|
|
|
// advance j until it points to a character that is larger than
|
|
// the one i points to. If this is the beginning of a one-
|
|
// character range, advance j to point to the end
|
|
if (i < chars.length && i % 2 == 0) {
|
|
while (j < c2.length && c2[j] < chars[i]) {
|
|
++j;
|
|
}
|
|
if (j < c2.length && j % 2 == 0 && c2[j] == chars[i]) {
|
|
++j;
|
|
}
|
|
}
|
|
|
|
// if j points to the endpoint of a range, save the current
|
|
// value of i, then advance i until it reaches a character
|
|
// which is larger than the character pointed at
|
|
// by j. All of the characters we've advanced over (except
|
|
// the one currently pointed to by i) are added to the result
|
|
oldI = i;
|
|
while (j % 2 == 1 && i < chars.length && chars[i] <= c2[j]) {
|
|
++i;
|
|
}
|
|
for (int k = oldI; k < i; k++) {
|
|
result[index++] = chars[k];
|
|
}
|
|
|
|
// if i points to the endpoint of a range, save the current
|
|
// value of j, then advance j until it reaches a character
|
|
// which is larger than the character pointed at
|
|
// by i. All of the characters we've advanced over (except
|
|
// the one currently pointed to by i) are added to the result
|
|
oldJ = j;
|
|
while (i % 2 == 1 && j < c2.length && c2[j] <= chars[i]) {
|
|
++j;
|
|
}
|
|
for (int k = oldJ; k < j; k++) {
|
|
result[index++] = c2[k];
|
|
}
|
|
|
|
// advance i until it points to a character larger than j
|
|
// If it points at the beginning of a one-character range,
|
|
// advance it to the end of that range
|
|
if (j < c2.length && j % 2 == 0) {
|
|
while (i < chars.length && chars[i] < c2[j]) {
|
|
++i;
|
|
}
|
|
if (i < chars.length && i % 2 == 0 && c2[j] == chars[i]) {
|
|
++i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result.length > index) {
|
|
int[] tmpbuf = new int[index];
|
|
System.arraycopy(result, 0, tmpbuf, 0, index);
|
|
return tmpbuf;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a CharSet containing all the characters in "this" that
|
|
* aren't also in "that"
|
|
*/
|
|
public CharSet difference(CharSet that) {
|
|
return new CharSet(doIntersection(that.doComplement()));
|
|
}
|
|
|
|
/**
|
|
* Removes from "this" all the characters that are also in "that"
|
|
*/
|
|
private void internalDifference(CharSet that) {
|
|
chars = doIntersection(that.doComplement());
|
|
}
|
|
|
|
/**
|
|
* Returns a CharSet containing all the characters which are not
|
|
* in "this"
|
|
*/
|
|
public CharSet complement() {
|
|
return new CharSet(doComplement());
|
|
}
|
|
|
|
/**
|
|
* Complements "this". All the characters it contains are removed,
|
|
* and all the characters it doesn't contain are added.
|
|
*/
|
|
private void internalComplement() {
|
|
chars = doComplement();
|
|
}
|
|
|
|
/**
|
|
* The internal implementation function for the complement routines
|
|
*/
|
|
private int[] doComplement() {
|
|
// the complement of an empty CharSet is one containing everything
|
|
if (empty()) {
|
|
int[] result = new int[2];
|
|
result[0] = 0x0000;
|
|
result[1] = 0x10FFFF;
|
|
return result;
|
|
}
|
|
|
|
int[] result = new int[chars.length+2];
|
|
|
|
int i = 0;
|
|
int index = 0;
|
|
|
|
// the result begins with \u0000 unless the original CharSet does
|
|
if (chars[0] != 0x0000) {
|
|
result[index++] = 0x0000;
|
|
}
|
|
|
|
// walk through the characters in this CharSet. Append a pair of
|
|
// characters the first of which is one less than the first
|
|
// character we see and the second of which is one plus the second
|
|
// character we see (don't write the first character if it's \u0000,
|
|
// and don't write the second character if it's \uffff.
|
|
while (i < chars.length) {
|
|
if (chars[i] != 0x0000) {
|
|
result[index++] = chars[i] - 1;
|
|
}
|
|
if (chars[i + 1] != 0x10FFFF) {
|
|
result[index++] = chars[i + 1] + 1;
|
|
}
|
|
i += 2;
|
|
}
|
|
|
|
// add 0x10ffff to the end of the result, unless it was in
|
|
// the original set
|
|
if (chars[i-1] != 0x10FFFF) {
|
|
result[index++] = 0x10FFFF;
|
|
}
|
|
|
|
if (result.length > index) {
|
|
int[] tmpbuf = new int[index];
|
|
System.arraycopy(result, 0, tmpbuf, 0, index);
|
|
return tmpbuf;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns true if this CharSet contains the specified character
|
|
* @param c The character we're testing for set membership
|
|
*/
|
|
public boolean contains(int c) {
|
|
// search for the first range endpoint that is greater than or
|
|
// equal to c
|
|
int i = 1;
|
|
while (i < chars.length && chars[i] < c) {
|
|
i += 2;
|
|
}
|
|
|
|
// if we've walked off the end, we don't contain c
|
|
if (i == chars.length) {
|
|
return false;
|
|
}
|
|
|
|
// otherwise, we contain c if the beginning of the range is less
|
|
// than or equal to c
|
|
return chars[i - 1] <= c;
|
|
}
|
|
|
|
/**
|
|
* Returns true if "that" is another instance of CharSet containing
|
|
* the exact same characters as this one
|
|
*/
|
|
public boolean equals(Object that) {
|
|
return (that instanceof CharSet) && Arrays.equals(chars, ((CharSet)that).chars);
|
|
}
|
|
|
|
/**
|
|
* Returns the hash code for this set of characters
|
|
*/
|
|
public int hashCode() {
|
|
return Arrays.hashCode(chars);
|
|
}
|
|
|
|
/**
|
|
* Creates a new CharSet that is equal to this one
|
|
*/
|
|
public Object clone() {
|
|
return new CharSet(chars);
|
|
}
|
|
|
|
/**
|
|
* Returns true if this CharSet contains no characters
|
|
*/
|
|
public boolean empty() {
|
|
return chars.length == 0;
|
|
}
|
|
|
|
/**
|
|
* Returns a textual representation of this CharSet. If the result
|
|
* of calling this function is passed to CharSet.parseString(), it
|
|
* will produce another CharSet that is equal to this one.
|
|
*/
|
|
public String toString() {
|
|
StringBuffer result = new StringBuffer();
|
|
|
|
// the result begins with an opening bracket
|
|
result.append('[');
|
|
|
|
// iterate through the ranges in the CharSet
|
|
for (int i = 0; i < chars.length; i += 2) {
|
|
// for a range with the same beginning and ending point,
|
|
// output that character
|
|
if (chars[i] == chars[i + 1]) {
|
|
result.append("0x");
|
|
result.append(Integer.toHexString(chars[i]));
|
|
}
|
|
|
|
// otherwise, output the start and end points of the range
|
|
// separated by a dash
|
|
else {
|
|
result.append("0x");
|
|
result.append(Integer.toHexString(chars[i]));
|
|
result.append("-0x");
|
|
result.append(Integer.toHexString(chars[i + 1]));
|
|
}
|
|
}
|
|
|
|
// the result ends with a closing bracket
|
|
result.append(']');
|
|
return result.toString();
|
|
}
|
|
|
|
/**
|
|
* Returns an integer array representing the contents of this CharSet
|
|
* in the same form in which they're stored internally: as pairs
|
|
* of characters representing the start and end points of ranges
|
|
*/
|
|
public int[] getRanges() {
|
|
return chars;
|
|
}
|
|
|
|
/**
|
|
* Returns an Enumeration that will return the ranges of characters
|
|
* contained in this CharSet one at a time
|
|
*/
|
|
public Enumeration getChars() {
|
|
return new Enumeration(this);
|
|
}
|
|
|
|
//==========================================================================
|
|
// CharSet.Enumeration
|
|
//==========================================================================
|
|
|
|
/**
|
|
* An Enumeration that can be used to extract the character ranges
|
|
* from a CharSet one at a time
|
|
*/
|
|
public class Enumeration implements java.util.Enumeration<int[]> {
|
|
/**
|
|
* Initializes a CharSet.Enumeration
|
|
*/
|
|
Enumeration(CharSet cs) {
|
|
this.chars = cs.chars;
|
|
p = 0;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the enumeration hasn't yet returned
|
|
* all the ranges in the CharSet
|
|
*/
|
|
public boolean hasMoreElements() {
|
|
return p < chars.length;
|
|
}
|
|
|
|
/**
|
|
* Returns the next range in the CarSet
|
|
*/
|
|
public int[] nextElement() {
|
|
int[] result = new int[2];
|
|
result[0] = chars[p++];
|
|
result[1] = chars[p++];
|
|
return result;
|
|
}
|
|
|
|
int p;
|
|
int[] chars;
|
|
}
|
|
}
|