X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2Fjs%2FParser.java;h=c99ff7138e6f257b293c6d92d89979e5bca04ee0;hb=17b346d40a6ac856114dfae365e4f106933d14f9;hp=82da503b54e84bca920062a9c900e5491e22874d;hpb=9b9482f2939c8cb7526a8ca7ff43a7f2c2b5f97a;p=org.ibex.core.git

diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java
index 82da503..c99ff71 100644
--- a/src/org/xwt/js/Parser.java
+++ b/src/org/xwt/js/Parser.java
@@ -4,15 +4,21 @@ package org.xwt.js;
 import org.xwt.util.*;
 import java.io.*;
 
+
 /** parses a stream of lexed tokens into a tree of Expr's */
 public class Parser extends Lexer {
 
     // Constructors //////////////////////////////////////////////////////
 
-    public Parser(Reader r) throws IOException { super(r); }
+    public Parser(Reader r, String sourceName, int line) throws IOException {
+	super(r);
+	this.sourceName = sourceName;
+	this.line = line;
+    }
 
+    /** for debugging */
     public static void main(String[] s) throws Exception {
-	Parser p = new Parser(new InputStreamReader(System.in));
+	Parser p = new Parser(new InputStreamReader(System.in), "stdin", 0);
 	while(true) {
 	    Expr block = p.parseBlock(false);
 	    if (block == null) return;
@@ -25,322 +31,512 @@ public class Parser extends Lexer {
     // Statics ////////////////////////////////////////////////////////////
 
     static byte[] precedence = new byte[MAX_TOKEN + 1];
+    static boolean[] isRightAssociative = new boolean[MAX_TOKEN + 1];
     static {
-	precedence[COMMA] = 1;
-	precedence[ASSIGN] = 2;
-	precedence[GT] = precedence[GE] = 3;
+	precedence[ASSIGN] = 1;
+	isRightAssociative[ASSIGN] = true;
+	precedence[HOOK] = 2;
+	precedence[COMMA] = 3;
 	precedence[OR] = precedence[AND] = 4;
-	precedence[BITOR] = 5;
-	precedence[BITXOR] = 6;
-	precedence[BITAND] = 7;
-	precedence[EQ] = precedence[NE] = 8;
-	precedence[LT] = precedence[LE] = 9;
-	precedence[SHEQ] = precedence[SHNE] = 10;
-	precedence[LSH] = precedence[RSH] = precedence[URSH] = 11;
-	precedence[ADD] = precedence[SUB] = 12;
-	precedence[MUL] = precedence[DIV] = precedence[MOD] = 13;
-	precedence[BITNOT] = precedence[INSTANCEOF] = 14;
-	precedence[INC] = precedence[DEC] = 15;
-	precedence[LP] = 16;
-	precedence[DOT] = 17;
+	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] = precedence[INSTANCEOF] = 15;
+	precedence[INC] = precedence[DEC] = 16;
+	precedence[LP] = 17;
+	precedence[LB] = 18;
+	precedence[DOT] = 19;
     }
 
 
     // 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 Error("expected {");
-	if (braced) getToken();
-	Expr head = null;
-	Expr tail = null;
-	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(tok, parseMaximalExpr());
-		if (getToken() != SEMI) throw new Error("expected ;");
-		break;
-	    case GOTO: case BREAK: case CONTINUE:
-		getToken();
-		if (getToken() == NAME)
-		    smt = new Expr(tok, new Expr(string));
-		else if (tok == GOTO)
-		    throw new Error("goto must be followed by a label");
-		else
-		    smt = new Expr(tok);
-		if (getToken() != SEMI) throw new Error("expected ;");
-		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 Error("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(LC, head);
+    public void consume(int code) throws IOException {
+	int got = getToken();
+	if (got != code) throw new ParserException("expected " + codeToString[code] + ", got " + (got == -1 ? "EOL" : codeToString[got]));
+    }
+    public void consume(int code, int code2) throws IOException {
+	int got = getToken();
+	if (got != code && got != code2)
+	    throw new ParserException("expected " + codeToString[code] + " or " + codeToString[code2] +
+				      ", got " + (got == -1 ? "EOL" : codeToString[got]));
     }
-
-    /** 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 Error("expected " + codeToString[got] + ", got " + (got == -1 ? "EOL" : codeToString[got]));
+	if (got != code) throw new ParserException("expected " + codeToString[code] + ", got " + (got == -1 ? "EOL" : codeToString[got]));
     }
 
     /** parses the largest possible expression */
     public Expr parseMaximalExpr() throws IOException { return parseMaximalExpr(null, -1); }
     public Expr parseMaximalExpr(Expr prefix, int minPrecedence) throws IOException {
-	Expr save = null;
 	while(true) {
-	    save = prefix;
 	    if (peekToken() == -1) break;
+	    Expr save = prefix;
 	    prefix = parseSingleExpr(prefix, minPrecedence);
 	    if (save == prefix) break;
-	    if (prefix == null) throw new Error("parseSingleExpr_() returned null");
+	    if (prefix == null) throw new ParserException("parseSingleExpr() returned null");
 	}
 	return prefix;
     }
 
-    /** parses the smallest possible complete expression */
-    public Expr parseSingleExpr() throws IOException { return parseSingleExpr(null, 0); }
-
-    /** parses the smallest possible complete expression beginning with prefix and only using operators with at least minPrecedence */
     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 && precedence[tok] <= minPrecedence) return prefix;
+	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 Error("XWT does not allow the WITH keyword");
-	case VOID: case RESERVED: throw new Error("reserved word that you shouldn't be using");
-	case NAME: if (prefix != null) { pushBackToken(); return prefix; } else return parseMaximalExpr(new Expr(NAME, string), minPrecedence);
-	case STRING: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(string);
-	case NUMBER: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(number);
-	case NULL: case TRUE: case FALSE: case NOP: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(tok);
+	case VAR: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.THIS, NO_ARG);
+	    while(true) {
+		consume(NAME);
+		String name = string;
+		b.add(b.DECLARE, name);
+		if (peekToken() == ASSIGN) {
+		    b.add(b.LITERAL, name);
+		    consume(ASSIGN);
+		    b.add(b.EXPR, parseMaximalExpr());
+		    b.add(b.PUT, NO_ARG);
+		    b.add(b.POP, NO_ARG);
+		}
+		if (peekToken() != COMMA) break;
+		consume(COMMA);
+	    }
+	    return b;
+	}
 
-        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(ASSIGN, prefix, new Expr(tok - 1, prefix, parseMaximalExpr(null, precedence[ASSIGN])));
+	case IN: pushBackToken(); return prefix;
 
-        case BITOR: case BITXOR: case BITAND: case SHEQ: case SHNE: case LSH:
-	case RSH: case URSH: case ADD: case SUB: case MUL: case DIV: case MOD:
-	case COMMA: case ASSIGN: case GT: case GE: case OR: case AND:
-	case EQ: case NE: case LT: case LE: case DOT:
-	    return new Expr(tok, prefix, parseMaximalExpr(null, precedence[tok]));
+	case IF: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    ByteCode b = new ByteCode(curLine);
+	    consume(LP);
+	    b.add(b.EXPR, parseMaximalExpr());
+	    consume(RP);
+	    b.add(b.JF, new Integer(3));
+	    b.add(b.EXPR, parseBlock(false));
+	    b.add(b.JMP, new Integer(2));
+	    if (peekToken() != ELSE) return b.add(b.LITERAL, null);
+	    consume(ELSE);
+	    b.add(b.EXPR, parseBlock(false));
+	    return b;
+	}
 
