yggdrasil/gcc
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Imported GNU Classpath 0.90

Browse Source 
Imported GNU Classpath 0.90
       * scripts/makemake.tcl: Set gnu/java/awt/peer/swing to ignore.
       * gnu/classpath/jdwp/VMFrame.java (SIZE): New constant.
       * java/lang/VMCompiler.java: Use gnu.java.security.hash.MD5.
       * java/lang/Math.java: New override file.
       * java/lang/Character.java: Merged from Classpath.
       (start, end): Now 'int's.
       (canonicalName): New field.
       (CANONICAL_NAME, NO_SPACES_NAME, CONSTANT_NAME): New constants.
       (UnicodeBlock): Added argument.
       (of): New overload.
       (forName): New method.
       Updated unicode blocks.
       (sets): Updated.
       * sources.am: Regenerated.
       * Makefile.in: Likewise.

From-SVN: r111942
This commit is contained in:
Mark Wielaard
2006-03-10 21:46:48 +00:00
parent 27079765d0
commit 8aa540d2f7
1367 changed files with 188789 additions and 22762 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libjava/classpath/gnu/regexp/RETokenOneOf.java
+144 -41
View File
@@ -1,5 +1,5 @@
/* gnu/regexp/RETokenOneOf.java
Copyright (C) 1998-2001, 2004 Free Software Foundation, Inc.
Copyright (C) 2006 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -37,11 +37,35 @@ exception statement from your version. */
package gnu.regexp;
import java.util.Vector;
import java.util.Stack;
final class RETokenOneOf extends REToken {
private Vector options;
private boolean negative;
private Vector addition;
// This Vector addition is used to store nested character classes.
// For example, if the original expression is
// [2-7a-c[f-k][m-z]&&[^p-v][st]]
// the basic part /2-7a-c/ is stored in the Vector options, and
// the additional part /[f-k][m-z]&&[^p-v][st]/ is stored in the
// Vector addition in the following order (Reverse Polish Notation):
// -- The matching result of the basic part is assumed here.
// [f-k] -- REToken
// "|" -- or
// [m-z] -- REToken
// "|" -- or
// false
// [^p-v] -- REToken
// "|" -- or
// [st] -- REToken
// "|" -- or
// "&" -- and
//
// As it is clear from the explanation above, the Vector addition is
// effective only when this REToken originates from a character class
// expression.
// This constructor is used for convenience when we know the set beforehand,
// e.g. \d --> new RETokenOneOf("0123456789",false, ..)
// \D --> new RETokenOneOf("0123456789",true, ..)
@@ -60,7 +84,17 @@ final class RETokenOneOf extends REToken {
this.negative = negative;
}
RETokenOneOf(int subIndex, Vector options, Vector addition, boolean negative) {
super(subIndex);
this.options = options;
this.addition = addition;
this.negative = negative;
}
int getMinimumLength() {
// (negative || addition != null) occurs when this token originates from
// character class expression.
if (negative || addition != null) return 1;
int min = Integer.MAX_VALUE;
int x;
for (int i=0; i < options.size(); i++) {
@@ -70,54 +104,123 @@ final class RETokenOneOf extends REToken {
return min;
}
boolean match(CharIndexed input, REMatch mymatch) {
if (negative && (input.charAt(mymatch.index) == CharIndexed.OUT_OF_BOUNDS))
return false;
REMatch newMatch = null;
REMatch last = null;
REToken tk;
boolean isMatch;
int getMaximumLength() {
// (negative || addition != null) occurs when this token originates from
// character class expression.
if (negative || addition != null) return 1;
int max = 0;
int x;
for (int i=0; i < options.size(); i++) {
if ((x = ((REToken) options.elementAt(i)).getMaximumLength()) > max)
max = x;
}
return max;
}
boolean match(CharIndexed input, REMatch mymatch) {
REMatch tryMatch;
boolean tryOnly;
if (addition == null) {
tryMatch = mymatch;
tryOnly = false;
}
else {
tryMatch = (REMatch) mymatch.clone();
tryOnly = true;
}
boolean b = negative ?
matchN(input, tryMatch, tryOnly) :
matchP(input, tryMatch, tryOnly);
if (addition == null) return b;
Stack stack = new Stack();
stack.push(new Boolean(b));
for (int i=0; i < addition.size(); i++) {
Object obj = addition.elementAt(i);
if (obj instanceof REToken) {
b = ((REToken)obj).match(input, (REMatch)mymatch.clone());
stack.push(new Boolean(b));
}
else if (obj instanceof Boolean) {
stack.push(obj);
}
else if (obj.equals("|")) {
b = ((Boolean)stack.pop()).booleanValue();
b = ((Boolean)stack.pop()).booleanValue() || b;
stack.push(new Boolean(b));
}
else if (obj.equals("&")) {
b = ((Boolean)stack.pop()).booleanValue();
b = ((Boolean)stack.pop()).booleanValue() && b;
stack.push(new Boolean(b));
}
else {
throw new RuntimeException("Invalid object found");
}
}
b = ((Boolean)stack.pop()).booleanValue();
if (b) {
++mymatch.index;
return next(input, mymatch);
}
return false;
}
private boolean matchN(CharIndexed input, REMatch mymatch, boolean tryOnly) {
if (input.charAt(mymatch.index) == CharIndexed.OUT_OF_BOUNDS)
return false;
REMatch newMatch = null;
REMatch last = null;
REToken tk;
for (int i=0; i < options.size(); i++) {
tk = (REToken) options.elementAt(i);
REMatch tryMatch = (REMatch) mymatch.clone();
if (tk.match(input, tryMatch)) { // match was successful
if (negative) return false;
if (next(input, tryMatch)) {
// Add tryMatch to list of possibilities.
if (last == null) {
newMatch = tryMatch;
last = tryMatch;
} else {
last.next = tryMatch;
last = tryMatch;
}
} // next succeeds
return false;
} // is a match
} // try next option
} // try next option
if (newMatch != null) {
if (negative) {
return false;
} else {
// set contents of mymatch equal to newMatch
// try each one that matched
mymatch.assignFrom(newMatch);
return true;
}
} else {
if (negative) {
++mymatch.index;
return next(input, mymatch);
} else {
return false;
}
if (tryOnly) return true;
++mymatch.index;
return next(input, mymatch);
}
// index+1 works for [^abc] lists, not for generic lookahead (--> index)
}
private boolean matchP(CharIndexed input, REMatch mymatch, boolean tryOnly) {
boolean stopMatchingIfSatisfied =
(mymatch.matchFlags & REMatch.MF_FIND_ALL) == 0;
REMatch.REMatchList newMatch = new REMatch.REMatchList();
REToken tk;
for (int i=0; i < options.size(); i++) {
// In order that the backtracking can work,
// each option must be chained to the next token.
// But the chain method has some side effect, so
// we use clones.
tk = (REToken)((REToken) options.elementAt(i)).clone();
if (! tryOnly) {
tk.chain(this.next);
tk.setUncle(this.uncle);
tk.subIndex = this.subIndex;
}
REMatch tryMatch = (REMatch) mymatch.clone();
if (tk.match(input, tryMatch)) { // match was successful
if (tryOnly) return true;
newMatch.addTail(tryMatch);
if (stopMatchingIfSatisfied) break;
} // is a match
} // try next option
if (tryOnly) return false;
if (newMatch.head != null) {
// set contents of mymatch equal to newMatch
// try each one that matched
mymatch.assignFrom(newMatch.head);
return true;
} else {
return false;
}
}
void dump(StringBuffer os) {
os.append(negative ? "[^" : "(?:");