/* calculate the total size of the bitmap required for a class expression */
private static bool calculateBitmapSize(CompilerState state, RENode target, char [] src, int index, int end)
{
char rangeStart = (char)(0);
char c;
int n;
int nDigits;
int i;
int max = 0;
bool inRange = false;
target.bmsize = 0;
if (index == end)
return true;
if (src [index] == '^')
++index;
while (index != end) {
int localMax = 0;
nDigits = 2;
switch (src [index]) {
case '\\':
++index;
c = src [index++];
switch (c) {
case 'b':
localMax = 0x8;
break;
case 'f':
localMax = 0xC;
break;
case 'n':
localMax = 0xA;
break;
case 'r':
localMax = 0xD;
break;
case 't':
localMax = 0x9;
break;
case 'v':
localMax = 0xB;
break;
case 'c':
if (((index + 1) < end) && char.IsLetter (src [index + 1]))
localMax = (char)(src [index++] & 0x1F);
else
localMax = '\\';
break;
case 'u':
nDigits += 2;
// fall thru...
goto case 'x';
case 'x':
n = 0;
for (i = 0; (i < nDigits) && (index < end); i++) {
c = src [index++];
n = ScriptConvert.XDigitToInt (c, n);
if (n < 0) {
// Back off to accepting the original
// '\' as a literal
index -= (i + 1);
n = '\\';
break;
}
}
localMax = n;
break;
case 'd':
if (inRange) {
reportError ("msg.bad.range", "");
return false;
}
localMax = '9';
break;
case 'D':
case 's':
case 'S':
case 'w':
case 'W':
if (inRange) {
reportError ("msg.bad.range", "");
return false;
}
target.bmsize = 65535;
return true;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
/*
* This is a non-ECMA extension - decimal escapes (in this
* case, octal!) are supposed to be an error inside class
* ranges, but supported here for backwards compatibility.
*
*/
n = (c - '0');
c = src [index];
if ('0' <= c && c <= '7') {
index++;
n = 8 * n + (c - '0');
c = src [index];
if ('0' <= c && c <= '7') {
index++;
i = 8 * n + (c - '0');
if (i <= 255)
n = i;
else
index--;
}
}
localMax = n;
break;
default:
localMax = c;
break;
}
break;
default:
localMax = src [index++];
break;
}
if (inRange) {
if (rangeStart > localMax) {
reportError ("msg.bad.range", "");
return false;
}
inRange = false;
}
else {
if (index < (end - 1)) {
if (src [index] == '-') {
++index;
inRange = true;
rangeStart = (char)localMax;
continue;
}
}
}
if ((state.flags & JSREG_FOLD) != 0) {
char cu = upcase ((char)localMax);
char cd = downcase ((char)localMax);
localMax = (cu >= cd) ? cu : cd;
}
if (localMax > max)
max = localMax;
}
target.bmsize = max;
return true;
}
private static bool parseTerm(CompilerState state)
{
char [] src = state.cpbegin;
char c = src [state.cp++];
int nDigits = 2;
int parenBaseCount = state.parenCount;
int num, tmp;
RENode term;
int termStart;
int ocp = state.cp;
switch (c) {
/* assertions and atoms */
case '^':
state.result = new RENode (REOP_BOL);
state.progLength++;
return true;
case '$':
state.result = new RENode (REOP_EOL);
state.progLength++;
return true;
case '\\':
if (state.cp < state.cpend) {
c = src [state.cp++];
switch (c) {
/* assertion escapes */
case 'b':
state.result = new RENode (REOP_WBDRY);
state.progLength++;
return true;
case 'B':
state.result = new RENode (REOP_WNONBDRY);
state.progLength++;
return true;
/* Decimal escape */
case '0':
// Under 'strict' ECMA 3, we interpret \0 as NUL and don't accept octal.
// However (and since Rhino doesn't have a 'strict' mode) we'll just
// behave the old way for compatibility reasons.
// (see http://bugzilla.mozilla.org/show_bug.cgi?id=141078)
// TODO: Use strict mode
/* octal escape */
num = 0;
while (state.cp < state.cpend) {
c = src [state.cp];
if ((c >= '0') && (c <= '7')) {
state.cp++;
tmp = 8 * num + (c - '0');
if (tmp > 255)
break;
num = tmp;
}
else
break;
}
c = (char)(num);
doFlat (state, c);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
termStart = state.cp - 1;
num = getDecimalValue (c, state, 0xFFFF, "msg.overlarge.backref");
/*
* n > 9 and > count of parentheses,
* then treat as octal instead.
*/
if ((num > 9) && (num > state.parenCount)) {
state.cp = termStart;
num = 0;
while (state.cp < state.cpend) {
c = src [state.cp];
if ((c >= '0') && (c <= '7')) {
state.cp++;
tmp = 8 * num + (c - '0');
if (tmp > 255)
break;
num = tmp;
}
else
break;
}
c = (char)(num);
doFlat (state, c);
break;
}
/* otherwise, it's a back-reference */
state.result = new RENode (REOP_BACKREF);
state.result.parenIndex = num - 1;
state.progLength += 3;
break;
/* Control escape */
case 'f':
c = (char)(0xC);
doFlat (state, c);
break;
case 'n':
c = (char)(0xA);
doFlat (state, c);
break;
case 'r':
c = (char)(0xD);
doFlat (state, c);
break;
case 't':
c = (char)(0x9);
doFlat (state, c);
break;
case 'v':
c = (char)(0xB);
doFlat (state, c);
break;
/* Control letter */
case 'c':
if ((state.cp < state.cpend) && char.IsLetter (src [state.cp]))
c = (char)(src [state.cp++] & 0x1F);
else {
/* back off to accepting the original '\' as a literal */
--state.cp;
c = '\\';
}
doFlat (state, c);
break;
/* UnicodeEscapeSequence */
case 'u':
nDigits += 2;
// fall thru...
/* HexEscapeSequence */
goto case 'x';
case 'x': {
int n = 0;
int i;
for (i = 0; (i < nDigits) && (state.cp < state.cpend); i++) {
c = src [state.cp++];
n = ScriptConvert.XDigitToInt (c, n);
if (n < 0) {
// Back off to accepting the original
// 'u' or 'x' as a literal
state.cp -= (i + 2);
n = src [state.cp++];
break;
}
}
c = (char)(n);
}
doFlat (state, c);
break;
/* Character class escapes */
case 'd':
state.result = new RENode (REOP_DIGIT);
state.progLength++;
break;
case 'D':
state.result = new RENode (REOP_NONDIGIT);
state.progLength++;
break;
case 's':
state.result = new RENode (REOP_SPACE);
state.progLength++;
break;
case 'S':
state.result = new RENode (REOP_NONSPACE);
state.progLength++;
break;
case 'w':
state.result = new RENode (REOP_ALNUM);
state.progLength++;
break;
case 'W':
state.result = new RENode (REOP_NONALNUM);
state.progLength++;
break;
/* IdentityEscape */
default:
state.result = new RENode (REOP_FLAT);
state.result.chr = c;
state.result.length = 1;
state.result.flatIndex = state.cp - 1;
state.progLength += 3;
break;
}
break;
}
else {
/* a trailing '\' is an error */
reportError ("msg.trail.backslash", "");
return false;
}
case '(': {
RENode result = null;
termStart = state.cp;
if (state.cp + 1 < state.cpend && src [state.cp] == '?' && ((c = src [state.cp + 1]) == '=' || c == '!' || c == ':')) {
state.cp += 2;
if (c == '=') {
result = new RENode (REOP_ASSERT);
/* ASSERT, <next>, ... ASSERTTEST */
state.progLength += 4;
}
else if (c == '!') {
result = new RENode (REOP_ASSERT_NOT);
/* ASSERTNOT, <next>, ... ASSERTNOTTEST */
state.progLength += 4;
}
}
else {
result = new RENode (REOP_LPAREN);
/* LPAREN, <index>, ... RPAREN, <index> */
state.progLength += 6;
result.parenIndex = state.parenCount++;
}
++state.parenNesting;
if (!parseDisjunction (state))
return false;
if (state.cp == state.cpend || src [state.cp] != ')') {
reportError ("msg.unterm.paren", "");
return false;
}
++state.cp;
--state.parenNesting;
if (result != null) {
result.kid = state.result;
state.result = result;
}
break;
}
case ')':
reportError ("msg.re.unmatched.right.paren", "");
return false;
case '[':
state.result = new RENode (REOP_CLASS);
termStart = state.cp;
state.result.startIndex = termStart;
while (true) {
if (state.cp >= state.cpend) {
reportError ("msg.unterm.class", "");
return false;
}
if (src [state.cp] == '\\')
state.cp++;
else {
if (src [state.cp] == ']') {
state.result.kidlen = state.cp - termStart;
break;
}
}
state.cp++;
}
state.result.index = state.classCount++;
/*
* Call calculateBitmapSize now as we want any errors it finds
* to be reported during the parse phase, not at execution.
*/
if (!calculateBitmapSize (state, state.result, src, termStart, state.cp++))
return false;
state.progLength += 3; /* CLASS, <index> */
break;
case '.':
state.result = new RENode (REOP_DOT);
state.progLength++;
break;
case '*':
case '+':
case '?':
reportError ("msg.bad.quant", Convert.ToString (src [state.cp - 1]));
return false;
default:
state.result = new RENode (REOP_FLAT);
state.result.chr = c;
state.result.length = 1;
state.result.flatIndex = state.cp - 1;
state.progLength += 3;
break;
}
term = state.result;
if (state.cp == state.cpend) {
return true;
}
bool hasQ = false;
switch (src [state.cp]) {
case '+':
state.result = new RENode (REOP_QUANT);
state.result.min = 1;
state.result.max = -1;
/* <PLUS>, <parencount>, <parenindex>, <next> ... <ENDCHILD> */
state.progLength += 8;
hasQ = true;
break;
case '*':
state.result = new RENode (REOP_QUANT);
state.result.min = 0;
state.result.max = -1;
/* <STAR>, <parencount>, <parenindex>, <next> ... <ENDCHILD> */
state.progLength += 8;
hasQ = true;
break;
case '?':
state.result = new RENode (REOP_QUANT);
state.result.min = 0;
state.result.max = 1;
/* <OPT>, <parencount>, <parenindex>, <next> ... <ENDCHILD> */
state.progLength += 8;
hasQ = true;
break;
case '{': /* balance '}' */ {
int min = 0;
int max = -1;
int leftCurl = state.cp;
/* For Perl etc. compatibility, if quntifier does not match
* \{\d+(,\d*)?\} exactly back off from it
* being a quantifier, and chew it up as a literal
* atom next time instead.
*/
c = src [++state.cp];
if (isDigit (c)) {
++state.cp;
min = getDecimalValue (c, state, 0xFFFF, "msg.overlarge.min");
c = src [state.cp];
if (c == ',') {
c = src [++state.cp];
if (isDigit (c)) {
++state.cp;
max = getDecimalValue (c, state, 0xFFFF, "msg.overlarge.max");
c = src [state.cp];
if (min > max) {
reportError ("msg.max.lt.min", Convert.ToString (src [state.cp]));
return false;
}
}
}
else {
max = min;
}
/* balance '{' */
if (c == '}') {
state.result = new RENode (REOP_QUANT);
state.result.min = min;
state.result.max = max;
// QUANT, <min>, <max>, <parencount>,
// <parenindex>, <next> ... <ENDCHILD>
state.progLength += 12;
hasQ = true;
if (state.cp + 1 != state.cpend) {
char nc = src [state.cp + 1];
if (nc == '{') {
string quant = string.Empty;
for (int i = 2; state.cp + i != state.cpend; i++) {
if (src [state.cp + i] == '}')
break;
quant += src [state.cp + i];
}
reportError ("msg.bad.quant", quant);
}
}
}
}
if (!hasQ) {
state.cp = leftCurl;
}
break;
}
}
if (!hasQ)
return true;
++state.cp;
state.result.kid = term;
state.result.parenIndex = parenBaseCount;
state.result.parenCount = state.parenCount - parenBaseCount;
if ((state.cp < state.cpend) && (src [state.cp] == '?')) {
++state.cp;
state.result.greedy = false;
}
else
state.result.greedy = true;
return true;
}
internal static object compileRE(string str, string global, bool flat)
{
RECompiled regexp = new RECompiled ();
regexp.source = str.ToCharArray ();
int length = str.Length;
int flags = 0;
if (global != null) {
for (int i = 0; i < global.Length; i++) {
char c = global [i];
if (c == 'g') {
flags |= JSREG_GLOB;
}
else if (c == 'i') {
flags |= JSREG_FOLD;
}
else if (c == 'm') {
flags |= JSREG_MULTILINE;
}
else {
reportError ("msg.invalid.re.flag", Convert.ToString (c));
}
}
}
regexp.flags = flags;
CompilerState state = new CompilerState (regexp.source, length, flags);
if (flat && length > 0) {
if (debug) {
System.Console.Out.WriteLine ("flat = \"" + str + "\"");
}
state.result = new RENode (REOP_FLAT);
state.result.chr = state.cpbegin [0];
state.result.length = length;
state.result.flatIndex = 0;
state.progLength += 5;
}
else if (!parseDisjunction (state))
return null;
regexp.program = new sbyte [state.progLength + 1];
if (state.classCount != 0) {
regexp.classList = new RECharSet [state.classCount];
regexp.classCount = state.classCount;
}
int endPC = emitREBytecode (state, regexp, 0, state.result);
regexp.program [endPC++] = REOP_END;
if (debug) {
System.Console.Out.WriteLine ("Prog. length = " + endPC);
for (int i = 0; i < endPC; i++) {
System.Console.Out.Write (DebugNameOp ((sbyte)regexp.program [i]));
if (i < (endPC - 1))
System.Console.Out.Write (", ");
}
System.Console.Out.WriteLine ();
}
regexp.parenCount = state.parenCount;
// If re starts with literal, init anchorCh accordingly
switch (regexp.program [0]) {
case REOP_UCFLAT1:
case REOP_UCFLAT1i:
regexp.anchorCh = (char)getIndex (regexp.program, 1);
break;
case REOP_FLAT1:
case REOP_FLAT1i:
regexp.anchorCh = (char)(regexp.program [1] & 0xFF);
break;
case REOP_FLAT:
case REOP_FLATi:
int k = getIndex (regexp.program, 1);
regexp.anchorCh = regexp.source [k];
break;
}
if (debug) {
if (regexp.anchorCh >= 0) {
System.Console.Out.WriteLine ("Anchor ch = '" + (char)regexp.anchorCh + "'");
}
}
return regexp;
}
/*
* Top-down regular expression grammar, based closely on Perl4.
*
* regexp: altern A regular expression is one or more
* altern '|' regexp alternatives separated by vertical bar.
*/
private static bool parseDisjunction(CompilerState state)
{
using (Helpers.StackOverflowVerifier sov = new Helpers.StackOverflowVerifier (1024)) {
if (!parseAlternative (state))
return false;
char [] source = state.cpbegin;
int index = state.cp;
if (index != source.Length && source [index] == '|') {
RENode altResult;
++state.cp;
altResult = new RENode (REOP_ALT);
altResult.kid = state.result;
if (!parseDisjunction (state))
return false;
altResult.kid2 = state.result;
state.result = altResult;
/* ALT, <next>, ..., JUMP, <end> ... JUMP <end> */
state.progLength += 9;
}
return true;
}
}
/*
* altern: item An alternative is one or more items,
* item altern concatenated together.
*/
private static bool parseAlternative(CompilerState state)
{
RENode headTerm = null;
RENode tailTerm = null;
char [] source = state.cpbegin;
while (true) {
if (state.cp == state.cpend || source [state.cp] == '|' || (state.parenNesting != 0 && source [state.cp] == ')')) {
if (headTerm == null) {
state.result = new RENode (REOP_EMPTY);
}
else
state.result = headTerm;
return true;
}
if (!parseTerm (state))
return false;
if (headTerm == null)
headTerm = state.result;
else {
if (tailTerm == null) {
headTerm.next = state.result;
tailTerm = state.result;
while (tailTerm.next != null)
tailTerm = tailTerm.next;
}
else {
tailTerm.next = state.result;
tailTerm = tailTerm.next;
while (tailTerm.next != null)
tailTerm = tailTerm.next;
}
}
}
}
private static int getDecimalValue(char c, CompilerState state, int maxValue, string overflowMessageId)
{
bool overflow = false;
int start = state.cp;
char [] src = state.cpbegin;
int value = c - '0';
for (; state.cp != state.cpend; ++state.cp) {
c = src [state.cp];
if (!isDigit (c)) {
break;
}
if (!overflow) {
int digit = c - '0';
if (value < (maxValue - digit) / 10) {
value = value * 10 + digit;
}
else {
overflow = true;
value = maxValue;
}
}
}
if (overflow) {
reportError (overflowMessageId, new string (src, start, state.cp - start));
}
return value;
}
private static int emitREBytecode(CompilerState state, RECompiled re, int pc, RENode t)
{
RENode nextAlt;
int nextAltFixup, nextTermFixup;
sbyte [] program = re.program;
while (t != null) {
program [pc++] = t.op;
switch (t.op) {
case REOP_EMPTY:
--pc;
break;
case REOP_ALT:
nextAlt = t.kid2;
nextAltFixup = pc; /* address of next alternate */
pc += OFFSET_LEN;
pc = emitREBytecode (state, re, pc, t.kid);
program [pc++] = REOP_JUMP;
nextTermFixup = pc; /* address of following term */
pc += OFFSET_LEN;
resolveForwardJump (program, nextAltFixup, pc);
pc = emitREBytecode (state, re, pc, nextAlt);
program [pc++] = REOP_JUMP;
nextAltFixup = pc;
pc += OFFSET_LEN;
resolveForwardJump (program, nextTermFixup, pc);
resolveForwardJump (program, nextAltFixup, pc);
break;
case REOP_FLAT:
/*
* Consecutize FLAT's if possible.
*/
if (t.flatIndex != -1) {
while ((t.next != null) && (t.next.op == REOP_FLAT) && ((t.flatIndex + t.length) == t.next.flatIndex)) {
t.length += t.next.length;
t.next = t.next.next;
}
}
if ((t.flatIndex != -1) && (t.length > 1)) {
if ((state.flags & JSREG_FOLD) != 0)
program [pc - 1] = REOP_FLATi;
else
program [pc - 1] = REOP_FLAT;
pc = addIndex (program, pc, t.flatIndex);
pc = addIndex (program, pc, t.length);
}
else {
if (t.chr < 256) {
if ((state.flags & JSREG_FOLD) != 0)
program [pc - 1] = REOP_FLAT1i;
else
program [pc - 1] = REOP_FLAT1;
program [pc++] = (sbyte)(t.chr);
}
else {
if ((state.flags & JSREG_FOLD) != 0)
program [pc - 1] = REOP_UCFLAT1i;
else
program [pc - 1] = REOP_UCFLAT1;
pc = addIndex (program, pc, t.chr);
}
}
break;
case REOP_LPAREN:
pc = addIndex (program, pc, t.parenIndex);
pc = emitREBytecode (state, re, pc, t.kid);
program [pc++] = REOP_RPAREN;
pc = addIndex (program, pc, t.parenIndex);
break;
case REOP_BACKREF:
pc = addIndex (program, pc, t.parenIndex);
break;
case REOP_ASSERT:
nextTermFixup = pc;
pc += OFFSET_LEN;
pc = emitREBytecode (state, re, pc, t.kid);
program [pc++] = REOP_ASSERTTEST;
resolveForwardJump (program, nextTermFixup, pc);
break;
case REOP_ASSERT_NOT:
nextTermFixup = pc;
pc += OFFSET_LEN;
pc = emitREBytecode (state, re, pc, t.kid);
program [pc++] = REOP_ASSERTNOTTEST;
resolveForwardJump (program, nextTermFixup, pc);
break;
case REOP_QUANT:
if ((t.min == 0) && (t.max == -1))
program [pc - 1] = (t.greedy) ? REOP_STAR : REOP_MINIMALSTAR;
else if ((t.min == 0) && (t.max == 1))
program [pc - 1] = (t.greedy) ? REOP_OPT : REOP_MINIMALOPT;
else if ((t.min == 1) && (t.max == -1))
program [pc - 1] = (t.greedy) ? REOP_PLUS : REOP_MINIMALPLUS;
else {
if (!t.greedy)
program [pc - 1] = REOP_MINIMALQUANT;
pc = addIndex (program, pc, t.min);
// max can be -1 which addIndex does not accept
pc = addIndex (program, pc, t.max + 1);
}
pc = addIndex (program, pc, t.parenCount);
pc = addIndex (program, pc, t.parenIndex);
nextTermFixup = pc;
pc += OFFSET_LEN;
pc = emitREBytecode (state, re, pc, t.kid);
program [pc++] = REOP_ENDCHILD;
resolveForwardJump (program, nextTermFixup, pc);
break;
case REOP_CLASS:
pc = addIndex (program, pc, t.index);
re.classList [t.index] = new RECharSet (t.bmsize, t.startIndex, t.kidlen);
break;
default:
break;
}
t = t.next;
}
return pc;
}
/*
* item: assertion An item is either an assertion or
* quantatom a quantified atom.
*
* assertion: '^' Assertions match beginning of string
* (or line if the class static property
* RegExp.multiline is true).
* '$' End of string (or line if the class
* static property RegExp.multiline is
* true).
* '\b' Word boundary (between \w and \W).
* '\B' Word non-boundary.
*
* quantatom: atom An unquantified atom.
* quantatom '{' n ',' m '}'
* Atom must occur between n and m times.
* quantatom '{' n ',' '}' Atom must occur at least n times.
* quantatom '{' n '}' Atom must occur exactly n times.
* quantatom '*' Zero or more times (same as {0,}).
* quantatom '+' One or more times (same as {1,}).
* quantatom '?' Zero or one time (same as {0,1}).
*
* any of which can be optionally followed by '?' for ungreedy
*
* atom: '(' regexp ')' A parenthesized regexp (what matched
* can be addressed using a backreference,
* see '\' n below).
* '.' Matches any char except '\n'.
* '[' classlist ']' A character class.
* '[' '^' classlist ']' A negated character class.
* '\f' Form Feed.
* '\n' Newline (Line Feed).
* '\r' Carriage Return.
* '\t' Horizontal Tab.
* '\v' Vertical Tab.
* '\d' A digit (same as [0-9]).
* '\D' A non-digit.
* '\w' A word character, [0-9a-z_A-Z].
* '\W' A non-word character.
* '\s' A whitespace character, [ \b\f\n\r\t\v].
* '\S' A non-whitespace character.
* '\' n A backreference to the nth (n decimal
* and positive) parenthesized expression.
* '\' octal An octal escape sequence (octal must be
* two or three digits long, unless it is
* 0 for the null character).
* '\x' hex A hex escape (hex must be two digits).
* '\c' ctrl A control character, ctrl is a letter.
* '\' literalatomchar Any character except one of the above
* that follow '\' in an atom.
* otheratomchar Any character not first among the other
* atom right-hand sides.
*/
private static void doFlat(CompilerState state, char c)
{
state.result = new RENode (REOP_FLAT);
state.result.chr = c;
state.result.length = 1;
state.result.flatIndex = -1;
state.progLength += 3;
}