-	case BITNOT: case INSTANCEOF:
-	    if (prefix != null) throw new Error("didn't expect non-null prefix!");
-	    return new Expr(tok, parseMaximalExpr(null, precedence[tok]));
+	    // FIXME: ugly hack!!
+        case ASSIGN_BITOR: if (tok == ASSIGN_BITOR) tok = BITOR;
+	case ASSIGN_BITXOR: if (tok == ASSIGN_BITXOR) tok = BITXOR;
+	case ASSIGN_BITAND: if (tok == ASSIGN_BITAND) tok = BITAND;
+	case ASSIGN_LSH: if (tok == ASSIGN_LSH) tok = LSH;
+	case ASSIGN_RSH: if (tok == ASSIGN_RSH) tok = RSH;
+	case ASSIGN_URSH: if (tok == ASSIGN_URSH) tok = URSH;
+	case ASSIGN_ADD: if (tok == ASSIGN_ADD) tok = ADD;
+	case ASSIGN_SUB: if (tok == ASSIGN_SUB) tok = SUB;
+	case ASSIGN_MUL: if (tok == ASSIGN_MUL) tok = MUL;
+	case ASSIGN_DIV: if (tok == ASSIGN_DIV) tok = DIV;
+	case ASSIGN_MOD: if (tok == ASSIGN_MOD) tok = MOD;
+	    {
+		ByteCode b = (ByteCode)prefix;
+		b.set(b.size() - 1, b.GET_PRESERVE, new Boolean(true));
+		b.add(b.EXPR, parseMaximalExpr(null, precedence[tok]));
+		b.add(tok, NO_ARG);
+		b.add(b.PUT, NO_ARG);
+		b.add(b.SWAP, NO_ARG);
+		b.add(b.POP, NO_ARG);
+		return b;
+	    }
 
 	case INC: case DEC:
 	    if (prefix == null) {
 		// prefix
-		return new Expr(tok, parseMaximalExpr(null, precedence[tok]));
+		ByteCode b = (ByteCode)parseMaximalExpr(null, precedence[tok]);
+		b.set(b.size() - 1, tok, new Boolean(true));
+		return b;
 	    } else {
 		// postfix
-		return new Expr(tok, null, prefix);
+		ByteCode b = (ByteCode)prefix;
+		b.set(b.size() - 1, tok, new Boolean(false));
+		return b;
 	    }
 
 	case LP:
 	    if (prefix == null) {  // grouping
-		Expr r = parseMaximalExpr();
-		expect(RP); getToken();
-		return r;
+		ByteCode b = new ByteCode(curLine, ByteCode.EXPR, parseMaximalExpr());
+		consume(RP);
+		return b;
 
 	    } else {  // invocation
+		ByteCode b = new ByteCode(curLine);
+		int i = 0;
+		b.add(b.EXPR, prefix);
 		while(peekToken() != RP) {
-		    Expr e = parseMaximalExpr(null, precedence[COMMA]);
-		    if (head == null) head = tail = e; else tail = tail.next = e;
-		    tok = getToken();
-		    if (tok == RP) { pushBackToken(); break; }
-		    if (tok != COMMA) throw new Error("expected comma or right paren, got " + codeToString[tok]);
+		    b.add(b.EXPR, parseMaximalExpr());
+		    i++;
+		    if (peekToken() == RP) break;
+		    consume(COMMA);
 		}
+		consume(RP);
+		b.add(b.CALL, new Integer(i));
+		return b;
+	    }
+
+	case BANG: case BITNOT: case INSTANCEOF: case TYPEOF: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.EXPR, parseMaximalExpr(null, precedence[tok]));
+	    b.add(tok, NO_ARG);
+	    return b;
+	}
+
+	case SUB:
+	    if (prefix == null && peekToken() == NUMBER) {
 		getToken();
-		return new Expr(LP, prefix, head);
+		return new ByteCode(curLine, ByteCode.LITERAL, 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 GT: case GE: case EQ: case NE: case LT: case LE: {
+	    if (prefix == null) throw new ParserException("the " + codeToString[tok] + " token cannot start an expression");
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.EXPR, prefix);
+	    b.add(b.EXPR, parseMaximalExpr(null, precedence[tok]));
+	    b.add(tok, NO_ARG);
+	    return b;
+	}
+
+	    // includes short-circuit logic
+	case OR: case AND: {
+	    if (prefix == null) throw new ParserException("the " + codeToString[tok] + " token cannot start an expression");
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.LITERAL, tok == AND ? new Boolean(false) : new Boolean(true));
+	    b.add(b.EXPR, prefix);
+	    b.add(tok == AND ? b.JF : b.JT, new Integer(3));
+	    b.add(b.POP, NO_ARG);
+	    b.add(b.EXPR, parseMaximalExpr(null, precedence[tok]));
+	    return b;
+	}
+
+	case ASSIGN: {
+	    if (prefix == null) throw new ParserException("the " + codeToString[tok] + " token cannot start an expression");
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.THIS, NO_ARG);
+	    b.add(b.LITERAL, prefix.string);   // FIXME, this is ass-ugly
+	    b.add(b.EXPR, parseMaximalExpr(null, precedence[ASSIGN]));
+	    b.add(b.PUT, NO_ARG);
+	    b.add(b.SWAP, NO_ARG);
+	    b.add(b.POP, NO_ARG);
+	    return b;
+	}
+
+	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 NUMBER:
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    return new ByteCode(curLine, ByteCode.LITERAL, number);
+
+	case STRING:
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    return new ByteCode(curLine, ByteCode.LITERAL, string);
+
+	case NULL: case TRUE: case FALSE: case NOP:
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    return new ByteCode(curLine, ByteCode.LITERAL, (tok == NULL || tok == NOP) ? null : new Boolean(tok == TRUE));
+
+	case COMMA: pushBackToken(); return prefix;
+
+	case THIS:
+	    if (prefix != null) { pushBackToken(); return prefix; } 
+	    return new ByteCode(curLine, ByteCode.THIS, NO_ARG);
+
+	    // potential lvalues
+
+	case NAME: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    String name = string;
+	    ByteCode b = new ByteCode(curLine);
+	    if (peekToken() == ASSIGN) {
+		consume(ASSIGN);
+		b.add(ByteCode.THIS, NO_ARG);
+		b.add(ByteCode.LITERAL, name);
+		b.add(ByteCode.EXPR, parseMaximalExpr(null, minPrecedence));
+		b.add(ByteCode.PUT, NO_ARG);
+		b.add(ByteCode.SWAP, NO_ARG);
+		b.add(ByteCode.POP, NO_ARG);
+		return b;
+	    } else {
+		b.add(ByteCode.THIS, NO_ARG);
+		b.add(ByteCode.LITERAL, name);
+		b.add(ByteCode.GET, NO_ARG);
+		return parseMaximalExpr(b, minPrecedence);
 	    }
