X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=src%2Forg%2Fxwt%2Fjs%2FParser.java;h=1914cc7e3226acaa6f8f57fe9ae85373515ed1de;hb=16c24a73c1c1b2955db0bbbaf5a940215329bca1;hp=f70a13d7d8f99d5d37fc8cef2a887a503000aa32;hpb=11fb6d3f994008abe6c16b4402c3904a543e240e;p=org.ibex.core.git

diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java
index f70a13d..1914cc7 100644
--- a/src/org/xwt/js/Parser.java
+++ b/src/org/xwt/js/Parser.java
@@ -1,29 +1,81 @@
-// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
+// Copyright 2004 Adam Megacz, see the COPYING file for licensing [GPL]
 package org.xwt.js;
 
 import org.xwt.util.*;
 import java.io.*;
 
+/**
+ *  Parses a stream of lexed tokens into a tree of JSFunction's.
+ *
+ *  There are three kinds of things we parse: blocks, statements, and
+ *  expressions.
+ *
+ *  - Expressions are a special type of statement that evaluates to a
+ *    value (for example, "break" is not an expression, * but "3+2"
+ *    is).  Some tokens sequences start expressions (for * example,
+ *    literal numbers) and others continue an expression which * has
+ *    already been begun (for example, '+').  Finally, some *
+ *    expressions are valid targets for an assignment operation; after
+ *    * each of these expressions, continueExprAfterAssignable() is
+ *    called * to check for an assignment operation.
+ *
+ *  - A statement ends with a semicolon and does not return a value.
+ *
+ *  - A block is a single statement or a sequence of statements
+ *    surrounded by curly braces.
+ *
+ *  Each parsing method saves the parserLine before doing its actual
+ *  work and restores it afterwards.  This ensures that parsing a
+ *  subexpression does not modify the line number until a token
+ *  *after* the subexpression has been consumed by the parent
+ *  expression.
+ *
+ *  Technically it would be a better design for this class to build an
+ *  intermediate parse tree and use that to emit bytecode.  Here's the
+ *  tradeoff:
+ *
+ *  Advantages of building a parse tree:
+ *  - easier to apply optimizations
+ *  - would let us handle more sophisticated languages than JavaScript
+ *
+ *  Advantages of leaving out the parse tree
+ *  - faster compilation
+ *  - less load on the garbage collector
+ *  - much simpler code, easier to understand
+ *  - less error-prone
+ *
+ *  Fortunately JS is such a simple language that we can get away with
+ *  the half-assed approach and still produce a working, complete
+ *  compiler.
+ *
+ *  The bytecode language emitted doesn't really cause any appreciable
+ *  semantic loss, and is itself a parseable language very similar to
+ *  Forth or a postfix variant of LISP.  This means that the bytecode
+ *  can be transformed into a parse tree, which can be manipulated.
+ *  So if we ever want to add an optimizer, it could easily be done by
+ *  producing a parse tree from the bytecode, optimizing that tree,
+ *  and then re-emitting the bytecode.  The parse tree node class
+ *  would also be much simpler since the bytecode language has so few
+ *  operators.
+ *
+ *  Actually, the above paragraph is slightly inaccurate -- there are
+ *  places where we push a value and then perform an arbitrary number
+ *  of operations using it before popping it; this doesn't parse well.
+ *  But these cases are clearly marked and easy to change if we do
+ *  need to move to a parse tree format.
+ */
+class Parser extends Lexer implements ByteCodes {
 
-/** parses a stream of lexed tokens into a tree of Expr's */
-public class Parser extends Lexer {
 
     // Constructors //////////////////////////////////////////////////////
 
-    public Parser(Reader r, String sourceName, int line) throws IOException {
-	super(r);
-	this.sourceName = sourceName;
-	this.line = line;
-    }
+    public Parser(Reader r, String sourceName, int line) throws IOException { super(r, sourceName, line); }
 
+    /** for debugging */
     public static void main(String[] s) throws Exception {
-	Parser p = new Parser(new InputStreamReader(System.in), "stdin", 0);
-	while(true) {
-	    Expr block = p.parseBlock(false);
-	    if (block == null) return;
-	    System.out.println(block);
-	    if (p.peekToken() == -1) return;
-	}
+        JS block = JS.fromReader("stdin", 0, new InputStreamReader(System.in));
+        if (block == null) return;
+        System.out.println(block);
     }
 
 
@@ -31,768 +83,868 @@ public class Parser extends Lexer {
 
     static byte[] precedence = new byte[MAX_TOKEN + 1];
     static boolean[] isRightAssociative = new boolean[MAX_TOKEN + 1];
+    // Use this as the precedence when we want anything up to the comma
+    private final static int NO_COMMA = 2;
     static {
-	precedence[ASSIGN] = 1;
-	isRightAssociative[ASSIGN] = true;
-	precedence[HOOK] = 2;
-	precedence[COMMA] = 3;
-	precedence[GT] = precedence[GE] = 4;
-	precedence[OR] = precedence[AND] = 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] = precedence[INSTANCEOF] = 15;
-	precedence[INC] = precedence[DEC] = 16;
-	precedence[LP] = 17;
-	precedence[LB] = 18;
-	precedence[DOT] = 19;
+        isRightAssociative[ASSIGN] =
+            isRightAssociative[ASSIGN_BITOR] =
+            isRightAssociative[ASSIGN_BITXOR] =
+            isRightAssociative[ASSIGN_BITAND] =
+            isRightAssociative[ASSIGN_LSH] =
+            isRightAssociative[ASSIGN_RSH] =
+            isRightAssociative[ASSIGN_URSH] =
+            isRightAssociative[ASSIGN_ADD] =
+            isRightAssociative[ASSIGN_SUB] =
+            isRightAssociative[ASSIGN_MUL] =
+            isRightAssociative[ASSIGN_DIV] =
+            isRightAssociative[ASSIGN_MOD] =
+            isRightAssociative[ADD_TRAP] =
+            isRightAssociative[DEL_TRAP] =
+            true;
+
+        precedence[COMMA] = 1;
+        // 2 is intentionally left unassigned. we use minPrecedence==2 for comma separated lists
+        precedence[ASSIGN] =
+            precedence[ASSIGN_BITOR] =
+            precedence[ASSIGN_BITXOR] =
+            precedence[ASSIGN_BITAND] =
+            precedence[ASSIGN_LSH] =
+            precedence[ASSIGN_RSH] =
+            precedence[ASSIGN_URSH] =
+            precedence[ASSIGN_ADD] =
+            precedence[ASSIGN_SUB] =
+            precedence[ASSIGN_MUL] =
+            precedence[ASSIGN_DIV] =
+            precedence[ADD_TRAP] =
+            precedence[DEL_TRAP] =
+            precedence[ASSIGN_MOD] = 3;
+        precedence[HOOK] = 4;
+        precedence[OR] = 5;
+        precedence[AND] = 6;
+        precedence[BITOR] = 7;
+        precedence[BITXOR] = 8;
+        precedence[BITAND] = 9;
+        precedence[EQ] = precedence[NE] = precedence[SHEQ] = precedence[SHNE] = 10;
+        precedence[LT] = precedence[LE] = precedence[GT] = precedence[GE] = 11;
+        precedence[LSH] = precedence[RSH] = precedence[URSH] = 12;
+        precedence[ADD] = precedence[SUB] = 12;
+        precedence[MUL] = precedence[DIV] = precedence[MOD] = 13;
+        precedence[BITNOT] =  precedence[BANG] = precedence[TYPEOF] = 14;
+        precedence[DOT] = precedence[LB] = precedence[LP] =  precedence[INC] = precedence[DEC] = 15;
     }
 
 
     // Parsing Logic /////////////////////////////////////////////////////////
 
-    /** a block is either a single statement or a list of statements surrounded by curly braces; all expressions are also statements */
-    public Expr parseBlock(boolean requireBraces) throws IOException {
-	Expr ret = null;
-	int tok = peekToken();
-	boolean braced = tok == LC;
-	if (requireBraces && !braced) throw new ParserException("expected {");
-	if (braced) getToken();
-	Expr head = null;
-	Expr tail = null;
-	int curLine = line;
-	OUTER: while(true) {
-	    Expr smt;
-
-	    switch(tok = peekToken()) {
-	    case -1: break OUTER;
-	    case LC: smt = parseBlock(true); break;
-	    case THROW: case RETURN: case ASSERT:
-		getToken();
-		smt = new Expr(curLine, tok, parseMaximalExpr());
-		if (getToken() != SEMI) throw new ParserException("expected ;");
-		break;
-
-		/*
-		  FIXME
-	    case NAME: {
-		getToken();
-		String str = string;
-		if (getToken() != COLON) throw new ParserException("expected COLON after label");
-		Expr labeledBlock = parseBlock(false);
-		if (labeledBlock.code != WHILE && labeledBlock.code != FOR && labeledBlock.code != SWITCH) 
-		    throw new ParserException("you can only label a WHILE, FOR, or SWITCH block");
-		labeledBlock.string = str;
-		return labeledBlock;
-	    }
-		*/
-
-	    case GOTO: case BREAK: case CONTINUE: {
-		getToken();
-		int t = peekToken();
-		if (t == NAME) {
-		    getToken();
-		    smt = new Expr(curLine, tok, new Expr(curLine, string));
-		} else if (t == GOTO) {
-		    throw new ParserException("goto must be followed by a label");
-		} else if (t == SEMI) {
-		    getToken();
-		    smt = new Expr(curLine, tok);
-		} else {
-		    throw new ParserException(codeToString[tok] + " followed by a " + codeToString[t] + "; expected NAME or SEMI");
-		}
-		break;
-	    }
-
-	    case RC:
-		if (braced) getToken();
-		break OUTER;
-
-	    case SEMI:
-		getToken();
-		if (!braced) break OUTER;
-		continue;
-
-	    default:
-		smt = parseMaximalExpr();
-		if (smt == null) {
-		    if (head == null) throw new ParserException("empty statement list; next token is " + codeToString[peekToken()]);
-		    break OUTER;
-		}
-		break;
-	    }
-	    if (head == null) head = tail = smt; else tail = (tail.next = smt);
-	}
-	return new Expr(curLine, LC, head);
+    /** gets a token and throws an exception if it is not <tt>code</tt> */
+    private void consume(int code) throws IOException {
+        if (getToken() != code) {
+            if(code == NAME) switch(op) {
+                case RETURN: case TYPEOF: case BREAK: case CONTINUE: case TRY: case THROW:
+                case ASSERT: case NULL: case TRUE: case FALSE: case IN: case IF: case ELSE:
+                case SWITCH: case CASE: case DEFAULT: case WHILE: case VAR: case WITH:
+                case CATCH: case FINALLY:
+                    throw pe("Bad variable name; '" + codeToString[op].toLowerCase() + "' is a javascript keyword");
+            }
+            throw pe("expected " + codeToString[code] + ", got " + (op == -1 ? "EOF" : codeToString[op]));
+        }
     }
 
-    /** throws an error if the next token is not <tt>code</tt> */
-    public void expect(int code) throws IOException {
-	int got = peekToken();
-	if (got != code)
-	    throw new ParserException("expected " + codeToString[code] + ", got " + (got == -1 ? "EOL" : codeToString[got]));
+    /**
+     *  Parse the largest possible expression containing no operators
+     *  of precedence below <tt>minPrecedence</tt> and append the
+     *  bytecodes for that expression to <tt>appendTo</tt>; the
+     *  appended bytecodes MUST grow the stack by exactly one element.
+     */ 
+    private void startExpr(JSFunction appendTo, int minPrecedence) throws IOException {
+        int saveParserLine = parserLine;
+        _startExpr(appendTo, minPrecedence);
+        parserLine = saveParserLine;
+    }
+    private void _startExpr(JSFunction appendTo, int minPrecedence) throws IOException {
+        int tok = getToken();
+        JSFunction b = appendTo;
+
+        switch (tok) {
+        case -1: throw pe("expected expression");
+
+        // all of these simply push values onto the stack
+        case NUMBER: b.add(parserLine, LITERAL, number); break;
+        case STRING: b.add(parserLine, LITERAL, string); break;
+        case NULL: b.add(parserLine, LITERAL, null); break;
+        case TRUE: case FALSE: b.add(parserLine, LITERAL, JS.B(tok == TRUE)); break;
+
+        // (.foo) syntax
+        case DOT: {
+            consume(NAME);
+            b.add(parserLine, TOPSCOPE);
+            b.add(parserLine, LITERAL, "");
+            b.add(parserLine, GET);
+            b.add(parserLine, LITERAL, string);
+            b.add(parserLine, GET);
+            continueExpr(b, minPrecedence);
+            break;
+        }
+
+        case LB: {
+            b.add(parserLine, ARRAY, JS.ZERO);                       // 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;
+                    b.add(parserLine, LITERAL, JS.N(i++));           // push the index in the array to place it into
+                    if (peekToken() == COMMA || peekToken() == RB)
+                        b.add(parserLine, LITERAL, null);                   // for stuff like [1,,2,]
+                    else
+                        startExpr(b, NO_COMMA);                             // push the value onto the stack
+                    b.add(parserLine, PUT);                                 // put it into the array
+                    b.add(parserLine, POP);                                 // discard the value remaining on the stack
+                    if (peekToken() == RB) break;
+                    consume(COMMA);
+                }
+            b.set(size0 - 1, JS.N(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(parserLine, LITERAL, JS.N(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]);
+            int prev = b.size - 1;
+            if (b.get(prev) == GET && b.getArg(prev) != null)
+                b.set(prev, LITERAL, b.getArg(prev));
+            else if(b.get(prev) == GET)
+                b.pop();
+            else
+                throw pe("prefixed increment/decrement can only be performed on a valid assignment target");
+            b.add(parserLine, GET_PRESERVE, Boolean.TRUE);
+            b.add(parserLine, LITERAL, JS.N(1));
+            b.add(parserLine, tok == INC ? ADD : SUB, JS.N(2));
+            b.add(parserLine, PUT, null);
+            b.add(parserLine, SWAP, null);
+            b.add(parserLine, POP, null);
+            break;
+        }
+        case BANG: case BITNOT: case TYPEOF: {
+            startExpr(b, precedence[tok]);
+            b.add(parserLine, tok);
+            break;
+        }
+        case LC: { // object constructor
+            b.add(parserLine, OBJECT, null);                                     // put an object on the stack
+            if (peekToken() != RC)
+                while(true) {
+                    if (peekToken() != NAME && peekToken() != STRING)
+                        throw pe("expected NAME or STRING");
+                    getToken();
+                    b.add(parserLine, LITERAL, string);                          // grab the key
+                    consume(COLON);
+                    startExpr(b, NO_COMMA);                                      // grab the value
+                    b.add(parserLine, PUT);                                      // put the value into the object
+                    b.add(parserLine, 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: {
+            b.add(parserLine, TOPSCOPE);
+            b.add(parserLine, LITERAL, string);
+            continueExprAfterAssignable(b,minPrecedence);
+            break;
+        }
+        case FUNCTION: {
+            consume(LP);
+            int numArgs = 0;
+            JSFunction b2 = new JSFunction(sourceName, parserLine, null);
+            b.add(parserLine, NEWFUNCTION, b2);
+
+            // function prelude; arguments array is already on the stack
+            b2.add(parserLine, TOPSCOPE);
+            b2.add(parserLine, SWAP);
+            b2.add(parserLine, DECLARE, "arguments");                     // declare arguments (equivalent to 'var arguments;')
+            b2.add(parserLine, SWAP);                                     // set this.arguments and leave the value on the stack
+            b2.add(parserLine, PUT);
+
+            while(peekToken() != RP) {                                    // run through the list of argument names
+                numArgs++;
+                if (peekToken() == NAME) {
+                    consume(NAME);                                        // a named argument
+                    String varName = string;
+                    
+                    b2.add(parserLine, DUP);                              // dup the args array 
+                    b2.add(parserLine, GET, JS.N(numArgs - 1));   // retrieve it from the arguments array
+                    b2.add(parserLine, TOPSCOPE);
+                    b2.add(parserLine, SWAP);
+                    b2.add(parserLine, DECLARE, varName);                  // declare the name
+                    b2.add(parserLine, SWAP);
+                    b2.add(parserLine, PUT); 
+                    b2.add(parserLine, POP);                               // pop the value
+                    b2.add(parserLine, POP);                               // pop the scope                  
+                }
+                if (peekToken() == RP) break;
+                consume(COMMA);
+            }
+            consume(RP);
+
+            b2.numFormalArgs = numArgs;
+            b2.add(parserLine, POP);                                      // pop off the arguments array
+            b2.add(parserLine, POP);                                      // pop off TOPSCOPE
+            
+           if(peekToken() != LC)
+                throw pe("JSFunctions must have a block surrounded by curly brackets");
+                
+            parseBlock(b2, null);                                   // the function body
+
+            b2.add(parserLine, LITERAL, null);                        // in case we "fall out the bottom", return NULL
+            b2.add(parserLine, RETURN);
+
+            break;
+        }
+        default: throw pe("expected expression, found " + codeToString[tok] + ", which cannot start an expression");
+        }
+
+        // attempt to continue the expression
+        continueExpr(b, minPrecedence);
     }
 
-    /** parses the largest possible expression */
-    public Expr parseMaximalExpr() throws IOException { return parseMaximalExpr(null, -1); }
-    public Expr parseMaximalExpr(Expr prefix, int minPrecedence) throws IOException {
-	while(true) {
-	    if (peekToken() == -1) break;
-	    Expr save = prefix;
-	    prefix = parseSingleExpr(prefix, minPrecedence);
-	    if (save == prefix) break;
-	    if (prefix == null) throw new ParserException("parseSingleExpr() returned null");
-	}
-	return prefix;
+    private Grammar parseGrammar(Grammar g) throws IOException {
+        int tok = getToken();
+        if (g != null)
+            switch(tok) {
+                case BITOR: return new Grammar.Alternative(g, parseGrammar(null));
+                case ADD:   return parseGrammar(new Grammar.Repetition(g, 1, Integer.MAX_VALUE));
+                case MUL:   return parseGrammar(new Grammar.Repetition(g, 0, Integer.MAX_VALUE));
+                case HOOK:  return parseGrammar(new Grammar.Repetition(g, 0, 1));
+            }
+        Grammar g0 = null;
+        switch(tok) {
+            //case NUMBER: g0 = new Grammar.Literal(number); break;
+            case NAME: g0 = new Grammar.Reference(string); break;
+            case STRING:
+                g0 = new Grammar.Literal(string);
+                if (peekToken() == DOT) {
+                    String old = string;
+                    consume(DOT);
+                    consume(DOT);
+                    consume(STRING);
+                    if (old.length() != 1 || string.length() != 1) throw pe("literal ranges must be single-char strings");
+                    g0 = new Grammar.Range(old.charAt(0), string.charAt(0));
+                }
+                break;
+            case LP:     g0 = parseGrammar(null); consume(RP); break;
+            default:     pushBackToken(); return g;
+        }
+        if (g == null) return parseGrammar(g0);
+        return parseGrammar(new Grammar.Juxtaposition(g, g0));
     }
 
-    public Expr parseSingleExpr(Expr prefix, int minPrecedence) throws IOException {
-	Expr e1 = null, e2 = null, e3 = null, head = null, tail = null, ret = null;
-
-	int tok = peekToken();
-	if (minPrecedence > 0 &&
-	    tok < precedence.length &&
-	    precedence[tok] != 0 &&
-	    (isRightAssociative[tok] ?
-	     (precedence[tok] < minPrecedence) :
-	     (precedence[tok] <= minPrecedence))) {
-	    return prefix;
-	     }
-	getToken();
-	int curLine = line;
-
-	// these case arms match the precedence of operators; each arm is a precedence level.
-	switch (tok) {
-
-	case WITH: throw new ParserException("XWT does not allow the WITH keyword");
-	case VOID: case RESERVED: throw new ParserException("reserved word that you shouldn't be using");
-	case NAME: if (prefix != null) { pushBackToken(); return prefix; } else return parseMaximalExpr(new Expr(curLine, NAME, string), minPrecedence);
-	case STRING: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(curLine, string);
-	case NUMBER: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(curLine, number);
-	case NULL: case TRUE: case FALSE: case NOP: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(curLine, 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:
-	    return new Expr(curLine, ASSIGN, prefix, new Expr(curLine, tok - 1, prefix, parseMaximalExpr(null, precedence[ASSIGN])));
-
-	case COMMA: pushBackToken();return prefix;
-
-	case THIS:
-	    if (prefix != null) { pushBackToken(); return prefix; } 
-	    return new Expr(curLine, THIS);
-
-	case SUB:
-	    if (prefix == null && peekToken() == NUMBER) {
-		getToken();
-		return new Expr(curLine, new Double(number.doubleValue() * -1));
-	    } // else fall through
-        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 ASSIGN: case GT: case GE: case OR: case AND:
-	case EQ: case NE: case LT: case LE:
-	    if (prefix == null) throw new ParserException("the " + codeToString[tok] + " token cannot start an expression");
-	    return new Expr(curLine, tok, prefix, parseMaximalExpr(null, precedence[tok]));
-
-	case DOT: {
-	    //e1 = parseMaximalExpr(null, precedence[DOT]);
-	    //if (e1.code == NAME) e1.code = STRING;
-	    //else throw new ParserException("argument to DOT must be a NAME; got a " + codeToString[e1.code]);
-	    //return new Expr(curLine, DOT, prefix, e1);
-	    tok = getToken();
-	    if (tok != NAME) throw new ParserException("DOT must be followed by a NAME");
-	    return new Expr(curLine, DOT, prefix, new Expr(curLine, STRING, string));
-	}
-
-	case BANG: case BITNOT: case INSTANCEOF: case TYPEOF:
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    return new Expr(curLine, tok, parseMaximalExpr(null, precedence[tok]));
-
-	case INC: case DEC:
-	    if (prefix == null) {
-		// prefix
-		e1 = parseMaximalExpr(null, precedence[tok]);
-		return new Expr(curLine, ASSIGN, e1, new Expr(curLine, tok == INC ? ADD : SUB, e1, new Expr(curLine, new Integer(1))));
-	    } else {
-		// postfix
-		return new Expr(curLine, tok, prefix);
-	    }
-
-	case LP:
-	    if (prefix == null) {  // grouping
-		Expr r = parseMaximalExpr();
-		expect(RP); getToken();
-		return r;
-
-	    } else {  // invocation
-		while(peekToken() != RP) {
-		    Expr e = parseMaximalExpr();
-		    if (head == null) head = tail = e; else tail = tail.next = e;
-		    tok = getToken();
-		    if (tok == RP) { pushBackToken(); break; }
-		    if (tok != COMMA) throw new ParserException("expected comma or right paren, got " + codeToString[tok]);
-		}
-		getToken();
-		return new Expr(curLine, LP, prefix, head);
-	    }
-
-	case LB:
-	    if (prefix != null) {
-		// subscripting
-		e1 = parseMaximalExpr();
-		if (getToken() != RB) throw new ParserException("expected a right brace");
-		return new Expr(curLine, DOT, prefix, e1);
-	    } else {
-		// array ctor
-		while(true) {
-		    if (peekToken() == RB) { getToken(); return new Expr(curLine, LB, prefix, head); }
-		    Expr eee = parseMaximalExpr();
-		    if (eee != null) {
-			if (head == null) head = tail = eee;
-			else tail.next = tail = eee;
-		    }
-		    tok = getToken();
-		    if (tok == RB) return new Expr(curLine, LB, prefix, head);
-		    if (tok != COMMA) throw new ParserException("expected right bracket or comma");
-		}
-	    }
-	    
-	case LC:
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    tok = getToken();
-	    if (tok == RC) return new Expr(curLine, RC, head);
-	    while(true) {
-		if (tok != NAME && tok != STRING) throw new ParserException("expecting name, got " + codeToString[tok]);
-		Expr name = new Expr(curLine, NAME, string);
-		if (getToken() != COLON) throw new ParserException("expecting colon");		
-		e1 = new Expr(curLine, COLON, name, parseMaximalExpr());
-		if (head == null) head = tail = e1; else tail = tail.next = e1;
-		tok = getToken();
-		if (tok != COMMA && tok != RC) throw new ParserException("expected right curly or comma, got " + codeToString[tok]);
-		if (tok == RC) return new Expr(curLine, RC, head);
-		tok = getToken();
-		if (tok == RC) return new Expr(curLine, RC, head);
-	    }
-	    
-	case HOOK:
-	    e2 = parseMaximalExpr();
-	    if (getToken() != COLON) throw new ParserException("expected colon to close ?: expression");
-	    e3 = parseMaximalExpr();
-	    return new Expr(curLine, HOOK, prefix, new Expr(curLine, ELSE, e2, e3));
-	    
-	case SWITCH: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    if (getToken() != LP) throw new ParserException("expected left paren");
-	    Expr switchExpr = parseMaximalExpr();
-	    if (getToken() != RP) throw new ParserException("expected left paren");
-	    if (getToken() != LC) throw new ParserException("expected left brace");
-	    Expr firstExpr = null;
-	    Expr lastExpr = null;
-	    while(true) {
-		tok = getToken();
-		Expr caseExpr;
-		if (tok == DEFAULT) {
-		    caseExpr = null;
-		} else if (tok == CASE) {
-		    // FIXME: we don't support non-brace-enclosed CASE blocks
-		    caseExpr = parseMaximalExpr();
-		} else {
-		    throw new ParserException("expected CASE");
-		}
-		expect(COLON); getToken();
-		head = tail = null;
-		while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) {
-		    e1 = parseBlock(false);
-		    if (e1 == null) break;
-		    if (head == null) head = tail = e1; else tail = tail.next = e1;
-		}
-		e1 = new Expr(curLine, tok, caseExpr, new Expr(curLine, LC, head));
-		if (lastExpr == null) firstExpr = e1; else lastExpr.next = e1;
-		lastExpr = e1;
-		if (peekToken() == RC) {getToken(); return new Expr(curLine, SWITCH, switchExpr, firstExpr); }
-	    }
-	}
-	    
-	case FUNCTION: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    if (getToken() != LP) throw new ParserException("function keyword must be followed by a left paren");
-	    Expr formalArgs = null, cur = null;
-	    tok = getToken();
-	    while(tok != RP) {
-		if (tok != NAME) throw new ParserException("expected a variable name");
-		if (cur == null) { formalArgs = cur = new Expr(curLine, string); }
-		else { cur.next = new Expr(curLine, NAME, string); cur = cur.next; }
-		tok = getToken();
-		if (tok == RP) break;
-		if (tok != COMMA) throw new ParserException("function argument list must consist of alternating NAMEs and COMMAs");
-		tok = getToken();
-	    }
-	    return new Expr(curLine, FUNCTION, formalArgs, parseBlock(true));
-	}
-	    
-	case VAR:
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    while(true) {
-		if (getToken() != NAME) throw new ParserException("variable declarations must start with a variable name");
-		Expr name = new Expr(curLine, NAME, string);
-		Expr initVal = null;
-		tok = peekToken();
-		Expr e = null;
-		if (tok == ASSIGN) {
-		    getToken();
-		    initVal = parseMaximalExpr();
-		    tok = peekToken();
-		    e = new Expr(curLine, ASSIGN, name, initVal);
-		} else {
-		    e = new Expr(curLine, NAME, name);
-		}
-		if (head == null) head = tail = e; else tail = tail.next = e;
-		if (tok != COMMA) break;
-		getToken();
-	    }
-	    return new Expr(curLine, VAR, head);
-
-	case TRY: {
-	    // We deliberately allow you to omit braces in catch{}/finally{} if they are single statements...
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    Expr tryBlock = parseBlock(true);
-	    
-	    tok = peekToken();
-	    if (tok == CATCH) {
-		getToken();
-		if (getToken() != LP) throw new ParserException("expected (");
-		if (getToken() != NAME) throw new ParserException("expected name");
-		Expr name = new Expr(curLine, NAME, string);
-		if (getToken() != RP) throw new ParserException("expected )");
-		head = tail = new Expr(curLine, CATCH, name, parseBlock(false));
-		tok = peekToken();
-	    }
-	    if (tok == FINALLY) {
-		getToken();
-		e1 = new Expr(curLine, FINALLY, parseBlock(false));
-		if (head == null) head = tail = e1; else tail = tail.next = e1;
-	    }
-
-	    if (head == null) throw new ParserException("try without catch or finally");
-	    return new Expr(curLine, TRY, tryBlock, head);
-	}
-
-	case IF: case WHILE: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    if (getToken() != LP) throw new ParserException("expected left paren");
-	    Expr parenExpr = parseMaximalExpr();
-	    int t;
-	    if ((t = getToken()) != RP) throw new ParserException("expected right paren, but got " + codeToString[t]);
-	    Expr firstBlock = parseBlock(false);
-	    if (tok == IF && peekToken() == ELSE) {
-		getToken();
-		return new Expr(curLine, tok, parenExpr, new Expr(curLine, ELSE, firstBlock, parseBlock(false)));
-	    } else if (tok == IF) {
-		return new Expr(curLine, tok, parenExpr, new Expr(curLine, ELSE, firstBlock, new Expr(curLine, LC)));
-	    } else if (tok == WHILE) {
-		return new Expr(curLine, tok, parenExpr, firstBlock);
-	    }
-	}
-
-	case IN: pushBackToken(); return prefix;
-
-	case FOR:
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    if (getToken() != LP) throw new ParserException("expected left paren");
-	    e1 = parseMaximalExpr(null, -1);
-	    if (peekToken() == IN) {
-		getToken();
-		e2 = parseMaximalExpr(null, -1);
-		if (getToken() != RP) throw new ParserException("expected right paren");
-		return new Expr(curLine, FOR, new Expr(curLine, IN, e1, e2), parseBlock(false));
-		
-	    } else {
-		if (getToken() != SEMI) throw new ParserException("expected ;");
-		e2 = parseMaximalExpr();
-		if (getToken() != SEMI) throw new ParserException("expected ;");
-		e3 = parseMaximalExpr();
-		if (getToken() != RP) throw new ParserException("expected right paren");
-		return new Expr(curLine, LC, e1, new Expr(curLine, WHILE, e2, new Expr(curLine, LC, parseBlock(false), e3)));
-	    }
-	    
-	case DO: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    Expr firstBlock = parseBlock(false);
-	    if (getToken() != WHILE) throw new ParserException("expecting WHILE");
-	    if (getToken() != LP) throw new ParserException("expected left paren");
-	    Expr whileExpr = parseMaximalExpr();
-	    if (getToken() != RP) throw new ParserException("expected right paren");
-	    if (getToken() != SEMI) throw new ParserException("semicolon");
-	    return new Expr(curLine, DO, firstBlock, whileExpr);
-	}
-	    
-	default:
-	    pushBackToken();
-	    return prefix;
-	}
+    /**
+     *  Assuming that a complete assignable (lvalue) has just been
+     *  parsed and the object and key are on the stack,
+     *  <tt>continueExprAfterAssignable</tt> will attempt to parse an
+     *  expression that modifies the assignable.  This method always
+     *  decreases the stack depth by exactly one element.
+     */
+    private void continueExprAfterAssignable(JSFunction b,int minPrecedence) throws IOException {
+        int saveParserLine = parserLine;
+        _continueExprAfterAssignable(b,minPrecedence);
+        parserLine = saveParserLine;
+    }
+    private void _continueExprAfterAssignable(JSFunction b,int minPrecedence) throws IOException {
+        if (b == null) throw new Error("got null b; this should never happen");
+        int tok = getToken();
+        if (minPrecedence != -1 && (precedence[tok] < minPrecedence || (precedence[tok] == minPrecedence && !isRightAssociative[tok])))
+            // force the default case
+            tok = -1;
+        switch(tok) {
+
+        case GRAMMAR: {
+            b.add(parserLine, GET_PRESERVE);
+            Grammar g = parseGrammar(null);
+            if (peekToken() == LC) {
+                g.action = new JSFunction(sourceName, parserLine, null);
+                parseBlock((JSFunction)g.action);
+                ((JSFunction)g.action).add(parserLine, LITERAL, null);         // in case we "fall out the bottom", return NULL              
+                ((JSFunction)g.action).add(parserLine, RETURN);
+            }
+            b.add(parserLine, MAKE_GRAMMAR, g);
+            b.add(parserLine, PUT);
+            break;
+        }
+
+        case ASSIGN_BITOR: case ASSIGN_BITXOR: case ASSIGN_BITAND: case ASSIGN_LSH: case ASSIGN_RSH: case ASSIGN_URSH:
+        case ASSIGN_MUL: case ASSIGN_DIV: case ASSIGN_MOD: case ASSIGN_ADD: case ASSIGN_SUB: case ADD_TRAP: case DEL_TRAP: {
+            if (tok != ADD_TRAP && tok != DEL_TRAP) b.add(parserLine, GET_PRESERVE);
+            
+            startExpr(b,  precedence[tok]);
+            
+            int size = b.size;
+            
+            if (tok != ADD_TRAP && tok != DEL_TRAP) {
+                // tok-1 is always s/^ASSIGN_// (0 is BITOR, 1 is ASSIGN_BITOR, etc) 
+                b.add(parserLine, tok - 1, tok-1==ADD ? JS.N(2) : null);
+                b.add(parserLine, PUT);
+                b.add(parserLine, SWAP);
+                b.add(parserLine, POP);
+            } else {
+                b.add(parserLine, tok);
+            }
+            break;
+        }
+        case INC: case DEC: { // postfix
+            b.add(parserLine, GET_PRESERVE, Boolean.TRUE);
+            b.add(parserLine, LITERAL, JS.N(1));
+            b.add(parserLine, tok == INC ? ADD : SUB, JS.N(2));
+            b.add(parserLine, PUT, null);
+            b.add(parserLine, SWAP, null);
+            b.add(parserLine, POP, null);
+            b.add(parserLine, LITERAL, JS.N(1));
+            b.add(parserLine, tok == INC ? SUB : ADD, null);   // undo what we just did, since this is postfix
+            break;
+        }
+        case ASSIGN: {
+            startExpr(b, precedence[tok]);
+            b.add(parserLine, PUT);
+            b.add(parserLine, SWAP);
+            b.add(parserLine, POP);
+            break;
+        }
+        case LP: {
+
+            // Method calls are implemented by doing a GET_PRESERVE
+            // first.  If the object supports method calls, it will
+            // return JS.METHOD
+            int n = parseArgs(b, 2);
+            b.add(parserLine, GET_PRESERVE);
+            b.add(parserLine, CALLMETHOD, JS.N(n));
+            break;
+        }
+        default: {
+            pushBackToken();
+            if(b.get(b.size-1) == LITERAL && b.getArg(b.size-1) != null)
+                b.set(b.size-1,GET,b.getArg(b.size-1));
+            else
+                b.add(parserLine, GET);
+            return;
+        }
+        }
     }
-    
-    // Expr //////////////////////////////////////////////////////////////////////
 
-    /** sorta like gcc trees */
-    class Expr {
-	int code = -1;
-    
-	final Expr left;
-	final Expr right;
-	Expr next = null;   // if this expr is part of a list
-	int line = -1;
-	String sourceName = "unknown";
-    
-	String string = null;
-	Number number = null;
+
+    /**
+     *  Assuming that a complete expression has just been parsed,
+     *  <tt>continueExpr</tt> will attempt to extend this expression by
+     *  parsing additional tokens and appending additional bytecodes.
+     *
+     *  No operators with precedence less than <tt>minPrecedence</tt>
+     *  will be parsed.
+     *
+     *  If any bytecodes are appended, they will not alter the stack
+     *  depth.
+     */
+    private void continueExpr(JSFunction b, int minPrecedence) throws IOException {
+        int saveParserLine = parserLine;
+        _continueExpr(b, minPrecedence);
+        parserLine = saveParserLine;
+    }
+    private void _continueExpr(JSFunction 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) {
+        case LP: {  // invocation (not grouping)
+            int n = parseArgs(b, 1);
+            b.add(parserLine, CALL, JS.N(n));
+            break;
+        }
+        case BITOR: case BITXOR: case BITAND: case SHEQ: case SHNE: case LSH:
+        case RSH: case URSH: 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(parserLine, tok);
+            break;
+        }
+        case ADD: {
+            int count=1;
+            int nextTok;
+            do {
+                startExpr(b,precedence[tok]);
+                count++;
+                nextTok = getToken();
+            } while(nextTok == tok);
+            pushBackToken();
+            b.add(parserLine, tok, JS.N(count));
+            break;
+        }
+        case OR: case AND: {
+            b.add(parserLine, tok == AND ? b.JF : b.JT, JS.ZERO);       // test to see if we can short-circuit
+            int size = b.size;
+            startExpr(b, precedence[tok]);                                     // otherwise check the second value
+            b.add(parserLine, JMP, JS.N(2));                            // leave the second value on the stack and jump to the end
+            b.add(parserLine, LITERAL, tok == AND ?
+                  JS.B(false) : JS.B(true));                     // target of the short-circuit jump is here
+            b.set(size - 1, JS.N(b.size - size));                     // write the target of the short-circuit jump
+            break;
+        }
+        case DOT: {
+            // support foo..bar syntax for foo[""].bar
+            if (peekToken() == DOT) {
+                string = "";
+            } else {
+                consume(NAME);
+            }
+            b.add(parserLine, LITERAL, string);
+            continueExprAfterAssignable(b,minPrecedence);
+            break;
+        }
+        case LB: { // subscripting (not array constructor)
+            startExpr(b, -1);
+            consume(RB);
+            continueExprAfterAssignable(b,minPrecedence);
+            break;
+        }
+        case HOOK: {
+            b.add(parserLine, JF, JS.ZERO);                // jump to the if-false expression
+            int size = b.size;
+            startExpr(b, minPrecedence);                          // write the if-true expression
+            b.add(parserLine, JMP, JS.ZERO);               // if true, jump *over* the if-false expression     
+            b.set(size - 1, JS.N(b.size - size + 1));    // now we know where the target of the jump is
+            consume(COLON);
+            size = b.size;
+            startExpr(b, minPrecedence);                          // write the if-false expression
+            b.set(size - 1, JS.N(b.size - size + 1));    // this is the end; jump to here
+            break;
+        }
+        case COMMA: {
+            // pop the result of the previous expression, it is ignored
+            b.add(parserLine,POP);
+            startExpr(b,-1);
+            break;
+        }
+        default: {
+            pushBackToken();
+            return;
+        }
+        }
+
+        continueExpr(b, minPrecedence);                           // try to continue the expression
+    }
     
-	public String toString() { return toString(0); }
-	public String toString(int indent) {
-	    String ret = "";
-	    for(int i=0; i<indent; i++) ret += " ";
-	    ret += Lexer.codeToString[code];
-	    if (code == Lexer.NUMBER) ret += " " + number;
-	    else if (string != null) ret += " \"" + string + "\"";
-	    ret += "\n";
-	    if (left != null) ret += left.toString(indent + 2);
-	    if (right != null) ret += right.toString(indent + 2);
-	    if (next != null) ret += next.toString(indent);
-	    return ret;
-	}
+    // parse a set of comma separated function arguments, assume LP has already been consumed
+    // if swap is true, (because the function is already on the stack) we will SWAP after each argument to keep it on top
+    private int parseArgs(JSFunction b, int pushdown) throws IOException {
+        int i = 0;
+        while(peekToken() != RP) {
+            i++;
+            if (peekToken() != COMMA) {
+                startExpr(b, NO_COMMA);
+                b.add(parserLine, SWAP, JS.N(pushdown));
+                if (peekToken() == RP) break;
+            }
+            consume(COMMA);
+        }
+        consume(RP);
+        return i;
+    }
     
-	public Expr(int line, String s) { this(line, Lexer.STRING); this.string = s; }  // an identifier or label
-	public Expr(int line, int code, String s) { this(line, code); this.string = s; }
-	public Expr(int line, Number n) { this(line, Lexer.NUMBER); this.number = n; }  // an identifier or label
-	public Expr(int line, int code) { this(line, code, null, null); }
-	public Expr(int line, int code, Expr left) { this(line, code, left, null); }
-	public Expr(int line, int code, Expr left, Expr right) {
-	    this.code = code; this.left = left; this.right = right;
-	    this.line = line;
-	    this.sourceName = Parser.this.sourceName;
-	}
-
-	public double toDouble(Object o) { return toNumber(o).doubleValue(); }
-	public long toLong(Object o) { return toNumber(o).longValue(); }
-	public boolean toBoolean(Object o) {
-	    if (o == null) return false;
-	    if (o instanceof Boolean) return ((Boolean)o).booleanValue();
-	    if (o instanceof Number) return o.equals(new Integer(0));
-	    return true;
-	}
-
-	public Object eval(final JS.Scope s) throws ControlTransferException, JS.Exn {
-	    switch(code) {
-
-	    case Lexer.BITOR: return new Long(toLong(left.eval(s)) | toLong(right.eval(s)));
-	    case Lexer.BITXOR: return new Long(toLong(left.eval(s)) ^ toLong(right.eval(s)));
-	    case Lexer.BITAND: return new Long(toLong(left.eval(s)) & toLong(right.eval(s)));
-	    case Lexer.BITNOT: return new Long(~toLong(left.eval(s)));
-
-	    case Lexer.ADD: {
-		Object l = left.eval(s);
-		Object r = right.eval(s);
-		if (l instanceof String || r instanceof String) {
-		    if (l == null) l = "null";
-		    if (r == null) r = "null";
-		    if (l instanceof Number && ((Number)l).doubleValue() == ((Number)l).longValue())
-			l = new Long(((Number)l).longValue());
-		    if (r instanceof Number && ((Number)r).doubleValue() == ((Number)r).longValue())
-			r = new Long(((Number)r).longValue());
-		    return l.toString() + r.toString();
-		}
-		return new Double(toDouble(l) + toDouble(r));
-	    }
-
-	    case Lexer.SUB: return new Double(toDouble(left.eval(s)) - toDouble(right.eval(s)));
-	    case Lexer.MUL: return new Double(toDouble(left.eval(s)) * toDouble(right.eval(s)));
-	    case Lexer.DIV: return new Double(toDouble(left.eval(s)) / toDouble(right.eval(s)));
-	    case Lexer.MOD: return new Double(toDouble(left.eval(s)) % toDouble(right.eval(s)));
-
-	    case Lexer.LSH: return new Long(toLong(left.eval(s)) << toLong(right.eval(s)));
-	    case Lexer.RSH: return new Long(toLong(left.eval(s)) >> toLong(right.eval(s)));
-	    case Lexer.URSH: return new Long(toLong(left.eval(s)) >>> toLong(right.eval(s)));
-
-	    case Lexer.LT: return toDouble(left.eval(s)) < toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
-	    case Lexer.LE: return toDouble(left.eval(s)) <= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
-	    case Lexer.GT: return toDouble(left.eval(s)) > toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
-	    case Lexer.GE: return toDouble(left.eval(s)) >= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
-
-	    case Lexer.OR: return new Boolean(toBoolean(left.eval(s)) || toBoolean(right.eval(s)));
-	    case Lexer.AND: return new Boolean(toBoolean(left.eval(s)) && toBoolean(right.eval(s)));
-	    case Lexer.BANG: return new Boolean(!toBoolean(left.eval(s)));
-
-	    case Lexer.EQ:
-	    case Lexer.NE: {
-		// FIXME: should use Javascript coercion-equality rules
-		Object l = left.eval(s);
-		Object r = right.eval(s);
-		boolean ret = (l == null && r == null) || (l != null && l.equals(r));
-		return new Boolean(code == Lexer.EQ ? ret : !ret);
-	    }
-
-	    case Lexer.INC:
-	    case Lexer.DEC:
-	    case Lexer.ASSIGN: {
-		Object v = (code == Lexer.ASSIGN) ? right.eval(s) : new Double(toDouble(left.eval(s)) + (code == Lexer.INC ? 1 : -1));
-		if (left.code == Lexer.DOT) {
-		    Object o = left.left.eval(s);
-		    if (o instanceof String) {
-			throw new EvaluatorException("can't set properties on a String");
-		    } else if (o instanceof Number) {
-			throw new EvaluatorException("can't set properties on a Number");
-		    } else if (o instanceof Boolean) {
-			throw new EvaluatorException("can't set properties on a Boolean");
-		    } else {
-			JS target = (JS)left.left.eval(s);
-			if (target == null) throw new JS.Exn(new EvaluatorException("attempted to put to the null value"));
-			target.put(left.right.eval(s), v);
-			return v;
-		    }
-		} else {
-		    s.put(left.string, v);
-		    return v;
-		}
-	    }
-
-	    case Lexer.TYPEOF: {
-		Object o = left.eval(s);
-		if (o == null) return "null";
-		if (o.getClass() == String.class) return "string";
-		if (o.getClass() == Boolean.class) return "boolean";
-		if (o instanceof Number) return "number";
-		if (o instanceof JS.Array) return "array";
-		if (o instanceof JS) return "object";
-		throw new EvaluatorException("typeof " + o.getClass().getName() + " unknown");
-	    }
-
-	    case Lexer.NUMBER: return number;
-	    case Lexer.STRING: return string;
-
-	    case Lexer.NULL: return null;
-	    case Lexer.FALSE: return Boolean.FALSE;
-	    case Lexer.TRUE: return Boolean.TRUE;
-	    case Lexer.ASSERT: if (!toBoolean(left.eval(s))) throw new EvaluatorException("assertion failed");
-	    case Lexer.THROW: throw new JS.Exn(left.eval(s));
-	    case Lexer.NAME: return s.get(string);
-	    case Lexer.THIS: return s.isTransparent() ? s : this.eval(s.getParentScope());
-
-	    case Lexer.DOT: {
-		final Object o = left.eval(s);
-		Object v = ((right.code == Lexer.NAME) || (right.code == Lexer.STRING)) ? right.string : right.eval(s);
-		if (o instanceof String) {
-		    if (v.equals("length")) return new Integer(((String)o).length());
-		    else if (v.equals("substring")) return new JS.Function() {
-			    public Object _call(JS.Array args) {
-				if (args.length() == 1) return ((String)o).substring(toNumber(args.elementAt(0)).intValue());
-				else if (args.length() == 2) return ((String)o).substring(toNumber(args.elementAt(0)).intValue(),
-											  toNumber(args.elementAt(1)).intValue());
-				else throw new EvaluatorException("String.substring() can only take one or two arguments");
-			    }
-			};
-		    else if (v.equals("indexOf")) return new JS.Function() {
-			    public Object _call(JS.Array args) {
-				if (args.length() != 1) return null;
-				return new Integer(((String)o).indexOf(args.elementAt(0).toString()));
-			    }
-			};
-		    throw new EvaluatorException("Not Implemented: properties on String objects");
-		} else if (o instanceof Boolean) {
-		    throw new EvaluatorException("Not Implemented: properties on Boolean objects");
-		} else if (o instanceof Number) {
-		    throw new EvaluatorException("Not Implemented: properties on Number objects");
-		} else if (o instanceof JS) {
-		    return ((JS)o).get(v);
-		}
-	    }
-
-	    case Lexer.TRY: {
-		boolean safeToExit = false;
-		try {
-		    Object ret = left.eval(s);
-		    safeToExit = true;
-		    return ret;
-		} catch (JS.Exn e) {
-		    Expr c = right;
-		    if (c.code == Lexer.CATCH) {
-			JS.Scope scope = new JS.Scope(s);
-			s.put(c.left.string, e);
-			c.right.eval(scope);
-			c = c.next;
-		    }
-		    if (c.code == Lexer.FINALLY) {
-			JS.Scope scope = new JS.Scope(s);
-			c.left.eval(scope);
-		    }
-		} finally {
-		    if (!safeToExit) Log.log(this, "WARNING: Java exception penetrated a JavaScript try{} block");
-		}
-		return null;
-	    }
-
-	    case Lexer.LP:
-		JS.Function f = (JS.Function)left.eval(s);
-		JS.Array arguments = new JS.Array();
-		for(Expr e = right; e != null; e = e.next) arguments.addElement(e.eval(s));
-		if (f == null) throw new JS.Exn(new EvaluatorException("attempted to call null"));
-		return f.call(arguments);
-	    
-	    case Lexer.FUNCTION:
-		return new JS.Function() {
-			public String toString() { return right.sourceName + ":" + right.line; }
-			public String getSourceName() throws JS.Exn { return right.sourceName; }
-			public Object _call(final JS.Array args) throws JS.Exn {
-			    Function save = JS.getCurrentFunction();
-			    JS.currentFunction.put(Thread.currentThread(), this);
-			    JS.Scope scope = new JS.Scope(s) {
-				    // FIXME
-				    public String getSourceName() { return sourceName; }
-				    public boolean isTransparent() { return true; }
-				    public Object get(Object key) throws JS.Exn {
-					if (key.equals("trapee")) return org.xwt.Trap.currentTrapee();
-					else if (key.equals("cascade")) return org.xwt.Trap.cascadeFunction;
-					else if (key.equals("arguments")) return args;
-					return super.get(key);
-				    }
-				};
-			    int i = 0;
-			    for(Expr e = left; e != null; e = e.next) scope.put(e.string, args.get(new Integer(i++)));
-			    try {
-				return right.eval(scope);
-			    } catch (ReturnException r) {
-				return r.retval;
-			    } catch (ControlTransferException c) {
-				throw new EvaluatorException("error, ControlTransferException tried to leave a function: "
-							     + c);
-			    } finally {
-				if (save == null) JS.currentFunction.remove(Thread.currentThread());
-				else JS.currentFunction.put(Thread.currentThread(), save);
-			    }
-			}
-		    };
-		
-	    case Lexer.FOR:
-		Object[] keys = ((JS)left.right.eval(s)).keys();
-		for(int i=0; i<keys.length; i++) {
-		    JS.Scope scope = new JS.Scope(s);
-		    scope.put(left.left.string, keys[i]);
-		    try {
-			right.eval(scope);
-		    } catch (ContinueException c) {
-			if (c.label == null || c.label.equals(string)) continue;
-		    } catch (BreakException b) {
-			if (b.label == null || b.label.equals(string)) return null;
-			throw (BreakException)b.fillInStackTrace();
-		    }
-		}
-		return null;
-
-	    case Lexer.SWITCH:
-		Object switchVal = left.eval(s);
-		boolean go = false;
-		try {
-		    for(Expr e = right; e != null; e = e.next) {
-			if (go || e.code == Lexer.DEFAULT || e.left.eval(s).equals(switchVal)) go = true;
-			if (go) e.right.eval(s);
-		    }
-		} catch (BreakException b) {
-		    if (b.label == null || b.label.equals(string)) return null;
-		    throw (BreakException)b.fillInStackTrace();
-		}
-		return null;
-
-	    case Lexer.LB: {
-		JS.Array ret = new JS.Array();
-		for(Expr e = left; e != null; e = e.next) ret.addElement(e.eval(s));
-		return ret;
-	    }
-	    
-	    case Lexer.LC: // block
-		for(Expr e = left; e != null; e = e.next) e.eval(s);
-		return null;
-	    
-	    case Lexer.RC: {   // Object ctor
-		JS.Obj ret = new JS.Obj();
-		for(Expr e = left; e != null; e = e.next)
-		    ret.put(e.left.string, e.right.eval(s));
-		return ret;
-	    }
-	    
-	    case Lexer.VAR:
-		for(Expr e = left; e != null; e = e.next)
-		    if (e.code == Lexer.NAME) {
-			s.declare(e.string);
-		    } else {
-			s.declare(e.left.string);
-			e.eval(s);
-		    }
-		return null;
-
-	    case Lexer.HOOK: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s);
-	    case Lexer.IF: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s);
-	    case Lexer.BREAK: throw new BreakException(string);
-	    case Lexer.CONTINUE: throw new ContinueException(string);
-	    case Lexer.RETURN: throw new ReturnException(left == null ? null : left.eval(s));
-
-	    case Lexer.WHILE:
-	    case Lexer.DO:
-		try {
-		    boolean first = true;
-		    while((first && code == Lexer.DO) || toBoolean(left.eval(s))) {
-			first = false;
-			try { right.eval(s);
-			} catch (ContinueException c) {
-			    if (c.label == null || c.label.equals(string)) continue;
-			} catch (BreakException b) {
-			    if (b.label == null || b.label.equals(string)) return null;
-			    throw (BreakException)b.fillInStackTrace();
-			}
-		    }
-		} catch (BreakException e) {
-		    if (e.label != null && !e.label.equals(string)) throw e;
-		}
-		return null;
-
-	    default: throw new EvaluatorException("don't know how to eval an Expr with code " + Lexer.codeToString[code] + "\n" + this);
-	    }
-	}
-
-	class EvaluatorException extends RuntimeException {
-	    public EvaluatorException(String s) { super(sourceName + ":" + line + " " + s); }
-	}
+    /** Parse a block of statements which must be surrounded by LC..RC. */
+    void parseBlock(JSFunction b) throws IOException { parseBlock(b, null); }
+    void parseBlock(JSFunction b, String label) throws IOException {
+        int saveParserLine = parserLine;
+        _parseBlock(b, label);
+        parserLine = saveParserLine;
+    }
+    void _parseBlock(JSFunction 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);
+        }
     }
 
-	static abstract class ControlTransferException extends Exception { }
-	static class BreakException extends ControlTransferException {
-	    public String label;
-	    BreakException(String label) { this.label = label; }
-	}
-	static class ContinueException extends ControlTransferException {
-	    public String label;
-	    ContinueException(String label) { this.label = label; }
-	}
-	static class ReturnException extends ControlTransferException {
-	    public Object retval;
-	    ReturnException(Object retval) { this.retval = retval; }
-	}
-
-    class ParserException extends RuntimeException {
-	public ParserException(String s) { super(sourceName + ":" + line + " " + s); }
+    /** Parse a single statement, consuming the RC or SEMI which terminates it. */
+    void parseStatement(JSFunction b, String label) throws IOException {
+        int saveParserLine = parserLine;
+        _parseStatement(b, label);
+        parserLine = saveParserLine;
+    }
+    void _parseStatement(JSFunction 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(parserLine, LITERAL, null);
+            else
+                startExpr(b, -1);
+            b.add(parserLine, tok);
+            consume(SEMI);
+            break;
+        }
+        case BREAK: case CONTINUE: {
+            if (peekToken() == NAME) consume(NAME);
+            b.add(parserLine, tok, string);
+            consume(SEMI);
+            break;
+        }
+        case VAR: {
+            b.add(parserLine, TOPSCOPE);                         // push the current scope
+            while(true) {
+                consume(NAME);
+                b.add(parserLine, DECLARE, string);               // declare it
+                if (peekToken() == ASSIGN) {                     // if there is an '=' after the variable name
+                    consume(ASSIGN);
+                    startExpr(b, NO_COMMA);
+                    b.add(parserLine, PUT);                      // assign it
+                    b.add(parserLine, POP);                      // clean the stack
+                } else {
+                    b.add(parserLine, POP);                      // pop the string pushed by declare
+                }   
+                if (peekToken() != COMMA) break;
+                consume(COMMA);
+            }
+            b.add(parserLine, POP);                              // pop off the topscope
+            if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1 && mostRecentlyReadToken != SEMI) consume(SEMI);
+            break;
+        }
+        case IF: {
+            consume(LP);
+            startExpr(b, -1);
+            consume(RP);
+            
+            b.add(parserLine, JF, JS.ZERO);                    // if false, jump to the else-block
+            int size = b.size;
+            parseStatement(b, null);
+            
+            if (peekToken() == ELSE) {
+                consume(ELSE);
+                b.add(parserLine, JMP, JS.ZERO);               // if we took the true-block, jump over the else-block
+                b.set(size - 1, JS.N(b.size - size + 1));
+                size = b.size;
+                parseStatement(b, null);
+            }
+            b.set(size - 1, JS.N(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(parserLine, LABEL, label);
+            b.add(parserLine, LOOP);
+            int size = b.size;
+            b.add(parserLine, POP);                                   // discard the first-iteration indicator
+            startExpr(b, -1);
+            b.add(parserLine, JT, JS.N(2));                    // if the while() clause is true, jump over the BREAK
+            b.add(parserLine, BREAK);
+            consume(RP);
+            parseStatement(b, null);
+            b.add(parserLine, CONTINUE);                              // if we fall out of the end, definately continue
+            b.set(size - 1, JS.N(b.size - size + 1));        // end of the loop
+            break;
+        }
+        case SWITCH: {
+            consume(LP);
+            if (label != null) b.add(parserLine, LABEL, label);
+            b.add(parserLine, 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(parserLine, DUP);                        // duplicate the switch() value; we'll consume one copy
+                    startExpr(b, -1);
+                    consume(COLON);
+                    b.add(parserLine, EQ);                         // check if we should do this case-block
+                    b.add(parserLine, JF, JS.ZERO);         // 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, JS.N(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(parserLine, BREAK);                      // break out of the loop if we 'fall through'
+                    break;
+                } else {
+                    throw pe("expected CASE, DEFAULT, or RC; got " + codeToString[peekToken()]);
+                }
+            b.set(size0 - 1, JS.N(b.size - size0 + 1));      // end of the loop
+            break;
+        }
+            
+        case DO: {
+            if (label != null) b.add(parserLine, LABEL, label);
+            b.add(parserLine, LOOP);
+            int size = b.size;
+            parseStatement(b, null);
+            consume(WHILE);
+            consume(LP);
+            startExpr(b, -1);
+            b.add(parserLine, JT, JS.N(2));                  // check the while() clause; jump over the BREAK if true
+            b.add(parserLine, BREAK);
+            b.add(parserLine, CONTINUE);
+            consume(RP);
+            consume(SEMI);
+            b.set(size - 1, JS.N(b.size - size + 1));      // end of the loop; write this location to the LOOP instruction
+            break;
+        }
+            
+        case TRY: {
+            b.add(parserLine, TRY); // try bytecode causes a TryMarker to be pushed
+            int tryInsn = b.size - 1;
+            // parse the expression to be TRYed
+            parseStatement(b, null); 
+            // pop the try  marker. this is pushed when the TRY bytecode is executed                              
+            b.add(parserLine, POP);
+            // jump forward to the end of the catch block, start of the finally block                             
+            b.add(parserLine, JMP);                                  
+            int successJMPInsn = b.size - 1;
+            
+            if (peekToken() != CATCH && peekToken() != FINALLY)
+                throw pe("try without catch or finally");
+            
+            int catchJMPDistance = -1;
+            if (peekToken() == CATCH) {
+                Vec catchEnds = new Vec();
+                boolean catchAll = false;
+                
+                catchJMPDistance = b.size - tryInsn;
+                
+                while(peekToken() == CATCH && !catchAll) {
+                    String exceptionVar;
+                    getToken();
+                    consume(LP);
+                    consume(NAME);
+                    exceptionVar = string;
+                    int[] writebacks = new int[] { -1, -1, -1 };
+                    if (peekToken() != RP) {
+                        // extended XWT catch block: catch(e faultCode "foo.bar.baz")
+                        consume(NAME);
+                        String propName = string;
+                        b.add(parserLine, DUP);
+                        b.add(parserLine, LITERAL, string);
+                        b.add(parserLine, GET);
+                        b.add(parserLine, DUP);
+                        b.add(parserLine, LITERAL, null);
+                        b.add(parserLine, EQ);
+                        b.add(parserLine, JT);
+                        writebacks[0] = b.size - 1;
+                        if (peekToken() == STRING) {
+                            consume(STRING);
+                            b.add(parserLine, DUP);
+                            b.add(parserLine, LITERAL, string);
+                            b.add(parserLine, LT);
+                            b.add(parserLine, JT);
+                            writebacks[1] = b.size - 1;
+                            b.add(parserLine, DUP);
+                            b.add(parserLine, LITERAL, string + "/");   // (slash is ASCII after dot)
+                            b.add(parserLine, GE);
+                            b.add(parserLine, JT);
+                            writebacks[2] = b.size - 1;
+                        } else {
+                            consume(NUMBER);
+                            b.add(parserLine, DUP);
+                            b.add(parserLine, LITERAL, number);
+                            b.add(parserLine, EQ);
+                            b.add(parserLine, JF);
+                            writebacks[1] = b.size - 1;
+                        }
+                        b.add(parserLine, POP);  // pop the element thats on the stack from the compare
+                    } else {
+                        catchAll = true;
+                    }
+                    consume(RP);
+                    // the exception is on top of the stack; put it to the chosen name
+                    b.add(parserLine, NEWSCOPE);
+                    b.add(parserLine, TOPSCOPE);
+                    b.add(parserLine, SWAP);
+                    b.add(parserLine, LITERAL,exceptionVar);
+                    b.add(parserLine, DECLARE);
+                    b.add(parserLine, SWAP);
+                    b.add(parserLine, PUT);
+                    b.add(parserLine, POP);
+                    b.add(parserLine, POP);
+                    parseBlock(b, null);
+                    b.add(parserLine, OLDSCOPE);
+                    
+                    b.add(parserLine, JMP);
+                    catchEnds.addElement(new Integer(b.size-1));
+                    
+                    for(int i=0; i<3; i++) if (writebacks[i] != -1) b.set(writebacks[i], JS.N(b.size-writebacks[i]));
+                    b.add(parserLine, POP); // pop the element thats on the stack from the compare
+                }
+                
+                if(!catchAll)
+                    b.add(parserLine, THROW);
+                
+                for(int i=0;i<catchEnds.size();i++) {
+                    int n = ((Integer)catchEnds.elementAt(i)).intValue();
+                    b.set(n, JS.N(b.size-n));
+                }
+                
+                // pop the try and catch markers
+                b.add(parserLine,POP);
+                b.add(parserLine,POP);
+            }
+                        
+            // jump here if no exception was thrown
+            b.set(successJMPInsn, JS.N(b.size - successJMPInsn)); 
+                        
+            int finallyJMPDistance = -1;
+            if (peekToken() == FINALLY) {
+                b.add(parserLine, LITERAL, null); // null FinallyData
+                finallyJMPDistance = b.size - tryInsn;
+                consume(FINALLY);
+                parseStatement(b, null);
+                b.add(parserLine,FINALLY_DONE); 
+            }
+            
+            // setup the TRY arguments
+            b.set(tryInsn, new int[] { catchJMPDistance, finallyJMPDistance });
+            
+            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(parserLine, NEWSCOPE);                             // for-loops always create new scopes
+                b.add(parserLine, LITERAL, varName);                     // declare the new variable
+                b.add(parserLine, DECLARE);
+                    
+                b.add(parserLine, LOOP);                                 // we actually only add this to ensure that BREAK works
+                b.add(parserLine, POP);                                  // discard the first-iteration indicator
+                int size = b.size;
+                consume(NAME);
+                consume(IN);
+                startExpr(b, -1);
+                b.add(parserLine, PUSHKEYS);                             // push the keys as an array; check the length
+                b.add(parserLine, LITERAL, "length");
+                b.add(parserLine, GET);
+                consume(RP);
+                    
+                b.add(parserLine, LITERAL, JS.N(1));              // decrement the length
+                b.add(parserLine, SUB);
+                b.add(parserLine, DUP);
+                b.add(parserLine, LITERAL, JS.ZERO);              // see if we've exhausted all the elements
+                b.add(parserLine, LT);
+                b.add(parserLine, JF, JS.N(2));
+                b.add(parserLine, BREAK);                                // if we have, then BREAK
+                b.add(parserLine, GET_PRESERVE);                         // get the key out of the keys array
+                b.add(parserLine, LITERAL, varName);
+                b.add(parserLine, PUT);                                  // write it to this[varName]                          
+                parseStatement(b, null);                                 // do some stuff
+                b.add(parserLine, CONTINUE);                             // continue if we fall out the bottom
+
+                b.set(size - 1, JS.N(b.size - size + 1));       // BREAK to here
+                b.add(parserLine, OLDSCOPE);                             // restore the scope
+                    
+            } else {
+                if (hadVar) pushBackToken(VAR, null);                    // yeah, this actually matters
+                b.add(parserLine, NEWSCOPE);                             // grab a fresh scope
+                    
+                parseStatement(b, null);                                 // initializer
+                JSFunction e2 =                                    // we need to put the incrementor before the test
+                    new JSFunction(sourceName, parserLine, null);  // so we save the test here
+                if (peekToken() != SEMI)
+                    startExpr(e2, -1);
+                else
+                    e2.add(parserLine, b.LITERAL, Boolean.TRUE);         // handle the for(foo;;foo) case
+                consume(SEMI);
+                if (label != null) b.add(parserLine, LABEL, label);
+                b.add(parserLine, LOOP);
+                int size2 = b.size;
+                    
+                b.add(parserLine, JT, JS.ZERO);                   // 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(parserLine, POP);
+                }
+                b.set(size - 1, JS.N(b.size - size + 1));
+                consume(RP);
+                    
+                b.paste(e2);                                             // ok, *now* test if we're done yet
+                b.add(parserLine, JT, JS.N(2));                   // break out if we don't meet the test
+                b.add(parserLine, BREAK);
+                parseStatement(b, null);
+                b.add(parserLine, CONTINUE);                             // if we fall out the bottom, CONTINUE
+                b.set(size2 - 1, JS.N(b.size - size2 + 1));     // end of the loop
+                    
+                b.add(parserLine, 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(parserLine, POP);
+                if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1 && mostRecentlyReadToken != SEMI) consume(SEMI);
+                break;
+            }
+        }
+
+        case SEMI: return;                                               // yep, the null statement is valid
+
+        case LC: {  // blocks are statements too
+            pushBackToken();
+            b.add(parserLine, NEWSCOPE);
+            parseBlock(b, label);
+            b.add(parserLine, OLDSCOPE);
+            break;
+        }
+
+        default: {  // hope that it's an expression
+            pushBackToken();
+            startExpr(b, -1);
+            b.add(parserLine, POP);
+            if ((mostRecentlyReadToken != RC || peekToken() == SEMI) && peekToken() != -1 && mostRecentlyReadToken != SEMI) consume(SEMI);
+            break;
+        }
+        }
     }
 
-	public static Number toNumber(Object o) {
-	    if (o == null) return new Long(0);
-	    if (o instanceof Number) return ((Number)o);
-	    if (o instanceof String) return new Double((String)o);
-	    if (o instanceof Boolean) return ((Boolean)o).booleanValue() ? new Long(1) : new Long(0);
-	    if (o instanceof JS) return ((JS)o).coerceToNumber();
-	    // FIXME
-	    throw new Error("toNumber() got object of type " + o.getClass().getName());
-	}
- }
+
+    // ParserException //////////////////////////////////////////////////////////////////////
+    private IOException pe(String s) { return new IOException(sourceName + ":" + parserLine + " " + s); }
+    
+}