A regular expression parser for the XML Schema.
| Method from org.apache.xerces.impl.xpath.regex.ParserForXMLSchema Detail: |
|---|
 boolean checkQuestion(int off) {
return false;
}
|
int decodeEscaped() throws ParseException {
if (this.read() != T_BACKSOLIDUS) throw ex("parser.next.1", this.offset-1);
int c = this.chardata;
switch (c) {
case 'n": c = '\n"; break; // LINE FEED U+000A
case 'r": c = '\r"; break; // CRRIAGE RETURN U+000D
case 't": c = '\t"; break; // HORIZONTAL TABULATION U+0009
case '\\":
case '|":
case '.":
case '^":
case '-":
case '?":
case '*":
case '+":
case '{":
case '}":
case '(":
case ')":
case '[":
case ']":
break; // return actucal char
default:
throw ex("parser.process.1", this.offset-2);
}
return c;
} |
protected static synchronized RangeToken getRange(String name,
boolean positive) {
if (ranges == null) {
ranges = new Hashtable();
ranges2 = new Hashtable();
Token tok = Token.createRange();
setupRange(tok, SPACES);
ranges.put("xml:isSpace", tok);
ranges2.put("xml:isSpace", Token.complementRanges(tok));
tok = Token.createRange();
setupRange(tok, DIGITS);
ranges.put("xml:isDigit", tok);
ranges2.put("xml:isDigit", Token.complementRanges(tok));
tok = Token.createRange();
setupRange(tok, DIGITS);
ranges.put("xml:isDigit", tok);
ranges2.put("xml:isDigit", Token.complementRanges(tok));
tok = Token.createRange();
setupRange(tok, LETTERS);
tok.mergeRanges((Token)ranges.get("xml:isDigit"));
ranges.put("xml:isWord", tok);
ranges2.put("xml:isWord", Token.complementRanges(tok));
tok = Token.createRange();
setupRange(tok, NAMECHARS);
ranges.put("xml:isNameChar", tok);
ranges2.put("xml:isNameChar", Token.complementRanges(tok));
tok = Token.createRange();
setupRange(tok, LETTERS);
tok.addRange('_", '_");
tok.addRange(':", ':");
ranges.put("xml:isInitialNameChar", tok);
ranges2.put("xml:isInitialNameChar", Token.complementRanges(tok));
}
RangeToken tok = positive ? (RangeToken)ranges.get(name)
: (RangeToken)ranges2.get(name);
return tok;
} |
Token getTokenForShorthand(int ch) {
switch (ch) {
case 'd":
return ParserForXMLSchema.getRange("xml:isDigit", true);
case 'D":
return ParserForXMLSchema.getRange("xml:isDigit", false);
case 'w":
return ParserForXMLSchema.getRange("xml:isWord", true);
case 'W":
return ParserForXMLSchema.getRange("xml:isWord", false);
case 's":
return ParserForXMLSchema.getRange("xml:isSpace", true);
case 'S":
return ParserForXMLSchema.getRange("xml:isSpace", false);
case 'c":
return ParserForXMLSchema.getRange("xml:isNameChar", true);
case 'C":
return ParserForXMLSchema.getRange("xml:isNameChar", false);
case 'i":
return ParserForXMLSchema.getRange("xml:isInitialNameChar", true);
case 'I":
return ParserForXMLSchema.getRange("xml:isInitialNameChar", false);
default:
throw new RuntimeException("Internal Error: shorthands: \\u"+Integer.toString(ch, 16));
}
} |
protected RangeToken parseCharacterClass(boolean useNrange) throws ParseException {
this.setContext(S_INBRACKETS);
this.next(); // '['
boolean nrange = false;
boolean wasDecoded = false; // used to detect if the last - was escaped.
RangeToken base = null;
RangeToken tok;
if (this.read() == T_CHAR && this.chardata == '^") {
nrange = true;
this.next(); // '^'
base = Token.createRange();
base.addRange(0, Token.UTF16_MAX);
tok = Token.createRange();
} else {
tok = Token.createRange();
}
int type;
boolean firstloop = true;
while ((type = this.read()) != T_EOF) { // Don't use 'cotinue' for this loop.
wasDecoded = false;
// single-range | from-to-range | subtraction
if (type == T_CHAR && this.chardata == ']" && !firstloop) {
if (nrange) {
base.subtractRanges(tok);
tok = base;
}
break;
}
int c = this.chardata;
boolean end = false;
if (type == T_BACKSOLIDUS) {
switch (c) {
case 'd": case 'D":
case 'w": case 'W":
case 's": case 'S":
tok.mergeRanges(this.getTokenForShorthand(c));
end = true;
break;
case 'i": case 'I":
case 'c": case 'C":
c = this.processCIinCharacterClass(tok, c);
if (c < 0) end = true;
break;
case 'p":
case 'P":
int pstart = this.offset;
RangeToken tok2 = this.processBacksolidus_pP(c);
if (tok2 == null) throw this.ex("parser.atom.5", pstart);
tok.mergeRanges(tok2);
end = true;
break;
case '-":
c = this.decodeEscaped();
wasDecoded = true;
break;
default:
c = this.decodeEscaped();
} // \ + c
} // backsolidus
else if (type == T_XMLSCHEMA_CC_SUBTRACTION && !firstloop) {
// Subraction
if (nrange) {
base.subtractRanges(tok);
tok = base;
}
RangeToken range2 = this.parseCharacterClass(false);
tok.subtractRanges(range2);
if (this.read() != T_CHAR || this.chardata != ']")
throw this.ex("parser.cc.5", this.offset);
break; // Exit this loop
}
this.next();
if (!end) { // if not shorthands...
if (type == T_CHAR) {
if (c == '[") throw this.ex("parser.cc.6", this.offset-2);
if (c == ']") throw this.ex("parser.cc.7", this.offset-2);
if (c == '-" && this.chardata != ']" && !firstloop) throw this.ex("parser.cc.8", this.offset-2); // if regex = '[-]' then invalid
}
if (this.read() != T_CHAR || this.chardata != '-" || c == '-" && firstloop) { // Here is no '-'.
tok.addRange(c, c);
} else { // Found '-'
// Is this '-' is a from-to token??
this.next(); // Skips '-'
if ((type = this.read()) == T_EOF) throw this.ex("parser.cc.2", this.offset);
// c '-' ']' - > '-' is a single-range.
if(type == T_CHAR && this.chardata == ']") { // if - is at the last position of the group
tok.addRange(c, c);
tok.addRange('-", '-");
}
else if (type == T_XMLSCHEMA_CC_SUBTRACTION) {
throw this.ex("parser.cc.8", this.offset-1);
} else {
int rangeend = this.chardata;
if (type == T_CHAR) {
if (rangeend == '[") throw this.ex("parser.cc.6", this.offset-1);
if (rangeend == ']") throw this.ex("parser.cc.7", this.offset-1);
if (rangeend == '-") throw this.ex("parser.cc.8", this.offset-2);
}
else if (type == T_BACKSOLIDUS)
rangeend = this.decodeEscaped();
this.next();
if (c > rangeend) throw this.ex("parser.ope.3", this.offset-1);
tok.addRange(c, rangeend);
}
}
}
firstloop = false;
}
if (this.read() == T_EOF)
throw this.ex("parser.cc.2", this.offset);
tok.sortRanges();
tok.compactRanges();
//tok.dumpRanges();
this.setContext(S_NORMAL);
this.next(); // Skips ']'
return tok;
} Parses a character-class-expression, not a character-class-escape.
c-c-expression ::= '[' c-group ']'
c-group ::= positive-c-group | negative-c-group | c-c-subtraction
positive-c-group ::= (c-range | c-c-escape)+
negative-c-group ::= '^' positive-c-group
c-c-subtraction ::= (positive-c-group | negative-c-group) subtraction
subtraction ::= '-' c-c-expression
c-range ::= single-range | from-to-range
single-range ::= multi-c-escape | category-c-escape | block-c-escape | <any XML char>
cc-normal-c ::= <any character except [, ], \>
from-to-range ::= cc-normal-c '-' cc-normal-c |
protected RangeToken parseSetOperations() throws ParseException {
throw this.ex("parser.process.1", this.offset);
} |
Token processBackreference() throws ParseException {
throw ex("parser.process.1", this.offset-4);
} |
Token processBacksolidus_A() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processBacksolidus_B() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processBacksolidus_C() throws ParseException {
this.next();
return this.getTokenForShorthand('C");
} |
Token processBacksolidus_I() throws ParseException {
this.next();
return this.getTokenForShorthand('I");
} |
Token processBacksolidus_X() throws ParseException {
throw ex("parser.process.1", this.offset-2);
} |
Token processBacksolidus_Z() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processBacksolidus_b() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processBacksolidus_c() throws ParseException {
this.next();
return this.getTokenForShorthand('c");
} |
Token processBacksolidus_g() throws ParseException {
throw this.ex("parser.process.1", this.offset-2);
} |
Token processBacksolidus_gt() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processBacksolidus_i() throws ParseException {
this.next();
return this.getTokenForShorthand('i");
} |
Token processBacksolidus_lt() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processBacksolidus_z() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
int processCIinCharacterClass(RangeToken tok,
int c) {
tok.mergeRanges(this.getTokenForShorthand(c));
return -1;
} |
Token processCaret() throws ParseException {
this.next();
return Token.createChar('^");
} |
Token processCondition() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processDollar() throws ParseException {
this.next();
return Token.createChar('$");
} |
Token processIndependent() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processLookahead() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processLookbehind() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processModifiers() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processNegativelookahead() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processNegativelookbehind() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processParen() throws ParseException {
this.next();
Token tok = Token.createParen(this.parseRegex(), 0);
if (this.read() != T_RPAREN) throw ex("parser.factor.1", this.offset-1);
this.next(); // Skips ')'
return tok;
} |
Token processParen2() throws ParseException {
throw ex("parser.process.1", this.offset);
} |
Token processPlus(Token tok) throws ParseException {
// X+ - > XX*
this.next();
return Token.createConcat(tok, Token.createClosure(tok));
} |
Token processQuestion(Token tok) throws ParseException {
// X? - > X|
this.next();
Token par = Token.createUnion();
par.addChild(tok);
par.addChild(Token.createEmpty());
return par;
} |
Token processStar(Token tok) throws ParseException {
this.next();
return Token.createClosure(tok);
} |
static void setupRange(Token range,
String src) {
int len = src.length();
for (int i = 0; i < len; i += 2)
range.addRange(src.charAt(i), src.charAt(i+1));
} |
org.apache.xerces.impl.xpath.regex.RegexParser