+	}
 
-	case LB:
-	    if (prefix != null) {
-		// subscripting
-		e1 = parseMaximalExpr();
-		if (getToken() != RB) throw new Error("expected a right brace");
-		return new Expr(LB, prefix, e1);
+	case DOT: {
+	    consume(NAME);
+	    String target = string;
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.EXPR, prefix);
+	    if (peekToken() == ASSIGN) {
+		consume(ASSIGN);
+		Expr val = parseMaximalExpr();
+		b.add(b.LITERAL, target);
+		b.add(b.EXPR, val);
+		b.add(b.PUT, NO_ARG);
+		b.add(b.SWAP, NO_ARG);
+		b.add(b.POP, NO_ARG);
 	    } else {
-		// array ctor
-		tok = getToken();
+		b.add(b.LITERAL, target);
+		b.add(b.GET, NO_ARG);
+	    }
+	    return b;
+	}
+
+	case LB: {
+	    ByteCode b = new ByteCode(curLine);
+	    if (prefix == null) {
+		b.add(b.ARRAY, new Integer(0));
+		int i = 0;
 		while(true) {
-		    if (tok == RB) return new Expr(LB, prefix, head);
-		    if (head == null) head = tail = parseMaximalExpr(null, precedence[COMMA]);
-		    else tail = tail.next = parseMaximalExpr(null, precedence[COMMA]);
-		    tok = getToken();
-		    if (tok != COMMA && tok != RP) throw new Error("expected right bracket or comma");
+		    Expr e = parseMaximalExpr();
+		    if (e == null && peekToken() == RB) { consume(RB); return b; }
+		    b.add(b.LITERAL, new Integer(i++));
+		    if (e == null) b.add(b.LITERAL, null);
+		    else b.add(b.EXPR, e);
+		    b.add(b.PUT, NO_ARG);
+		    b.add(b.POP, NO_ARG);
+		    if (peekToken() == RB) { consume(RB); return b; }
+		    consume(COMMA);
+		}
+	    } else {
+		b.add(b.EXPR, prefix);
+		b.add(b.EXPR, parseMaximalExpr());
+		consume(RB);
+		if (peekToken() == ASSIGN) {
+		    consume(ASSIGN);
+		    b.add(b.EXPR, parseMaximalExpr());
+		    b.add(b.PUT, NO_ARG);
+		    b.add(b.SWAP, NO_ARG);
+		    b.add(b.POP, NO_ARG);
+		} else {
+		    b.add(b.GET, NO_ARG);
 		}
+		return b;
 	    }
+	}
+
+	    // end //
 	    
-	case LC:
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
-	    tok = getToken();
+	case LC: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.OBJECT, null);
+	    if (peekToken() == RC) { consume(RC); return b; }
 	    while(true) {
-		if (tok == RC) return new Expr(LC, head);
-		if (tok != NAME) throw new Error("expecting name");
-		expect(NAME); getToken();
-		Expr name = new Expr(NAME, string);
-		if (tok != COLON) throw new Error("expecting colon");		
-		e1 = new Expr(COLON, name, parseMaximalExpr(null, precedence[COMMA]));
-		if (head == null) head = tail = e1; else tail = tail.next = e1;
-		tok = getToken();
-		if (tok != COMMA && tok != RP) throw new Error("expected right curly or comma");
+		consume(NAME, STRING);
+		b.add(b.LITERAL, string);
+		consume(COLON);
+		b.add(b.EXPR, parseMaximalExpr());
+		b.add(b.PUT, NO_ARG);
+		b.add(b.POP, NO_ARG);
+		if (peekToken() == RC) { consume(RC); return b; }
+		consume(COMMA);
+		if (peekToken() == RC) { consume(RC); return b; }
 	    }
+	}
 	    
