From 466cd55c399b5b7a6ae922432f38dee204dc5001 Mon Sep 17 00:00:00 2001 From: megacz Date: Fri, 30 Jan 2004 07:01:09 +0000 Subject: [PATCH] 2003/06/13 09:47:17 darcs-hash:20040130070109-2ba56-064c1744e41e09a531715e6196efe3142f4249f1.gz --- src/org/xwt/js/Parser.java | 1111 ++++++++++++++++++++++---------------------- 1 file changed, 551 insertions(+), 560 deletions(-) diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java index f5ddd42..e82b408 100644 --- a/src/org/xwt/js/Parser.java +++ b/src/org/xwt/js/Parser.java @@ -2,6 +2,7 @@ package org.xwt.js; // FIXME: line number accuracy +// FIXME: scope management import org.xwt.util.*; import java.io.*; @@ -61,9 +62,9 @@ class Parser extends Lexer implements ByteCodes { /** for debugging */ public static void main(String[] s) throws Exception { - CompiledFunction block = new CompiledFunction("stdin", 0, new InputStreamReader(System.in), null); - if (block == null) return; - System.out.println(block); + CompiledFunction block = new CompiledFunction("stdin", 0, new InputStreamReader(System.in), null); + if (block == null) return; + System.out.println(block); } @@ -72,27 +73,27 @@ class Parser extends Lexer implements ByteCodes { static byte[] precedence = new byte[MAX_TOKEN + 1]; static boolean[] isRightAssociative = new boolean[MAX_TOKEN + 1]; static { - isRightAssociative[ASSIGN] = true; - - precedence[ASSIGN] = 1; - precedence[HOOK] = 2; - precedence[COMMA] = 3; - precedence[OR] = precedence[AND] = 4; - precedence[GT] = precedence[GE] = 5; - precedence[BITOR] = 6; - precedence[BITXOR] = 7; - precedence[BITAND] = 8; - precedence[EQ] = precedence[NE] = 9; - precedence[LT] = precedence[LE] = 10; - precedence[SHEQ] = precedence[SHNE] = 11; - precedence[LSH] = precedence[RSH] = precedence[URSH] = 12; - precedence[ADD] = precedence[SUB] = 13; - precedence[MUL] = precedence[DIV] = precedence[MOD] = 14; - precedence[BITNOT] = 15; - precedence[INC] = precedence[DEC] = 16; - precedence[LP] = 17; - precedence[LB] = 18; - precedence[DOT] = 19; + isRightAssociative[ASSIGN] = true; + + precedence[ASSIGN] = 1; + precedence[HOOK] = 2; + precedence[COMMA] = 3; + precedence[OR] = precedence[AND] = 4; + precedence[GT] = precedence[GE] = 5; + precedence[BITOR] = 6; + precedence[BITXOR] = 7; + precedence[BITAND] = 8; + precedence[EQ] = precedence[NE] = 9; + precedence[LT] = precedence[LE] = 10; + precedence[SHEQ] = precedence[SHNE] = 11; + precedence[LSH] = precedence[RSH] = precedence[URSH] = 12; + precedence[ADD] = precedence[SUB] = 13; + precedence[MUL] = precedence[DIV] = precedence[MOD] = 14; + precedence[BITNOT] = 15; + precedence[INC] = precedence[DEC] = 16; + precedence[LP] = 17; + precedence[LB] = 18; + precedence[DOT] = 19; } @@ -100,7 +101,7 @@ class Parser extends Lexer implements ByteCodes { /** gets a token and throws an exception if it is not code */ private void consume(int code) throws IOException { - if (getToken() != code) throw new ParserException("expected " + codeToString[code] + ", got " + (op == -1 ? "EOF" : codeToString[op])); + if (getToken() != code) throw new ParserException("expected " + codeToString[code] + ", got " + (op == -1 ? "EOF" : codeToString[op])); } /** @@ -110,156 +111,156 @@ class Parser extends Lexer implements ByteCodes { * appended bytecodes MUST grow the stack by exactly one element. */ private void startExpr(CompiledFunction appendTo, int minPrecedence) throws IOException { - int tok = getToken(); - CompiledFunction b = appendTo; + int tok = getToken(); + CompiledFunction b = appendTo; - switch (tok) { - case -1: throw new ParserException("expected expression"); + switch (tok) { + case -1: throw new ParserException("expected expression"); // all of these simply push values onto the stack - case NUMBER: b.add(line, LITERAL, number); break; - case STRING: b.add(line, LITERAL, string); break; - case THIS: b.add(line, TOPSCOPE, null); break; - case NULL: b.add(line, LITERAL, null); break; - case TRUE: case FALSE: b.add(line, LITERAL, new Boolean(tok == TRUE)); break; - - case LB: { - b.add(line, ARRAY, new Integer(0)); // push an array onto the stack - int size0 = b.size(); - int i = 0; - if (peekToken() != RB) - while(true) { // iterate over the initialization values - int size = b.size(); - if (peekToken() == COMMA || peekToken() == RB) - b.add(line, LITERAL, null); // for stuff like [1,,2,] - else - startExpr(b, -1); // push the value onto the stack - b.add(line, LITERAL, new Integer(i++)); // push the index in the array to place it into - b.add(line, PUT); // put it into the array - b.add(line, POP); // discard the value remaining on the stack - if (peekToken() == RB) break; - consume(COMMA); - } - b.set(size0 - 1, new Integer(i)); // back at the ARRAY instruction, write the size of the array - consume(RB); - break; - } - case SUB: { // negative literal (like "3 * -1") - consume(NUMBER); - b.add(line, LITERAL, new Double(number.doubleValue() * -1)); - break; - } - case LP: { // grouping (not calling) - startExpr(b, -1); - consume(RP); - break; - } - case INC: case DEC: { // prefix (not postfix) - startExpr(b, precedence[tok]); - b.set(b.size() - 1, tok, new Boolean(true)); // FIXME, ugly; need startAssignTarget - break; - } - case BANG: case BITNOT: case TYPEOF: { - startExpr(b, precedence[tok]); - b.add(line, tok); - break; - } - case LC: { // object constructor - b.add(line, OBJECT, null); // put an object on the stack - if (peekToken() != RC) - while(true) { - if (peekToken() != NAME && peekToken() != STRING) - throw new ParserException("expected NAME or STRING"); - getToken(); - b.add(line, LITERAL, string); // grab the key - consume(COLON); - startExpr(b, -1); // grab the value - b.add(line, PUT); // put the value into the object - b.add(line, POP); // discard the remaining value - if (peekToken() == RC) break; - consume(COMMA); - if (peekToken() == RC) break; // we permit {,,} -- I'm not sure if ECMA does - } - consume(RC); - break; - } - case NAME: { // FIXME; this is an lvalue - String name = string; - if (peekToken() == ASSIGN) { - consume(ASSIGN); - b.add(line, TOPSCOPE); - b.add(line, LITERAL, name); - startExpr(b, minPrecedence); - b.add(line, PUT); - b.add(line, SWAP); - b.add(line, POP); - } else { - b.add(line, TOPSCOPE); - b.add(line, LITERAL, name); - b.add(line, GET); - } - break; - } - case FUNCTION: { - consume(LP); - int numArgs = 0; - CompiledFunction b2 = new CompiledFunction(sourceName, line, null); - b.add(line, NEWFUNCTION, b2); - - // function prelude; arguments array is already on the stack - b2.add(line, TOPSCOPE); // push the scope onto the stack - b2.add(line, SWAP); // swap 'this' and 'arguments' - - b2.add(line, LITERAL, "arguments"); // declare arguments (equivalent to 'var arguments;') - b2.add(line, DECLARE); - - b2.add(line, LITERAL, "arguments"); // set this.arguments and leave the value on the stack - b2.add(line, SWAP); - b2.add(line, PUT); - b2.add(line, SWAP); - b2.add(line, POP); - - while(peekToken() != RP) { // run through the list of argument names - if (peekToken() == NAME) { - consume(NAME); // a named argument - - b2.add(line, LITERAL, string); // declare the name - b2.add(line, DECLARE); - - b2.add(line, LITERAL, new Integer(numArgs)); // retrieve it from the arguments array - b2.add(line, GET_PRESERVE); - b2.add(line, SWAP); - b2.add(line, POP); - - b2.add(line, TOPSCOPE); // put it to the current scope - b2.add(line, SWAP); - b2.add(line, LITERAL, string); - b2.add(line, SWAP); - b2.add(line, PUT); - - b2.add(line, POP); // clean the stack - b2.add(line, POP); - } - if (peekToken() == RP) break; - consume(COMMA); - numArgs++; - } - consume(RP); - - b2.add(line, POP); // pop off the arguments array - - parseStatement(b2, null); // the function body - - b2.add(line, LITERAL, null); // in case we "fall out the bottom", return NULL - b2.add(line, RETURN); - - break; - } - default: throw new ParserException("expected expression, found " + codeToString[tok] + ", which cannot start an expression"); - } - - // attempt to continue the expression - continueExpr(b, minPrecedence); + case NUMBER: b.add(line, LITERAL, number); break; + case STRING: b.add(line, LITERAL, string); break; + case THIS: b.add(line, TOPSCOPE, null); break; + case NULL: b.add(line, LITERAL, null); break; + case TRUE: case FALSE: b.add(line, LITERAL, new Boolean(tok == TRUE)); break; + + case LB: { + b.add(line, ARRAY, new Integer(0)); // push an array onto the stack + int size0 = b.size(); + int i = 0; + if (peekToken() != RB) + while(true) { // iterate over the initialization values + int size = b.size(); + if (peekToken() == COMMA || peekToken() == RB) + b.add(line, LITERAL, null); // for stuff like [1,,2,] + else + startExpr(b, -1); // push the value onto the stack + b.add(line, LITERAL, new Integer(i++)); // push the index in the array to place it into + b.add(line, PUT); // put it into the array + b.add(line, POP); // discard the value remaining on the stack + if (peekToken() == RB) break; + consume(COMMA); + } + b.set(size0 - 1, new Integer(i)); // back at the ARRAY instruction, write the size of the array + consume(RB); + break; + } + case SUB: { // negative literal (like "3 * -1") + consume(NUMBER); + b.add(line, LITERAL, new Double(number.doubleValue() * -1)); + break; + } + case LP: { // grouping (not calling) + startExpr(b, -1); + consume(RP); + break; + } + case INC: case DEC: { // prefix (not postfix) + startExpr(b, precedence[tok]); + b.set(b.size() - 1, tok, new Boolean(true)); // FIXME, ugly; need startAssignTarget + break; + } + case BANG: case BITNOT: case TYPEOF: { + startExpr(b, precedence[tok]); + b.add(line, tok); + break; + } + case LC: { // object constructor + b.add(line, OBJECT, null); // put an object on the stack + if (peekToken() != RC) + while(true) { + if (peekToken() != NAME && peekToken() != STRING) + throw new ParserException("expected NAME or STRING"); + getToken(); + b.add(line, LITERAL, string); // grab the key + consume(COLON); + startExpr(b, -1); // grab the value + b.add(line, PUT); // put the value into the object + b.add(line, POP); // discard the remaining value + if (peekToken() == RC) break; + consume(COMMA); + if (peekToken() == RC) break; // we permit {,,} -- I'm not sure if ECMA does + } + consume(RC); + break; + } + case NAME: { // FIXME; this is an lvalue + String name = string; + if (peekToken() == ASSIGN) { + consume(ASSIGN); + b.add(line, TOPSCOPE); + b.add(line, LITERAL, name); + startExpr(b, minPrecedence); + b.add(line, PUT); + b.add(line, SWAP); + b.add(line, POP); + } else { + b.add(line, TOPSCOPE); + b.add(line, LITERAL, name); + b.add(line, GET); + } + break; + } + case FUNCTION: { + consume(LP); + int numArgs = 0; + CompiledFunction b2 = new CompiledFunction(sourceName, line, null); + b.add(line, NEWFUNCTION, b2); + + // function prelude; arguments array is already on the stack + b2.add(line, TOPSCOPE); // push the scope onto the stack + b2.add(line, SWAP); // swap 'this' and 'arguments' + + b2.add(line, LITERAL, "arguments"); // declare arguments (equivalent to 'var arguments;') + b2.add(line, DECLARE); + + b2.add(line, LITERAL, "arguments"); // set this.arguments and leave the value on the stack + b2.add(line, SWAP); + b2.add(line, PUT); + b2.add(line, SWAP); + b2.add(line, POP); + + while(peekToken() != RP) { // run through the list of argument names + if (peekToken() == NAME) { + consume(NAME); // a named argument + + b2.add(line, LITERAL, string); // declare the name + b2.add(line, DECLARE); + + b2.add(line, LITERAL, new Integer(numArgs)); // retrieve it from the arguments array + b2.add(line, GET_PRESERVE); + b2.add(line, SWAP); + b2.add(line, POP); + + b2.add(line, TOPSCOPE); // put it to the current scope + b2.add(line, SWAP); + b2.add(line, LITERAL, string); + b2.add(line, SWAP); + b2.add(line, PUT); + + b2.add(line, POP); // clean the stack + b2.add(line, POP); + } + if (peekToken() == RP) break; + consume(COMMA); + numArgs++; + } + consume(RP); + + b2.add(line, POP); // pop off the arguments array + + parseStatement(b2, null); // the function body + + b2.add(line, LITERAL, null); // in case we "fall out the bottom", return NULL + b2.add(line, RETURN); + + break; + } + default: throw new ParserException("expected expression, found " + codeToString[tok] + ", which cannot start an expression"); + } + + // attempt to continue the expression + continueExpr(b, minPrecedence); } /** @@ -274,405 +275,395 @@ class Parser extends Lexer implements ByteCodes { * depth. */ private void continueExpr(CompiledFunction b, int minPrecedence) throws IOException { - if (b == null) throw new Error("got null b; this should never happen"); - int tok = getToken(); - if (tok == -1) return; - if (minPrecedence != -1 && (precedence[tok] < minPrecedence || (precedence[tok] == minPrecedence && !isRightAssociative[tok]))) { - pushBackToken(); - return; - } - - switch (tok) { + if (b == null) throw new Error("got null b; this should never happen"); + int tok = getToken(); + if (tok == -1) return; + if (minPrecedence != -1 && (precedence[tok] < minPrecedence || (precedence[tok] == minPrecedence && !isRightAssociative[tok]))) { + pushBackToken(); + return; + } + + switch (tok) { case ASSIGN_BITOR: case ASSIGN_BITXOR: case ASSIGN_BITAND: case ASSIGN_LSH: case ASSIGN_RSH: case ASSIGN_URSH: - case ASSIGN_ADD: case ASSIGN_SUB: case ASSIGN_MUL: case ASSIGN_DIV: case ASSIGN_MOD: { - b.set(b.size() - 1, b.GET_PRESERVE, new Boolean(true)); // FIXME should use AssignTarget - startExpr(b, precedence[tok - 1]); - b.add(line, tok - 1); - b.add(line, PUT); - b.add(line, SWAP); - b.add(line, POP); - break; - } - case INC: case DEC: { // postfix - b.set(b.size() - 1, tok, new Boolean(false)); // FIXME use assignmenttarget - break; - } - case LP: { // invocation (not grouping) - int i = 0; - while(peekToken() != RP) { - i++; - if (peekToken() != COMMA) { - startExpr(b, -1); - if (peekToken() == RP) break; - } - consume(COMMA); - } - consume(RP); - b.add(line, CALL, new Integer(i)); - break; - } + case ASSIGN_ADD: case ASSIGN_SUB: case ASSIGN_MUL: case ASSIGN_DIV: case ASSIGN_MOD: { + b.set(b.size() - 1, b.GET_PRESERVE, new Boolean(true)); // FIXME should use AssignTarget + startExpr(b, precedence[tok - 1]); + b.add(line, tok - 1); + b.add(line, PUT); + b.add(line, SWAP); + b.add(line, POP); + break; + } + case INC: case DEC: { // postfix + b.set(b.size() - 1, tok, new Boolean(false)); // FIXME use assignmenttarget + break; + } + case LP: { // invocation (not grouping) + int i = 0; + while(peekToken() != RP) { + i++; + if (peekToken() != COMMA) { + startExpr(b, -1); + if (peekToken() == RP) break; + } + consume(COMMA); + } + consume(RP); + b.add(line, CALL, new Integer(i)); + break; + } case BITOR: case BITXOR: case BITAND: case SHEQ: case SHNE: case LSH: - case RSH: case URSH: case ADD: case MUL: case DIV: case MOD: - case GT: case GE: case EQ: case NE: case LT: case LE: case SUB: { - startExpr(b, precedence[tok]); - b.add(line, tok); - break; - } - case OR: case AND: { - b.add(line, tok == AND ? b.JF : b.JT, new Integer(0)); // test to see if we can short-circuit - int size = b.size(); - startExpr(b, precedence[tok]); // otherwise check the second value - b.add(line, JMP, new Integer(2)); // leave the second value on the stack and jump to the end - b.add(line, LITERAL, tok == AND ? new Boolean(false) : new Boolean(true)); // target of the short-circuit jump is here - b.set(size - 1, new Integer(b.size() - size)); // write the target of the short-circuit jump - break; - } - case DOT: { // FIXME, assigntarget - consume(NAME); - String target = string; - if (peekToken() == ASSIGN) { - consume(ASSIGN); - b.add(line, LITERAL, target); - startExpr(b, -1); - b.add(line, PUT); - b.add(line, SWAP); - b.add(line, POP); - } else { - b.add(line, LITERAL, target); - b.add(line, GET); - } - break; - } - case LB: { // subscripting (not array constructor) - startExpr(b, -1); - consume(RB); - if (peekToken() == ASSIGN) { // FIXME: assigntarget - consume(ASSIGN); - startExpr(b, -1); - b.add(line, PUT); - b.add(line, SWAP); - b.add(line, POP); - } else { - b.add(line, GET); - } - break; - } - case HOOK: { - b.add(line, JF, new Integer(0)); // jump to the if-false expression - int size = b.size(); - startExpr(b, -1); // write the if-true expression - b.add(line, JMP, new Integer(0)); // if true, jump *over* the if-false expression - b.set(size - 1, new Integer(b.size() - size + 1)); // now we know where the target of the jump is - consume(COLON); - size = b.size(); - startExpr(b, -1); // write the if-false expression - b.set(size - 1, new Integer(b.size() - size + 1)); // this is the end; jump to here - break; - } - default: { - pushBackToken(); - return; - } - } - - continueExpr(b, minPrecedence); // try to continue the expression + case RSH: case URSH: case ADD: case MUL: case DIV: case MOD: + case GT: case GE: case EQ: case NE: case LT: case LE: case SUB: { + startExpr(b, precedence[tok]); + b.add(line, tok); + break; + } + case OR: case AND: { + b.add(line, tok == AND ? b.JF : b.JT, new Integer(0)); // test to see if we can short-circuit + int size = b.size(); + startExpr(b, precedence[tok]); // otherwise check the second value + b.add(line, JMP, new Integer(2)); // leave the second value on the stack and jump to the end + b.add(line, LITERAL, tok == AND ? new Boolean(false) : new Boolean(true)); // target of the short-circuit jump is here + b.set(size - 1, new Integer(b.size() - size)); // write the target of the short-circuit jump + break; + } + case DOT: { // FIXME, assigntarget + consume(NAME); + String target = string; + if (peekToken() == ASSIGN) { + consume(ASSIGN); + b.add(line, LITERAL, target); + startExpr(b, -1); + b.add(line, PUT); + b.add(line, SWAP); + b.add(line, POP); + } else { + b.add(line, LITERAL, target); + b.add(line, GET); + } + break; + } + case LB: { // subscripting (not array constructor) + startExpr(b, -1); + consume(RB); + if (peekToken() == ASSIGN) { // FIXME: assigntarget + consume(ASSIGN); + startExpr(b, -1); + b.add(line, PUT); + b.add(line, SWAP); + b.add(line, POP); + } else { + b.add(line, GET); + } + break; + } + case HOOK: { + b.add(line, JF, new Integer(0)); // jump to the if-false expression + int size = b.size(); + startExpr(b, -1); // write the if-true expression + b.add(line, JMP, new Integer(0)); // if true, jump *over* the if-false expression + b.set(size - 1, new Integer(b.size() - size + 1)); // now we know where the target of the jump is + consume(COLON); + size = b.size(); + startExpr(b, -1); // write the if-false expression + b.set(size - 1, new Integer(b.size() - size + 1)); // this is the end; jump to here + break; + } + default: { + pushBackToken(); + return; + } + } + + continueExpr(b, minPrecedence); // try to continue the expression } /** Parse a block of statements which must be surrounded by LC..RC. */ void parseBlock(CompiledFunction b) throws IOException { parseBlock(b, null); } void parseBlock(CompiledFunction b, String label) throws IOException { - if (peekToken() == -1) return; - else if (peekToken() != LC) parseStatement(b, null); - else { - consume(LC); - while(peekToken() != RC && peekToken() != -1) parseStatement(b, null); - consume(RC); - } + if (peekToken() == -1) return; + else if (peekToken() != LC) parseStatement(b, null); + else { + consume(LC); + while(peekToken() != RC && peekToken() != -1) parseStatement(b, null); + consume(RC); + } } /** Parse a single statement, consuming the RC or SEMI which terminates it. */ void parseStatement(CompiledFunction b, String label) throws IOException { - int tok = peekToken(); - if (tok == -1) return; - switch(tok = getToken()) { - - case THROW: case ASSERT: case RETURN: { - if (tok == RETURN && peekToken() == SEMI) b.add(line, LITERAL, null); - else startExpr(b, -1); - b.add(line, tok); - consume(SEMI); - break; - } - - case BREAK: case CONTINUE: { - if (peekToken() == NAME) consume(NAME); - b.add(line, tok, string); - consume(SEMI); - break; - } - - case VAR: { - b.add(line, TOPSCOPE); // push the current scope - while(true) { - consume(NAME); - String name = string; - b.add(line, LITERAL, name); // push the name to be declared - b.add(line, DECLARE); // declare it - if (peekToken() == ASSIGN) { // if there is an '=' after the variable name - b.add(line, LITERAL, name); // put the var name back on the stack - consume(ASSIGN); - startExpr(b, -1); - b.add(line, PUT); - b.add(line, POP); - } - if (peekToken() != COMMA) break; - consume(COMMA); - } - b.add(line, POP); - if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1) consume(SEMI); - break; - } - - case IF: { - consume(LP); - startExpr(b, -1); - consume(RP); - - b.add(line, JF, new Integer(0)); - int size = b.size(); - parseStatement(b, null); - - if (peekToken() == ELSE) { - consume(ELSE); - b.set(size - 1, new Integer(2 + b.size() - size)); - b.add(line, JMP, new Integer(0)); - size = b.size(); - parseStatement(b, null); - } - b.set(size - 1, new Integer(1 + b.size() - size)); - break; - } - - case WHILE: { - consume(LP); - if (label != null) b.add(line, LABEL, label); - b.add(line, LOOP); - int size = b.size(); - b.add(line, POP); - startExpr(b, -1); - b.add(line, JT, new Integer(2)); - b.add(line, BREAK); - consume(RP); - parseStatement(b, null); - b.add(line, CONTINUE); // if we fall out of the end, definately continue - b.set(size - 1, new Integer(b.size() - size + 1)); // end of the loop - break; - } - - case SWITCH: { - consume(LP); - if (label != null) b.add(line, LABEL, label); - b.add(line, LOOP); - int size0 = b.size(); - startExpr(b, -1); - consume(RP); - consume(LC); - while(true) - if (peekToken() == CASE) { - consume(CASE); - b.add(line, DUP); - startExpr(b, -1); - consume(COLON); - b.add(line, EQ); - b.add(line, JF, new Integer(0)); - int size = b.size(); - while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) { - int size2 = b.size(); - parseStatement(b, null); - if (size2 == b.size()) break; - } - b.set(size - 1, new Integer(1 + b.size() - size)); - } else if (peekToken() == DEFAULT) { - consume(DEFAULT); - consume(COLON); - while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) { - int size2 = b.size(); - parseStatement(b, null); - if (size2 == b.size()) break; - } - } else if (peekToken() == RC) { - consume(RC); - b.add(line, BREAK); - break; - } else { - throw new ParserException("expected CASE, DEFAULT, or RC; got " + codeToString[peekToken()]); - } - b.add(line, BREAK); - b.set(size0 - 1, new Integer(b.size() - size0 + 1)); // end of the loop - break; - } - - case DO: { - if (label != null) b.add(line, LABEL, label); - b.add(line, LOOP); - int size = b.size(); - parseStatement(b, null); - consume(WHILE); - consume(LP); - startExpr(b, -1); - b.add(line, JT, new Integer(2)); - b.add(line, BREAK); - b.add(line, CONTINUE); - consume(RP); - consume(SEMI); - b.set(size - 1, new Integer(b.size() - size + 1)); // end of the loop - break; - } - - case TRY: { - // We deliberately allow you to omit braces in catch{}/finally{} if they are single statements... - b.add(line, TRY); - int size = b.size(); - parseBlock(b, null); - b.add(line, POP); // pop the TryMarker - b.add(line, JMP); // jump forward to the end of the catch block - int size2 = b.size(); - b.set(size - 1, new Integer(b.size() - size + 1));// the TRY argument points at the start of the CATCH block - - if (peekToken() == CATCH) { - getToken(); - consume(LP); - consume(NAME); - consume(RP); - // FIXME, we need an extra scope here - b.add(line, TOPSCOPE); // the exception is on top of the stack; put it to the variable - b.add(line, SWAP); - b.add(line, LITERAL); - b.add(line, SWAP); - b.add(line, PUT); - b.add(line, POP); - b.add(line, POP); - parseStatement(b, null); - } - - b.set(size2 - 1, new Integer(b.size() - size2 + 1)); // jump here if no exception was thrown - - // FIXME: not implemented correctly - if (peekToken() == FINALLY) { - consume(FINALLY); - parseStatement(b, null); - } - break; - } - - case FOR: { - consume(LP); - - tok = getToken(); - boolean hadVar = false; - if (tok == VAR) { hadVar = true; tok = getToken(); } - String varName = string; - boolean forIn = peekToken() == IN; - pushBackToken(tok, varName); - - if (forIn) { - // FIXME: break needs to work in here - consume(NAME); - consume(IN); - startExpr(b, -1); - b.add(line, PUSHKEYS); - b.add(line, LITERAL, "length"); - b.add(line, GET); - consume(RP); - CompiledFunction b2 = new CompiledFunction(sourceName, line, null); - - b.add(line, NEWSCOPE); - - b.add(line, LITERAL, new Integer(1)); - b.add(line, SUB); - b.add(line, DUP); - b.add(line, LITERAL, new Integer(0)); - b.add(line, LT); - b.add(line, JT, new Integer(7)); - b.add(line, GET_PRESERVE); - b.add(line, LITERAL, varName); - b.add(line, LITERAL, varName); - b.add(line, DECLARE); - b.add(line, PUT); - parseStatement(b, null); - - b.add(line, OLDSCOPE); - - break; - - } else { - if (hadVar) pushBackToken(VAR, null); - b.add(line, NEWSCOPE); - - parseStatement(b, null); - CompiledFunction e2 = new CompiledFunction(sourceName, line, null); - if (peekToken() != SEMI) { - startExpr(e2, -1); - } else { - e2.add(line, b.LITERAL, Boolean.TRUE); - } - consume(SEMI); - if (label != null) b.add(line, LABEL, label); - b.add(line, LOOP); - int size2 = b.size(); - - b.add(line, JT, new Integer(0)); - int size = b.size(); - if (peekToken() != RP) { - startExpr(b, -1); - b.add(line, POP); - } - b.set(size - 1, new Integer(b.size() - size + 1)); - consume(RP); - - b.paste(e2); - b.add(line, JT, new Integer(2)); - b.add(line, BREAK); - parseStatement(b, null); - b.add(line, CONTINUE); - b.set(size2 - 1, new Integer(b.size() - size2 + 1)); // end of the loop - - b.add(line, OLDSCOPE); - break; - } - } - - case NAME: { - String possiblyTheLabel = string; - if (peekToken() == COLON) { - consume(COLON); - label = possiblyTheLabel; - parseStatement(b, label); - break; - } else { - pushBackToken(NAME, possiblyTheLabel); - startExpr(b, -1); - b.add(line, POP); - if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1) consume(SEMI); - break; - } - } - - case SEMI: return; - case LC: { - pushBackToken(); - parseBlock(b, label); - break; - } - - default: { - pushBackToken(); - startExpr(b, -1); - b.add(line, POP); - if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1) consume(SEMI); - break; - } - } + int tok = peekToken(); + if (tok == -1) return; + switch(tok = getToken()) { + + case THROW: case ASSERT: case RETURN: { + if (tok == RETURN && peekToken() == SEMI) + b.add(line, LITERAL, null); + else + startExpr(b, -1); + b.add(line, tok); + consume(SEMI); + break; + } + case BREAK: case CONTINUE: { + if (peekToken() == NAME) consume(NAME); + b.add(line, tok, string); + consume(SEMI); + break; + } + case VAR: { + b.add(line, TOPSCOPE); // push the current scope + while(true) { + consume(NAME); + String name = string; + b.add(line, LITERAL, name); // push the name to be declared + b.add(line, DECLARE); // declare it + if (peekToken() == ASSIGN) { // if there is an '=' after the variable name + b.add(line, LITERAL, name); // put the var name back on the stack + consume(ASSIGN); + startExpr(b, -1); + b.add(line, PUT); // assign it + b.add(line, POP); // clean the stack + } + if (peekToken() != COMMA) break; + consume(COMMA); + } + b.add(line, POP); // pop off the topscope + if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1) consume(SEMI); + break; + } + case IF: { + consume(LP); + startExpr(b, -1); + consume(RP); + + b.add(line, JF, new Integer(0)); // if false, jump to the else-block + int size = b.size(); + parseStatement(b, null); + + if (peekToken() == ELSE) { + consume(ELSE); + b.add(line, JMP, new Integer(0)); // if we took the true-block, jump over the else-block + b.set(size - 1, new Integer(b.size() - size + 1)); + size = b.size(); + parseStatement(b, null); + } + b.set(size - 1, new Integer(b.size() - size + 1)); // regardless of which branch we took, b[size] needs to point here + break; + } + case WHILE: { + consume(LP); + if (label != null) b.add(line, LABEL, label); + b.add(line, LOOP); + int size = b.size(); + b.add(line, POP); // discard the first-iteration indicator + startExpr(b, -1); + b.add(line, JT, new Integer(2)); // if the while() clause is true, jump over the BREAK + b.add(line, BREAK); + consume(RP); + parseStatement(b, null); + b.add(line, CONTINUE); // if we fall out of the end, definately continue + b.set(size - 1, new Integer(b.size() - size + 1)); // end of the loop + break; + } + case SWITCH: { + consume(LP); + if (label != null) b.add(line, LABEL, label); + b.add(line, LOOP); + int size0 = b.size(); + startExpr(b, -1); + consume(RP); + consume(LC); + while(true) + if (peekToken() == CASE) { // we compile CASE statements like a bunch of if..else's + consume(CASE); + b.add(line, DUP); // duplicate the switch() value; we'll consume one copy + startExpr(b, -1); + consume(COLON); + b.add(line, EQ); // check if we should do this case-block + b.add(line, JF, new Integer(0)); // if not, jump to the next one + int size = b.size(); + while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) parseStatement(b, null); + b.set(size - 1, new Integer(1 + b.size() - size)); + } else if (peekToken() == DEFAULT) { + consume(DEFAULT); + consume(COLON); + while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) parseStatement(b, null); + } else if (peekToken() == RC) { + consume(RC); + b.add(line, BREAK); // break out of the loop if we 'fall through' + break; + } else { + throw new ParserException("expected CASE, DEFAULT, or RC; got " + codeToString[peekToken()]); + } + b.set(size0 - 1, new Integer(b.size() - size0 + 1)); // end of the loop + break; + } + + case DO: { + if (label != null) b.add(line, LABEL, label); + b.add(line, LOOP); + int size = b.size(); + parseStatement(b, null); + consume(WHILE); + consume(LP); + startExpr(b, -1); + b.add(line, JT, new Integer(2)); // check the while() clause; jump over the BREAK if true + b.add(line, BREAK); + b.add(line, CONTINUE); + consume(RP); + consume(SEMI); + b.set(size - 1, new Integer(b.size() - size + 1)); // end of the loop; write this location to the LOOP instruction + break; + } + + case TRY: { + b.add(line, TRY); + int size = b.size(); + parseStatement(b, null); // parse the expression to be TRYed + b.add(line, POP); // pop the TryMarker + b.add(line, JMP); // jump forward to the end of the catch block + int size2 = b.size(); + b.set(size - 1, new Integer(b.size() - size + 1)); // the TRY argument points at the start of the CATCH block + + if (peekToken() == CATCH) { + getToken(); + consume(LP); + consume(NAME); + consume(RP); + // FIXME, we need an extra scope here + b.add(line, TOPSCOPE); // the exception is on top of the stack; put it to the chosen name + b.add(line, SWAP); + b.add(line, LITERAL); + b.add(line, SWAP); + b.add(line, PUT); + b.add(line, POP); + b.add(line, POP); + parseStatement(b, null); + } + + // jump here if no exception was thrown + b.set(size2 - 1, new Integer(b.size() - size2 + 1)); + + // FIXME: not implemented correctly + if (peekToken() == FINALLY) { + consume(FINALLY); + parseStatement(b, null); + } + break; + } + + case FOR: { + consume(LP); + + tok = getToken(); + boolean hadVar = false; // if it's a for..in, we ignore the VAR + if (tok == VAR) { hadVar = true; tok = getToken(); } + String varName = string; + boolean forIn = peekToken() == IN; // determine if this is a for..in loop or not + pushBackToken(tok, varName); + + if (forIn) { + b.add(line, NEWSCOPE); + b.add(line, LITERAL, varName); // declare the new variable + b.add(line, DECLARE); + + b.add(line, LOOP); // we actually only add this to ensure that BREAK works + b.add(line, POP); // discard the first-iteration indicator + int size = b.size(); + consume(NAME); + consume(IN); + startExpr(b, -1); + b.add(line, PUSHKEYS); // push the keys as an array; check the length + b.add(line, LITERAL, "length"); + b.add(line, GET); + consume(RP); + + b.add(line, LITERAL, new Integer(1)); // decrement the length + b.add(line, SUB); + b.add(line, DUP); + b.add(line, LITERAL, new Integer(0)); // see if we've exhausted all the elements + b.add(line, LT); + b.add(line, JF, new Integer(2)); + b.add(line, BREAK); // if we have, then BREAK + b.add(line, GET_PRESERVE); // get the key out of the keys array + b.add(line, LITERAL, varName); + b.add(line, PUT); // write it to this[varName] + parseStatement(b, null); // do some stuff + b.add(line, CONTINUE); // continue if we fall out the bottom + + b.set(size - 1, new Integer(b.size() - size + 1)); // BREAK to here + b.add(line, OLDSCOPE); // restore the scope + + } else { + if (hadVar) pushBackToken(VAR, null); // yeah, this actually matters + b.add(line, NEWSCOPE); // grab a fresh scope + + parseStatement(b, null); // initializer + CompiledFunction e2 = // we need to put the incrementor before the test + new CompiledFunction(sourceName, line, null); // so we save the test here + if (peekToken() != SEMI) + startExpr(e2, -1); + else + e2.add(line, b.LITERAL, Boolean.TRUE); // handle the for(foo;;foo) case + consume(SEMI); + if (label != null) b.add(line, LABEL, label); + b.add(line, LOOP); + int size2 = b.size(); + + b.add(line, JT, new Integer(0)); // if we're on the first iteration, jump over the incrementor + int size = b.size(); + if (peekToken() != RP) { // do the increment thing + startExpr(b, -1); + b.add(line, POP); + } + b.set(size - 1, new Integer(b.size() - size + 1)); + consume(RP); + + b.paste(e2); // ok, *now* test if we're done yet + b.add(line, JT, new Integer(2)); // break out if we don't meet the test + b.add(line, BREAK); + parseStatement(b, null); + b.add(line, CONTINUE); // if we fall out the bottom, CONTINUE + b.set(size2 - 1, new Integer(b.size() - size2 + 1)); // end of the loop + + b.add(line, OLDSCOPE); // get our scope back + } + break; + } + + case NAME: { // either a label or an identifier; this is the one place we're not LL(1) + String possiblyTheLabel = string; + if (peekToken() == COLON) { // label + consume(COLON); + parseStatement(b, possiblyTheLabel); + break; + } else { // expression + pushBackToken(NAME, possiblyTheLabel); + startExpr(b, -1); + b.add(line, POP); + if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1) consume(SEMI); + break; + } + } + + case SEMI: return; // yep, the null statement is valid + + case LC: { // blocks are statements too + pushBackToken(); + parseBlock(b, label); + break; + } + + default: { // hope that it's an expression + pushBackToken(); + startExpr(b, -1); + b.add(line, POP); + if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1) consume(SEMI); + break; + } + } } -- 1.7.10.4