-	case HOOK:
-	    e2 = parseMaximalExpr();
-	    if (getToken() != COLON) throw new Error("expected colon to close ?: expression");
-	    e3 = parseMaximalExpr();
-	    return new Expr(HOOK, prefix, new Expr(ELSE, e2, e3));
-	    
-	case SWITCH: {
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
-	    if (getToken() != LP) throw new Error("expected left paren");
-	    Expr switchExpr = parseMaximalExpr();
-	    if (getToken() != RP) throw new Error("expected left paren");
-	    if (getToken() != LC) throw new Error("expected left brace");
-	    Expr firstExpr = null;
-	    Expr lastExpr = null;
-	    while(true) {
-		if (getToken() != CASE) throw new Error("expected CASE");
-		Expr caseExpr = parseMaximalExpr();
-		if (getToken() != COLON) throw new Error("expected COLON");
-		Expr e = new Expr(CASE, caseExpr, parseBlock(false));
-		if (lastExpr == null) firstExpr = e;
-		else lastExpr.next = e;
-		lastExpr = e;
-		if (getToken() == RC) return new Expr(SWITCH, switchExpr, firstExpr);
-	    }
+	case HOOK: {
+	    ByteCode b = new ByteCode(curLine);
+	    b.add(b.EXPR, prefix);
+	    b.add(b.JF, new Integer(3));
+	    b.add(b.EXPR, parseMaximalExpr());
+	    b.add(b.JMP, new Integer(2));
+	    consume(COLON);
+	    b.add(b.EXPR, parseMaximalExpr());
+	    return b;
 	}
 	    
 	case FUNCTION: {
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
-	    if (getToken() != LP) throw new Error("function keyword must be followed by a left paren");
-	    Expr formalArgs = null, cur = null;
-	    tok = getToken();
-	    while(tok != RP) {
-		if (tok != NAME) throw new Error("expected a variable name");
-		if (cur == null) { formalArgs = cur = new Expr(string); }
-		else { cur.next = new Expr(NAME, string); cur = cur.next; }
-		tok = getToken();
-		if (tok == RP) break;
-		if (tok != COMMA) throw new Error("function argument list must consist of alternating NAMEs and COMMAs");
-		tok = getToken();
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    consume(LP);
+	    ByteCode b = new ByteCode(curLine);
+	    int numArgs = 0;
+	    b.add(b.THIS, NO_ARG);
+	    b.add(b.SWAP, NO_ARG);
+	    b.add(b.LITERAL, "arguments");
+	    b.add(b.LITERAL, "arguments");
+	    b.add(b.DECLARE, NO_ARG);
+	    b.add(b.SWAP, NO_ARG);
+	    b.add(b.PUT, NO_ARG);
+	    b.add(b.SWAP, NO_ARG);
+	    b.add(b.POP, NO_ARG);
+	    if (peekToken() == RP) consume(RP);
+	    else while(true) {
+		if (peekToken() == COMMA) {
+		    consume(COMMA);
+		} else {
+		    consume(NAME);
+
+		    // declare the name
+		    b.add(b.LITERAL, string);
+		    b.add(b.DECLARE, NO_ARG);
+
+		    // retrieve it from the arguments array
+		    b.add(b.LITERAL, new Integer(numArgs));
+		    b.add(b.GET_PRESERVE, NO_ARG);
+		    b.add(b.SWAP, NO_ARG);
+		    b.add(b.POP, NO_ARG);
+
+		    // put it to the current scope
+		    b.add(b.THIS, NO_ARG);
+		    b.add(b.SWAP, NO_ARG);
+		    b.add(b.LITERAL, string);
+		    b.add(b.SWAP, NO_ARG);
+		    b.add(b.PUT, NO_ARG);
+
+		    // clean the stack
+		    b.add(b.POP, NO_ARG);
+		    b.add(b.POP, NO_ARG);
+
+		    if (peekToken() == RP) { consume(RP); break; }
+		    consume(COMMA);
+		}
+		numArgs++;
 	    }
-	    return new Expr(FUNCTION, formalArgs, parseBlock(true));
+	    // pop off the arguments array
+	    b.add(b.POP, NO_ARG);
+	    parseBlock(true, b);
+	    return new ByteCode(curLine, b.FUNCTION, b);
 	}
 	    
-	case VAR:
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
+	    // Needs break //
+
+	case SWITCH: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    consume(LP);
+	    Expr switchExpr = parseMaximalExpr();
+	    consume(RP);
+	    consume(LC);
+	    ExprList toplevel = new ExprList(curLine, LC);
 	    while(true) {
-		if (getToken() != NAME) throw new Error("variable declarations must start with a variable name");
-		Expr name = new Expr(NAME, string);
-		Expr initVal = null;
-		tok = peekToken();
-		Expr e = null;
-		if (tok == ASSIGN) {
-		    getToken();
-		    initVal = parseMaximalExpr(null, precedence[COMMA]);
-		    tok = peekToken();
-		    e = new Expr(ASSIGN, name, initVal);
-		} else {
-		    e = new Expr(NAME, name);
+		tok = getToken();
+		Expr caseExpr;
+		if (tok == DEFAULT) caseExpr = null;
+		else if (tok == CASE) caseExpr = parseMaximalExpr();
+		else throw new ParserException("expected CASE or DEFAULT");
+		consume(COLON);
+		// FIXME: we shouldn't be creating a scope here
+		ExprList list = new ExprList(curLine, LC);
+		while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) {
+		    if ((e1 = parseBlock(false)) == null) break;
+		    list.add(e1);
 		}
-		if (head == null) head = tail = e; else tail = tail.next = e;
-		if (tok != COMMA) break;
-		getToken();
+		toplevel.add(new Expr(curLine, tok, caseExpr, list));
+		if (peekToken() == RC) { consume(RC); return new Expr(curLine, SWITCH, switchExpr, toplevel); }
 	    }
-	    return new Expr(VAR, head);
-
+	}
+	    
 	case TRY: {
 	    // We deliberately allow you to omit braces in catch{}/finally{} if they are single statements...
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
+	    if (prefix != null) { pushBackToken(); return prefix; }
 	    Expr tryBlock = parseBlock(true);
-	    while ((tok = peekToken()) == CATCH || tok == FINALLY) {
+	    
+	    tok = peekToken();
+	    ExprList list = new ExprList(curLine, TRY);
+	    if (tok == CATCH) {
 		getToken();
-		if (getToken() != LP) throw new Error("expected (");
-		if (getToken() != NAME) throw new Error("expected name");
-		Expr name = new Expr(NAME, string);
-		if (getToken() != RP) throw new Error("expected )");
-		e1 = new Expr(tok, name, parseBlock(false));
-		if (head == null) head = tail = e1; else tail = tail.next = e1;
+		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 )");
+		list.add(new Expr(curLine, CATCH, name, parseBlock(false)));
+		tok = peekToken();
 	    }
-	    if (head == null) throw new Error("try without catch or finally");
-	    return new Expr(TRY, tryBlock, head);
+	    if (tok == FINALLY) {
+		getToken();
+		list.add(new Expr(curLine, FINALLY, parseBlock(false)));
+	    }
+
+	    if (list.size() == 0) throw new ParserException("try without catch or finally");
+	    return new Expr(curLine, TRY, tryBlock, list);
 	}
 
-	case IF: case WHILE: {
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
-	    if (getToken() != LP) throw new Error("expected left paren");
+	case WHILE: {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    consume(LP);
 	    Expr parenExpr = parseMaximalExpr();
 	    int t;
-	    if ((t = getToken()) != RP) throw new Error("expected right paren, but got " + codeToString[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(tok, parenExpr, new Expr(ELSE, firstBlock, parseBlock(false)));
-	    }
-	    return new Expr(tok, parenExpr, firstBlock);
+	    ExprList list = new ExprList(curLine, WHILE);
+	    list.add(parenExpr);
+	    list.add(firstBlock);
+	    list.add(new Expr(curLine, NULL));
+	    return list;
 	}
 
-	case IN: return prefix;
 	case FOR:
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
-	    if (getToken() != LP) throw new Error("expected left paren");
-	    e1 = parseMaximalExpr(null, -1);
-	    if (e1.code == NAME && peekToken() == IN) {
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    if (getToken() != LP) throw new ParserException("expected left paren");
+	    e1 = parseMaximalExpr();
+	    if (peekToken() == IN) {
 		getToken();
-		e2 = parseMaximalExpr(null, -1);
-		if (getToken() != RP) throw new Error("expected right paren");
-		return new Expr(FOR, new Expr(IN, e1, e2), parseBlock(false));
+		e2 = parseMaximalExpr();
+		if (getToken() != RP) throw new ParserException("expected right paren");
+		return new Expr(curLine, FOR, new Expr(curLine, IN, e1.left, e2), parseBlock(false));
 		
 	    } else {
-		if (getToken() != SEMI) throw new Error("expected ;");
-		e2 = parseMaximalExpr(null, -1);
-		if (getToken() != SEMI) throw new Error("expected ;");
-		e3 = parseMaximalExpr(null, -1);
-		if (getToken() != RP) throw new Error("expected right paren");
-		return new Expr(LC, e1, new Expr(WHILE, e2, new Expr(LC, parseBlock(false), e3)));
+		Expr initExpr = e1;
+		if (initExpr == null) initExpr = new Expr(curLine, NULL);
+		expect(SEMI); getToken();
+		Expr whileExpr = parseMaximalExpr();
+		expect(SEMI); getToken();
+		Expr incExpr = parseMaximalExpr();
+		expect(RP); getToken();
+		Expr body = parseBlock(false);
+		Expr loop = new Expr(curLine, WHILE, whileExpr, body);
+		ExprList list = new ExprList(curLine, LC);
+		list.add(initExpr);
+		ExprList list2 = new ExprList(curLine, WHILE);
+		list.add(list2);
+		list2.add(whileExpr);
+		list2.add(body);
+		list2.add(incExpr);
+		return list;
 	    }
 	    
 	case DO: {
-	    if (prefix != null) throw new Error("didn't expect non-null prefix");
-	    Expr firstBlock = parseBlock(false);
-	    if (getToken() != WHILE) throw new Error("expecting WHILE");
-	    if (getToken() != LP) throw new Error("expected left paren");
-	    Expr whileExpr = parseMaximalExpr();
-	    if (getToken() != RP) throw new Error("expected right paren");
-	    if (getToken() != SEMI) throw new Error("semicolon");
-	    return new Expr(DO, firstBlock, whileExpr);
+	    if (prefix != null) { pushBackToken(); return prefix; }
+	    ExprList list = new ExprList(curLine, DO);
+	    Expr body = parseBlock(false);
+	    consume(WHILE);
+	    consume(LP);
+	    list.add(parseMaximalExpr());
+	    list.add(body);
+	    list.add(new Expr(curLine, NULL));
+	    consume(RP);
+	    consume(SEMI);
+	    return list;
 	}
 	    
 	default:
@@ -349,5 +545,613 @@ public class Parser extends Lexer {
 	}
     }
     
-}
+    // Expr //////////////////////////////////////////////////////////////////////
+
+    public static final Object NO_ARG = new Object();
+
+    class ByteCode extends Expr {
+
+	// This class interprets a small forthlike bytecode language
+	// we use to represent JavaScript.  It's a stack machine.
+
+	// Each instruction is an opcode and a literal.  Any operation
+	// that accesses the top of the stack and does not have a
+	// mandatory literal can be performed on a literal instead of
+	// the top of the stack.
+
+	// opcodes:
+	public static final byte arithmetic = -1;  //                               -- arithmetic operators from parser
+	public static final byte LITERAL = -2;     // < String | Number | null >    -- push a literal onto the stack
+	public static final byte ARRAY = -3;       // < size >                      -- create a new array of size <size>
+	public static final byte OBJECT = -4;      //                               -- push an empty object onto the stack
+	public static final byte FUNCTION = -5;    // < bytecode_block >            -- push a new instance of a function with the given bytecode
+	public static final byte DECLARE = -6;     // < name >                      -- declare <name> in the current scope
+	public static final byte THIS = -7;        //                               -- push the topmost non-transparent scope onto the stack
+	public static final byte GET = -8;         //                               -- get stack[0] from stack[1]
+	public static final byte GET_PRESERVE = -80;         //                               -- get stack[0] from stack[1]
+	public static final byte PUT = -9;         //                               -- put stack[1] to key stack[0] on stack[2]; leaves object on the stack
+	public static final byte THROW = -10;      //                               -- throw topmost element
+	public static final byte RETURN = -11;     //                               -- return the topmost value on the stack
+	public static final byte ASSERT = -12;     //                               -- fail if topmost element is not true
+	public static final byte JT = -13;         // < relative_address >          -- pop the stack; if true, jump to <relative_address>
+	public static final byte JF = -21;         // < relative_address >          -- pop the stack; if false, jump to <relative_address>
+	public static final byte JMP = -22;        // < relative_address >          -- jump to <relative_address>
+        static public final byte POP = -14;        //                               -- discard the top element on the stack
+
+	public static final byte CALL = -15;       // < numargs >                   -- call stack[0] with the topmost <numargs> values as arguments
+	public static final byte TRY = -16;        // < bytecode_block >            -- run the block pointed to; returns with thrown exn on top of stack
+
+	public static final byte INSTANCEOF = -17; //                               -- ??
+	public static final byte TYPEOF = -18;     //                               --
+
+	public static final byte FOR__IN = -19;    //                               -- ??
+	public static final byte EXPR = -20;       //                               -- transitional
+	public static final byte SWAP = -23;       //                               -- transitional
+	public static final byte SCOPE = -30;       //                               -- transitional
+
+	int[] op = new int[10];
+	Object[] arg = new Object[10];
+	int size = 0;
+
+	public ByteCode(int line) { super(line, "foo"); }
+	public ByteCode(int line, int op_, Object arg_) { this(line); add(op_, arg_); }
+
+	public int size() { return size; }
+	public void set(int pos, int op_, Object arg_) { op[pos] = op_; arg[pos] = arg_; }
+	public ByteCode add(int op_, Object arg_) {
+	    if (size == op.length - 1) {
+		int[] op2 = new int[op.length * 2]; System.arraycopy(op, 0, op2, 0, op.length); op = op2;
+		Object[] arg2 = new Object[op.length * 2]; System.arraycopy(arg, 0, arg2, 0, arg.length); arg = arg2;
+	    }
+	    op[size] = op_;
+	    arg[size] = arg_;
+	    size++;
+	    return this;
+	}
+	
+	public Object eval(final JS.Scope s) throws ControlTransferException, JS.Exn {
+	    return eval(s, new Parser.Thread());
+	}
+	public Object eval(final JS.Scope s, Parser.Thread t) throws ControlTransferException {
+	    for(int i=0; i<size; i++)
+		switch(op[i]) {
+		case arithmetic: break;
+		case LITERAL:
+		    t.push(arg[i]);
+		    break;
+		case OBJECT: t.push(new JS.Obj()); break;
+		case ARRAY: t.push(new JS.Array(toNumber(arg[i]).intValue())); break;
+		case DECLARE: s.declare(arg[i] == NO_ARG ? (String)t.pop() : (String)arg[i]); break;
+		case THIS: t.push(s); break;   // FIXME: transparents
+		case ASSERT: if (!toBoolean(t.pop())) throw new EvaluatorException("assertion failed"); break;
+		case THROW: throw new JS.Exn(t.pop());
+		case JT: if (toBoolean(t.pop())) i += toNumber(arg[i]).intValue() - 1; break;
+		case JF: if (!toBoolean(t.pop())) i += toNumber(arg[i]).intValue() - 1; break;
+		case JMP: i += toNumber(arg[i]).intValue() - 1; break;
+		case POP: t.pop(); break;
+		case SWAP: t.swap(); break;
+		    
+		case PUT: {
+		    Object val = arg[i] == NO_ARG ? t.pop() : arg[i];
+		    Object key = t.pop();
+		    ((JS)t.peek()).put(key, val);
+		    t.push(val);
+		    break;
+		}
+
+		case GET: {
+		    Object v = arg[i] == NO_ARG ? t.pop() : arg[i];
+		    Object o = t.pop();
+		    t.push(doGet(o, v));
+		    break;
+		}
+		case GET_PRESERVE: {
+		    Object v = t.pop();
+		    Object o = t.peek();
+		    t.push(v);
+		    t.push(doGet(o, v));
+		    break;
+		}
+		case NOP: break;
+		    
+		case EXPR: t.push(((Expr)arg[i]).eval(s)); break;
+		case SCOPE: t.push(((Expr)arg[i]).eval(new JS.Scope(s))); break;
+		    
+		case CALL:
+		    JS.Array arguments = new JS.Array();
+		    int numArgs = toNumber(arg[i]).intValue();
+		    arguments.setSize(numArgs);
+		    for(int j=numArgs - 1; j >= 0; j--) arguments.setElementAt(t.pop(), j);
+		    JS.Function f = (JS.Function)t.pop();
+		    if (f == null) throw new JS.Exn(new EvaluatorException("attempted to call null"));
+		    t.push(f.call(arguments));
+		    break;
+
+		case FUNCTION: {
+		    final ByteCode myBytes = (ByteCode)arg[i];
+		    t.push(new JS.Function() {
+			public String toString() { return sourceName + ":" + line; }
+			public String getSourceName() throws JS.Exn { return sourceName; }
+			public Object _call(final JS.Array args) throws JS.Exn {
+			    Function save = JS.getCurrentFunction();
+			    JS.currentFunction.put(java.lang.Thread.currentThread(), this);
+			    JS.Scope scope = new JS.Scope(s) {
+				    // FIXME
+				    public String getSourceName() { return sourceName; }
+				    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;
+					return super.get(key);
+				    }
+				};
+			    Parser.Thread t0 = new Parser.Thread();
+			    t0.push(args);
+			    try {
+				return myBytes.eval(scope, t0);
+			    } 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(java.lang.Thread.currentThread());
+				else JS.currentFunction.put(java.lang.Thread.currentThread(), save);
+			    }
+			}
+		    });
+		    break;
+		}
+
+		case RETURN: break;
+		case TRY: break;
+		case INSTANCEOF: break;
+		case TYPEOF: break;
+		case FOR__IN: break;
+
+		case Lexer.BITNOT: t.push(new Long(~toLong(t.pop()))); break;
+		case Lexer.BANG: t.push(new Boolean(!toBoolean(t.pop()))); break;
+
+		case Lexer.INC: case Lexer.DEC: {
+		    boolean isPrefix = toBoolean(arg[i]);
+		    Object key = t.pop();
+		    JS obj = (JS)t.pop();
+		    Number num = toNumber(obj.get(key));
+		    Number val = new Double(op[i] == Lexer.INC ? num.doubleValue() + 1.0 : num.doubleValue() - 1.0);
+		    obj.put(key, val);
+		    t.push(isPrefix ? val : num);
+		    break;
+		}
+
+		default: {
+		    Object right = t.pop();
+		    Object left = t.pop();
+		    switch(op[i]) {
+
+		    case Lexer.BITOR: t.push(new Long(toLong(left) | toLong(right))); break;
+		    case Lexer.BITXOR: t.push(new Long(toLong(left) ^ toLong(right))); break;
+		    case Lexer.BITAND: t.push(new Long(toLong(left) & toLong(right))); break;
+
+		    case Lexer.ADD: {
+			Object l = left;
+			Object r = right;
+			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());
+			    t.push(l.toString() + r.toString()); break;
+			}
+			t.push(new Double(toDouble(l) + toDouble(r))); break;
+		    }
+			
+		    case Lexer.SUB: t.push(new Double(toDouble(left) - toDouble(right))); break;
+		    case Lexer.MUL: t.push(new Double(toDouble(left) * toDouble(right))); break;
+		    case Lexer.DIV: t.push(new Double(toDouble(left) / toDouble(right))); break;
+		    case Lexer.MOD: t.push(new Double(toDouble(left) % toDouble(right))); break;
+			
+		    case Lexer.LSH: t.push(new Long(toLong(left) << toLong(right))); break;
+		    case Lexer.RSH: t.push(new Long(toLong(left) >> toLong(right))); break;
+		    case Lexer.URSH: t.push(new Long(toLong(left) >>> toLong(right))); break;
+			
+			// FIXME: these need to work on strings
+		    case Lexer.LT: t.push(toDouble(left) < toDouble(right) ? Boolean.TRUE : Boolean.FALSE); break;
+		    case Lexer.LE: t.push(toDouble(left) <= toDouble(right) ? Boolean.TRUE : Boolean.FALSE); break;
+		    case Lexer.GT: t.push(toDouble(left) > toDouble(right) ? Boolean.TRUE : Boolean.FALSE); break;
+		    case Lexer.GE: t.push(toDouble(left) >= toDouble(right) ? Boolean.TRUE : Boolean.FALSE); break;
+		    
+		    case Lexer.EQ:
+		    case Lexer.NE: {
+			// FIXME: should use Javascript coercion-equality rules
+			Object l = left;
+			Object r = right;
+			boolean ret;
+			if (l == null) { Object tmp = r; r = l; l = tmp; }
+			if (l == null && r == null) ret = true;
+			else if (l instanceof Boolean) ret = new Boolean(toBoolean(r)).equals(l);
+			else if (l instanceof Number) ret = toNumber(r).doubleValue() == toNumber(l).doubleValue();
+			else if (l instanceof String) ret = r != null && l.equals(r.toString());
+			else ret = l.equals(r);
+			t.push(new Boolean(op[i] == Lexer.EQ ? ret : !ret)); break;
+		    }
+
+		    default: throw new Error("unknown opcode " + op[i]);
+		    } }
+		}
+	    if (t.size() != 1) {
+		throw new EvaluatorException("eval() terminated with " + t.size() + " elements on the stack; one expected");
+	    }
+	    return t.pop();
+	}
+
+	public Object doGet(final Object o, final Object v) {
+	    if (o == null) throw new EvaluatorException("tried to get property \"" + v + "\" from the null value");
+	    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 Error("String.substring() can only take one or two arguments");
+			}
+		    };
+		else if (v.equals("toLowerCase")) return new JS.Function() {
+			public Object _call(JS.Array args) {
+			    return ((String)o).toLowerCase();
+			} };
+		else if (v.equals("toUpperCase")) return new JS.Function() {
+			public Object _call(JS.Array args) {
+			    return ((String)o).toString().toUpperCase();
+			} };
+		else if (v.equals("charAt")) return new JS.Function() {
+			public Object _call(JS.Array args) {
+			    return ((String)o).charAt(toNumber(args.elementAt(0)).intValue()) + "";
+			} };
+		else if (v.equals("lastIndexOf")) return new JS.Function() {
+			public Object _call(JS.Array args) {
+			    if (args.length() != 1) return null;
+			    return new Integer(((String)o).lastIndexOf(args.elementAt(0).toString()));
+			} };
+		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 Error("Not Implemented: propery " + v + " on String objects");
+	    } else if (o instanceof Boolean) {
+		throw new Error("Not Implemented: properties on Boolean objects");
+	    } else if (o instanceof Number) {
+		Log.log(this, "Not Implemented: properties on Number objects");
+		return null;
+		//throw new Error("Not Implemented: properties on Number objects");
+	    } else if (o instanceof JS) {
+		return ((JS)o).get(v);
+	    }
+	    return null;
+	}
+    }
+
+    class Thread {
+	public Object[] os = new Object[256];
+	int size = 0;
+	public void push(Object o) { os[size++] = o; }
+	public Object pop() { return os[--size]; }
+	public Object peek() { return os[size - 1]; }
+	public void swap() { Object temp = os[size - 1]; os[size - 1] = os[size - 2]; os[size - 2] = temp; }
+	public int size() { return size; }
+    }
+
+    class ExprList extends Expr {
+	Vec v = new Vec();
+	public ExprList(int curLine, int code) { super(curLine, code); }
+	public void add(Expr e) { v.addElement(e); }
+	public int numExprs() { return v.size(); }
+	public int size() { return v.size(); }
+	public Expr elementAt(int i) { return (Expr)v.elementAt(i); }
+	public Object eval(final JS.Scope s) throws ControlTransferException, JS.Exn {
+	    switch(code) {
+	    case LC: {
+		// Block
+		JS.Scope scope = new JS.Scope(s);
+		for(int i=0; i<v.size(); i++) ((Expr)v.elementAt(i)).eval(scope);
+		return null;
+	    }
+	    case Lexer.LB: {
+		// Array ctor
+		JS.Array ret = new JS.Array();
+		for(int i=0; i<numExprs(); i++) ret.addElement(elementAt(i).eval(s));
+		return ret;
+	    }
+	    case Lexer.RC: {
+		// Object ctor
+		JS.Obj ret = new JS.Obj();
+		for(int i=0; i<numExprs(); i++) {
+		    Expr e = elementAt(i);
+		    Object key = e.left.string;
+		    Object val = e.right.eval(s);
+		    ret.put(key, val);
+		}
+		return ret;
+	    }
+	    case Lexer.WHILE:
+	    case Lexer.DO:
+		try {
+		    boolean first = true;
+		    Object bogus = null;
+		    ExprList list = this;
+		    Expr whileExpr = list.elementAt(0);
+		    Expr bodyExpr = list.elementAt(1);
+		    Expr incExpr = list.elementAt(2);
+		    for(;(first && code == Lexer.DO) || toBoolean(whileExpr.eval(s)); bogus = incExpr.eval(s)) {
+			first = false;
+			try {
+			    bodyExpr.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;
+	    case Lexer.VAR:
+		for(int i=0; i<size(); i++) {
+		    Expr e = elementAt(i);
+		    s.declare(e.left.string);
+		    if (e.right != null) e.right.eval(s);
+		}
+		return null;
+	    default: throw new Error("augh!");
+	    }
+	}
+    }
+    
+    /** 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 { return parseBlock(requireBraces, null); }
+    public Expr parseBlock(boolean requireBraces, ByteCode b) throws IOException {
+	Expr smt = null;
+	int tok = peekToken();
+	if (tok == -1) return null;
+	boolean braced = tok == LC;
+	if (requireBraces && !braced) throw new ParserException("expected {, got " + codeToString[tok]);
+	if (braced) consume(LC);
+	int curLine = line;
+	ByteCode ret = new ByteCode(curLine);
+	ByteCode block = b == null ? new ByteCode(curLine) : b;
+	block.add(ret.LITERAL, Boolean.TRUE);
+	ret.add(block.SCOPE, block);
+	while(true) {
+	    switch(tok = peekToken()) {
+
+	    case LC:
+		smt = parseBlock(true); break;
+
+	    case THROW: case RETURN: case ASSERT:
+		getToken();
+		if (peekToken() == SEMI) {
+		    if (tok == THROW || tok == ASSERT) throw new ParserException(codeToString[tok] + " requires an argument");
+		    consume(SEMI);
+		    smt = new Expr(curLine, tok);
+		} else {
+		    smt = new Expr(curLine, tok, parseMaximalExpr());
+		    consume(SEMI);
+		}
+		break;
+
+	    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 (tok == GOTO) {
+		    throw new ParserException("goto must be followed by a label");
+		}
+		smt = new Expr(curLine, tok, new Expr(curLine, string));
+		consume(SEMI);
+		break;
+	    }
+		
+	    case RC:
+		if (braced) consume(RC);
+		return block.size() == 0 ? null : ret;
+		
+	    case SEMI:
+		consume(SEMI);
+		if (!braced) return block.size() == 0 ? null : ret;
+		continue;
+		
+	    case NAME: {
+		String name = string;
+		consume(NAME);
+		if (peekToken() == COLON) {
+		    consume(COLON);
+		    smt = new Expr(curLine, COLON, new Expr(curLine, name), parseBlock(false));
+		    break;
+		} else {
+		    pushBackToken(NAME, name);
+		    // fall through to default case
+		}
+	    }
+
+	    case -1:
+	    default:
+		smt = parseMaximalExpr();
+		if (smt == null) return block.size() == 0 ? null : ret;
+		if (peekToken() == SEMI) getToken();
+		break;
+	    }
+
+	    if (!braced) return smt;
+	    block.add(block.EXPR, smt);
+	    block.add(block.POP, NO_ARG);
+	}
+    }
+    
+
+    /** sorta like gcc trees */
+    class Expr {
+	int code = -1;
+    
+	final Expr left;
+	final Expr right;
+	int line = -1;
+	String sourceName = "unknown";
+    
+	String string = null;
+	Number number = null;
+    
+	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);
+	    return ret;
+	}
+    
+	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.NULL: return null;
+	    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.THROW: throw new JS.Exn(left.eval(s));
+
+	    case Lexer.TRY: {
+		boolean safeToExit = false;
+		try {
+		    Object ret = left.eval(s);
+		    safeToExit = true;
+		    return ret;
+		} catch (JS.Exn e) {
+		    ExprList list = (ExprList)right;
+		    Expr c = list.elementAt(0);
+		    if (c.code == Lexer.CATCH) {
+			JS.Scope scope = new JS.Scope(s);
+			s.put(c.left.string, e);
+			c.right.eval(scope);
+			c = list.elementAt(1);
+		    }
+		    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.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.declare(left.string);
+		    scope.put(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 {
+		    ExprList list = (ExprList)right;
+		    for(int i=0; i<list.size(); i++) {
+			Expr e = list.elementAt(i);
+			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.BREAK: throw new BreakException(string);
+	    case Lexer.CONTINUE: throw new ContinueException(string);
+	    case Lexer.RETURN: throw new ReturnException(left == null ? null : left.eval(s));
+
+	    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); }
+	}
+    }
+
+	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); }
+    }
+
+	public static Number toNumber(Object o) {
+	    if (o == null) return new Long(0);
+	    if (o instanceof Number) return ((Number)o);
+	    if (o instanceof String) try { return new Double((String)o); } catch (NumberFormatException e) { return new Double(0); }
+	    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());
+	}
+ }