X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2Fjs%2FParser.java;h=fa36d6a5accfdbaf7140a613fe1881055bcf5fd7;hb=c3a9a6282c52e242c06d8e47660ab7aea09bdca4;hp=9af090f8e5c791be53d71155eaee094e04504391;hpb=3b4175d23bee1a58fb66f70aa46df94cf9c166de;p=org.ibex.core.git

diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java
index 9af090f..fa36d6a 100644
--- a/src/org/xwt/js/Parser.java
+++ b/src/org/xwt/js/Parser.java
@@ -1,30 +1,22 @@
-// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
+// Copyright 2003 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 CompiledFunction's */
+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;
-	}
+	CompiledFunction block = new CompiledFunction("stdin", 0, new InputStreamReader(System.in), null);
+	if (block == null) return;
+	System.out.println(block);
     }
 
 
@@ -33,8 +25,9 @@ public class Parser extends Lexer {
     static byte[] precedence = new byte[MAX_TOKEN + 1];
     static boolean[] isRightAssociative = new boolean[MAX_TOKEN + 1];
     static {
-	precedence[ASSIGN] = 1;
 	isRightAssociative[ASSIGN] = true;
+
+	precedence[ASSIGN] = 1;
 	precedence[HOOK] = 2;
 	precedence[COMMA] = 3;
 	precedence[OR] = precedence[AND] = 4;
@@ -48,7 +41,7 @@ public class Parser extends Lexer {
 	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[BITNOT] =  15;
 	precedence[INC] = precedence[DEC] = 16;
 	precedence[LP] = 17;
 	precedence[LB] = 18;
@@ -58,353 +51,142 @@ public class Parser extends Lexer {
 
     // Parsing Logic /////////////////////////////////////////////////////////
 
+    /** gets a token and throws an exception if it is not <tt>code</tt> */
     public void consume(int code) throws IOException {
 	if (getToken() != code)
-	    throw new ParserException("expected " + codeToString[op] + ", got " + (op == -1 ? "EOL" : codeToString[op]));
-    }
-
-    /** 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;
+	    throw new ParserException("expected " + codeToString[code] + ", got " + (op == -1 ? "EOF" : codeToString[op]));
     }
 
-    public Expr parseSingleExpr(Expr prefix, int minPrecedence) throws IOException {
-	Expr e1 = null, e2 = null, e3 = null, head = null, tail = null, ret = null;
+    /** append the largest possible expression containing no operators of precedence below <tt>minPrecedence</tt> */
+    public void startExpr(int minPrecedence, CompiledFunction appendTo) throws IOException {
+	int tok = getToken();
+	CompiledFunction b = appendTo;
 
-	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 VAR: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    ByteCode b = new ByteCode(curLine);
-	    b.add(b.THIS, NO_ARG);
+	case -1: return;
+	case NUMBER: continueExpr(b.add(line, CompiledFunction.LITERAL, number), minPrecedence); return;
+	case STRING: continueExpr(b.add(line, CompiledFunction.LITERAL, string), minPrecedence); return;
+	case THIS: continueExpr(b.add(line, TOPSCOPE, null), minPrecedence); return;
+	case NULL: continueExpr(b.add(line, CompiledFunction.LITERAL, null), minPrecedence); return;
+	case TRUE: case FALSE: continueExpr(b.add(line, CompiledFunction.LITERAL, new Boolean(tok == TRUE)), minPrecedence); return;
+	case LB: {
+	    b.add(line, ARRAY, new Integer(0));
+	    int i = 0;
 	    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;
+		int size = b.size();
+		startExpr(-1, b);
+		if (size == b.size())
+		    if (peekToken() == RB) { consume(RB); continueExpr(b, minPrecedence); return; }
+		b.add(line, LITERAL, new Integer(i++));
+		if (size == b.size()) b.add(line, LITERAL, null);
+		b.add(line, PUT);
+		b.add(line, POP);
+		if (peekToken() == RB) { consume(RB); continueExpr(b, minPrecedence); return; }
 		consume(COMMA);
 	    }
-	    return b;
 	}
-
-	case IN: pushBackToken(); return prefix;
-
-	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 SUB: {
+	    consume(NUMBER);
+	    b.add(line, CompiledFunction.LITERAL, new Double(number.doubleValue() * -1));
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-
-	    // 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
-		ByteCode b = (ByteCode)parseMaximalExpr(null, precedence[tok]);
-		b.set(b.size() - 1, tok, new Boolean(true));
-		return b;
-	    } else {
-		// postfix
-		ByteCode b = (ByteCode)prefix;
-		b.set(b.size() - 1, tok, new Boolean(false));
-		return b;
-	    }
-
-	case LP:
-	    if (prefix == null) {  // grouping
-		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) {
-		    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 LP: {
+	    startExpr(-1, b);
+	    consume(RP);
+	    continueExpr(b, minPrecedence);
+	    return;
+	}
+	case INC: case DEC: {
+	    // prefix
+	    startExpr(precedence[tok], b);
+	    b.set(b.size() - 1, tok, new Boolean(true));
+	    continueExpr(b, minPrecedence);
+	    return;
+	}
+	case BANG: case BITNOT: case TYPEOF: {
+	    startExpr(precedence[tok], b);
+	    b.add(line, tok);
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-
-	case SUB:
-	    if (prefix == null && peekToken() == NUMBER) {
+	case LC: {
+	    b.add(line, OBJECT, null);
+	    if (peekToken() != RC) while(true) {
+		if (peekToken() != NAME && peekToken() != STRING) throw new Error("expected NAME or STRING");
 		getToken();
-		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;
+		b.add(line, LITERAL, string);
+		consume(COLON);
+		startExpr(-1, b);
+		b.add(line, PUT);
+		b.add(line, POP);
+		if (peekToken() == RC) break;
+		consume(COMMA);
+		if (peekToken() == RC) break;
+	    }
+	    consume(RC);
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-
-	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 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 {
-		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) {
-		    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);
-		}
+		b.add(line, TOPSCOPE);
+		b.add(line, CompiledFunction.LITERAL, name);
+		startExpr(minPrecedence, b);
+		b.add(line, CompiledFunction.PUT);
+		b.add(line, CompiledFunction.SWAP);
+		b.add(line, CompiledFunction.POP);
 	    } 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;
+		b.add(line, TOPSCOPE);
+		b.add(line, CompiledFunction.LITERAL, name);
+		b.add(line, CompiledFunction.GET);
 	    }
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-
-	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 (peekToken() != NAME && peekToken() != STRING) throw new Error("expected NAME or STRING");
-		getToken();
-		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: {
-	    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) { 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);
+	    CompiledFunction b2 = new CompiledFunction(sourceName, line, null);
+	    b2.add(line, TOPSCOPE);
+	    b2.add(line, SWAP);
+	    b2.add(line, LITERAL, "arguments");
+	    b2.add(line, LITERAL, "arguments");
+	    b2.add(line, DECLARE);
+	    b2.add(line, SWAP);
+	    b2.add(line, PUT);
+	    b2.add(line, SWAP);
+	    b2.add(line, POP);
 	    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);
+		    b2.add(line, LITERAL, string);
+		    b2.add(line, DECLARE);
 
 		    // 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);
+		    b2.add(line, LITERAL, new Integer(numArgs));
+		    b2.add(line, GET_PRESERVE);
+		    b2.add(line, SWAP);
+		    b2.add(line, POP);
 
 		    // 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);
+		    b2.add(line, TOPSCOPE);
+		    b2.add(line, SWAP);
+		    b2.add(line, LITERAL, string);
+		    b2.add(line, SWAP);
+		    b2.add(line, PUT);
 
 		    // clean the stack
-		    b.add(b.POP, NO_ARG);
-		    b.add(b.POP, NO_ARG);
+		    b2.add(line, POP);
+		    b2.add(line, POP);
 
 		    if (peekToken() == RP) { consume(RP); break; }
 		    consume(COMMA);
@@ -412,788 +194,449 @@ public class Parser extends Lexer {
 		numArgs++;
 	    }
 	    // pop off the arguments array
-	    b.add(b.POP, NO_ARG);
-	    parseBlock(true, b);
-	    return new ByteCode(curLine, b.FUNCTION, b);
-	}
-	    
-	case WHILE: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    consume(LP);
-	    ByteCode r = new ByteCode(curLine);
-	    ByteCode loop = new ByteCode(curLine);
-	    r.add(loop.LOOP, loop);
-	    r.add(r.LITERAL, null);
-
-	    loop.add(loop.EXPR, parseMaximalExpr());
-	    loop.add(loop.JT, new Integer(2));
-	    loop.add(Lexer.BREAK, NO_ARG);
-	    consume(RP);
-	    parseBlock(false, loop);
-
-	    // if we fall out of the end, definately continue
-	    loop.add(CONTINUE, NO_ARG);
-	    return r;
+	    b2.add(line, POP);
+	    parseStatement(true, b2);
+	    b2.add(line, LITERAL, null);
+	    b2.add(line, RETURN);
+	    continueExpr(b.add(line, NEWFUNCTION, b2), minPrecedence);
+	    return;
 	}
-
-	case SWITCH: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    consume(LP);
-	    ByteCode r = new ByteCode(curLine);
-	    ByteCode loop = new ByteCode(curLine);
-	    r.add(loop.LOOP, loop);
-	    r.add(r.LITERAL, null);
-	    loop.add(loop.EXPR, parseMaximalExpr());
-	    consume(RP);
-	    consume(LC);
-	    while(true) {
-		Expr caseExpr;
-		tok = getToken();
-		if (tok == CASE) {
-		    loop.add(loop.DUP, NO_ARG);
-		    loop.add(loop.EXPR, parseMaximalExpr());
-		    loop.add(EQ, NO_ARG);
-		    loop.add(loop.JF, new Integer(2));
-		} else if (tok != DEFAULT) throw new ParserException("expected CASE or DEFAULT");
-		consume(COLON);
-		ByteCode b = new ByteCode(curLine);
-		while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) {
-		    if ((e1 = parseBlock(false)) == null) break;
-		    b.add(b.EXPR, e1);
-		}
-		loop.add(loop.EXPR, b);
-		if (peekToken() == RC) {
-		    consume(RC);
-		    r.add(BREAK, NO_ARG);
-		    return r;
-		}
-	    }
+	default: pushBackToken(); return;
 	}
-	    
-	case DO: {
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    ByteCode r = new ByteCode(curLine);
-	    ByteCode loop = new ByteCode(curLine);
-	    r.add(loop.LOOP, loop);
-	    r.add(r.LITERAL, null);
+    }
 
-	    parseBlock(false, loop);
-	    consume(WHILE);
-	    consume(LP);
-	    loop.add(loop.EXPR, parseMaximalExpr());
-	    loop.add(loop.JT, new Integer(2));
-	    loop.add(Lexer.BREAK, NO_ARG);
-	    loop.add(Lexer.CONTINUE, NO_ARG);
-	    consume(RP);
-	    consume(SEMI);
-	    return r;
-	}
+    public void continueExpr(CompiledFunction prefix, int minPrecedence) throws IOException {
+	int tok = getToken();
+	if (tok == -1) return;
+	if (minPrecedence > 0 && precedence[tok] != 0)
+	    if (precedence[tok] < minPrecedence || (precedence[tok] == minPrecedence && !isRightAssociative[tok]))
+		{ pushBackToken(); return; }
+	if (prefix == null) throw new Error("got null prefix");
+	CompiledFunction b = prefix;
 
-	    // Needs break //
+	switch (tok) {
 
-	case FOR:
-	    if (prefix != null) { pushBackToken(); return prefix; }
-	    if (getToken() != LP) throw new ParserException("expected left paren");
-	    e1 = parseMaximalExpr();
-	    if (peekToken() == IN) {
-		getToken();
-		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 {
-		Expr initExpr = e1;
-		if (initExpr == null) initExpr = new Expr(curLine, NULL);
-		consume(SEMI);
-		Expr whileExpr = parseMaximalExpr();
-		consume(SEMI);
-		Expr incExpr = parseMaximalExpr();
-		consume(RP);
-		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 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();
-	    ExprList list = new ExprList(curLine, TRY);
-	    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 )");
-		list.add(new Expr(curLine, CATCH, name, parseBlock(false)));
-		tok = peekToken();
-	    }
-	    if (tok == FINALLY) {
-		getToken();
-		list.add(new Expr(curLine, FINALLY, parseBlock(false)));
+        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: {
+	    prefix.set(prefix.size() - 1, b.GET_PRESERVE, new Boolean(true));
+	    startExpr(precedence[tok - 1], b);
+	    prefix.add(line, tok - 1);
+	    prefix.add(line, PUT);
+	    prefix.add(line, SWAP);
+	    prefix.add(line, POP);
+	    continueExpr(b, minPrecedence);
+	    return;
+	}
+
+	case INC: case DEC: {
+	    // postfix
+	    b.set(b.size() - 1, tok, new Boolean(false));
+	    continueExpr(b, minPrecedence);
+	    return;
+	}
+
+	case LP: {
+	    // invocation
+	    int i = 0;
+	    while(peekToken() != RP) {
+		i++;
+		startExpr(-1, b);
+		if (peekToken() == RP) break;
+		consume(COMMA);
 	    }
-
-	    if (list.size() == 0) throw new ParserException("try without catch or finally");
-	    return new Expr(curLine, TRY, tryBlock, list);
+	    consume(RP);
+	    b.add(line, CALL, new Integer(i));
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
 
-	default:
-	    pushBackToken();
-	    return prefix;
+        case BITOR: case BITXOR: case BITAND: case SHEQ: case SHNE: case LSH:
+	case RSH: case URSH: case ADD: case MUL: case DIV: case MOD:
+	case GT: case GE: case EQ: case NE: case LT: case LE: case SUB: {
+	    startExpr(precedence[tok], b);
+	    b.add(line, tok);
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-    }
-    
-    // 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
-	public static final byte LOOP = -40;       //                               -- transitional
-	public static final byte DUP = -50;       //                               -- 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());
+	case OR: case AND: {
+	    b.add(line, tok == AND ? b.JF : b.JT, new Integer(0));
+	    int size = b.size();
+	    startExpr(precedence[tok], b);
+	    b.set(size - 1, new Integer(b.size() - size + 2));
+	    b.add(line, JMP, new Integer(2));
+	    b.add(line, LITERAL, tok == AND ? new Boolean(false) : new Boolean(true));
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-	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 DUP: t.push(t.peek()); break;
-		    
-		case Lexer.BREAK: {
-		    // FIXME: make sure this can only appear in proper places
-		    return Boolean.FALSE;
-		}
-		case Lexer.CONTINUE: {
-		    // FIXME: make sure this can only appear in proper places
-		    return Boolean.TRUE;
-		}
-		case LOOP: {
-		    ByteCode loop = (ByteCode)arg[i];
-		    Parser.Thread t2 = new Parser.Thread();
-		    t2.push(Boolean.TRUE);
-		    while (true) {
-			Boolean result;
-			try {
-			    result = (Boolean)loop.eval(new JS.Scope(s), t2);
-			} catch (ContinueException c) {
-			    result = Boolean.TRUE;
-			} catch (BreakException b) {
-			    result = Boolean.FALSE;
-			}
-			if (result == Boolean.FALSE) break;
-			t2 = new Parser.Thread();
-			t2.push(Boolean.FALSE);
-		    }
-		    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");
+	case DOT: {
+	    consume(NAME);
+	    String target = string;
+	    if (peekToken() == ASSIGN) {
+		consume(ASSIGN);
+		b.add(line, LITERAL, target);
+		startExpr(-1, b);
+		b.add(line, PUT);
+		b.add(line, SWAP);
+		b.add(line, POP);
+	    } else {
+		b.add(line, LITERAL, target);
+		b.add(line, GET);
 	    }
-	    return t.pop();
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
 
-	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);
+	case LB: {
+	    startExpr(-1, b);
+	    consume(RB);
+	    if (peekToken() == ASSIGN) {
+		consume(ASSIGN);
+		startExpr(-1, b);
+		b.add(line, PUT);
+		b.add(line, SWAP);
+		b.add(line, POP);
+	    } else {
+		b.add(line, GET);
 	    }
-	    return null;
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-    }
 
-    class Thread {
-	public Object[] os = new Object[256];
-	private int size = 0;
-	public void push(Object o) {
-	    os[size++] = o;
-	}
-	public Object pop() {
-	    return os[--size];
+	case HOOK: {
+	    b.add(line, JF, new Integer(0));
+	    int size = b.size();
+	    startExpr(-1, b);
+	    b.set(size - 1, new Integer(b.size() - size + 2));
+	    b.add(line, JMP, new Integer(0));
+	    consume(COLON);
+	    size = b.size();
+	    startExpr(-1, b);
+	    b.set(size - 1, new Integer(b.size() - size + 1));
+	    continueExpr(b, minPrecedence);
+	    return;
 	}
-	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!");
-	    }
+	    
+	default: { pushBackToken(); return; }
 	}
     }
     
-    /** 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;
+    /**
+     *  a block is either a single statement or a list of statements surrounded by curly braces;
+     *  all expressions are also statements
+     */
+    public CompiledFunction parseStatement() throws IOException {
+	CompiledFunction ret = new CompiledFunction(sourceName, line, null);
+	ret.add(line, ret.LITERAL, null);
+	parseStatement(false, ret);
+	if (ret.size() == 1) return null;
+	return ret;
+    }
+
+    public void parseStatement(boolean r, CompiledFunction b) throws IOException { parseStatement(r, b, null); }
+    public void parseStatement(boolean requireBraces, CompiledFunction b, String label) throws IOException {
 	int tok = peekToken();
-	if (tok == -1) return null;
+	if (tok == -1) return;
+	int line = this.line;
 	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:
+	    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);
-		}
+		if (tok == RETURN && peekToken() == SEMI) b.add(line, LITERAL, null);
+		else startExpr(-1, b);
+		consume(SEMI);
+		b.add(line, tok);
 		break;
+	    }
 
-	    case GOTO: case BREAK: case CONTINUE: {
+	    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));
+		if (peekToken() == NAME) consume(NAME);
+		b.add(line, tok, string);
 		consume(SEMI);
 		break;
 	    }
 		
-	    case RC:
-		if (braced) consume(RC);
-		return block.size() == 0 ? null : ret;
-		
-	    case SEMI:
+	    case SEMI: {
 		consume(SEMI);
-		if (!braced) return block.size() == 0 ? null : ret;
-		continue;
+		if (!braced) return;
+		break;
+	    }
 		
-	    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 VAR: {
+		consume(VAR);
+		b.add(line, TOPSCOPE);                               // push the current scope
+		while(true) {
+		    consume(NAME);
+		    String name = string;
+		    b.add(line, LITERAL, name);                // push the name to be declared
+		    b.add(line, DECLARE);                      // declare it
+		    if (peekToken() == ASSIGN) {           // if there is an '=' after the variable name
+			b.add(line, LITERAL, name);            // put the var name back on the stack
+			consume(ASSIGN);
+			startExpr(-1, b);
+			b.add(line, PUT);
+			b.add(line, POP);
+		    }
+		    if (peekToken() != COMMA) break;
+		    consume(COMMA);
 		}
+		b.add(line, POP);
+		if (peekToken() == SEMI) consume(SEMI);
+		break;
 	    }
+		
+	    case IF: {
+		consume(IF);
+		consume(LP);
+		startExpr(-1, b);
+		consume(RP);
 
-	    case -1:
-	    default:
-		smt = parseMaximalExpr();
-		if (smt == null) return block.size() == 0 ? null : ret;
-		if (peekToken() == SEMI) getToken();
+		b.add(line, JF, new Integer(0));
+		int size = b.size();
+		parseStatement(false, b);
+		
+		if (peekToken() == ELSE) {
+		    consume(ELSE);
+		    b.set(size - 1, new Integer(2 + b.size() - size));
+		    b.add(line, JMP, new Integer(0));
+		    size = b.size();
+		    parseStatement(false, b);
+		}
+		b.set(size - 1, new Integer(1 + b.size() - size));
 		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 WHILE: {
+		consume(WHILE);
+		consume(LP);
+		if (label != null) b.add(line, LABEL, label);
+		b.add(line, LOOP);
+		int size = b.size();
+		b.add(line, POP);
+		startExpr(-1, b);
+		b.add(line, JT, new Integer(2));
+		b.add(line, BREAK);
+		consume(RP);
+		parseStatement(false, b);
+		b.add(line, CONTINUE);                                    // if we fall out of the end, definately continue
+		b.set(size - 1, new Integer(b.size() - size + 1));  // end of the loop
+		break;
+	    }
 
-	    case 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 SWITCH: {
+		consume(SWITCH);
+		consume(LP);
+		if (label != null) b.add(line, LABEL, label);
+		b.add(line, LOOP);
+		int size0 = b.size();
+		startExpr(-1, b);
+		consume(RP);
+		consume(LC);
+		while(true)
+		    if (peekToken() == CASE) {
+			consume(CASE);
+			b.add(line, DUP);
+			startExpr(-1, b);
+			consume(COLON);
+			b.add(line, EQ);
+			b.add(line, JF, new Integer(0));
+			int size = b.size();
+			while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) {
+			    int size2 = b.size();
+			    parseStatement(false, b);
+			    if (size2 == b.size()) break;
+			}
+			b.set(size - 1, new Integer(1 + b.size() - size));
+		    } else if (peekToken() == DEFAULT) {
+			consume(DEFAULT);
+			consume(COLON);
+			while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) {
+			    int size2 = b.size();
+			    parseStatement(false, b);
+			    if (size2 == b.size()) break;
+			}
+		    } else if (peekToken() == RC) {
+			consume(RC);
+			b.add(line, BREAK);
+			break;
+		    } else {
+			throw new ParserException("expected CASE, DEFAULT, or RC; got " + codeToString[peekToken()]);
+		    }
+		b.add(line, BREAK);
+		b.set(size0 - 1, new Integer(b.size() - size0 + 1));      // end of the loop
+		break;
+	    }
+		
+	    case DO: {
+		consume(DO);
+		if (label != null) b.add(line, LABEL, label);
+		b.add(line, LOOP);
+		int size = b.size();
+		parseStatement(false, b);
+		consume(WHILE);
+		consume(LP);
+		startExpr(-1, b);
+		b.add(line, JT, new Integer(2));
+		b.add(line, BREAK);
+		b.add(line, CONTINUE);
+		consume(RP);
+		consume(SEMI);
+		b.set(size - 1, new Integer(b.size() - size + 1));      // end of the loop
+		break;
 	    }
+		
+	    case TRY: {
+		// We deliberately allow you to omit braces in catch{}/finally{} if they are single statements...
+		consume(TRY);
+		b.add(line, TRY);
+		int size = b.size();
+		parseStatement(true, b);
+		b.add(line, POP);                                 // pop the TryMarker
+		b.add(line, JMP);                                 // jump forward to the end of the catch block
+		int size2 = b.size();
+		b.set(size - 1, new Integer(b.size() - size + 1));// the TRY argument points at the start of the CATCH block
+		
+		if (peekToken() == CATCH) {
+		    getToken();
+		    consume(LP);
+		    consume(NAME);
+		    consume(RP);
+		    // FIXME, we need an extra scope here
+		    b.add(line, TOPSCOPE);                        // the exception is on top of the stack; put it to the variable
+		    b.add(line, SWAP);
+		    b.add(line, LITERAL);
+		    b.add(line, SWAP);
+		    b.add(line, PUT);
+		    b.add(line, POP);
+		    b.add(line, POP);
+		    parseStatement(false, b);
+		}
 
-	    case Lexer.THROW: throw new JS.Exn(left.eval(s));
+		b.set(size2 - 1, new Integer(b.size() - size2 + 1)); // jump here if no exception was thrown
 
-	    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");
+		      // FIXME: not implemented correctly
+		if (peekToken() == FINALLY) {
+		    consume(FINALLY);
+		    parseStatement(false, b);
 		}
-		return null;
+		break;
 	    }
 
-	    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();
-		    }
+	    case FOR: {
+		consume(FOR);
+		consume(LP);
+		
+		tok = getToken();
+		boolean hadVar = false;
+		if (tok == VAR) { hadVar = true; tok = getToken(); }
+		String varName = string;
+		boolean forIn = peekToken() == IN;
+		pushBackToken(tok, varName);
+		
+		if (forIn) {
+		    // FIXME: break needs to work in here
+		    consume(NAME);
+		    consume(IN);
+		    startExpr(-1, b);
+		    b.add(line, PUSHKEYS);
+		    b.add(line, LITERAL, "length");
+		    b.add(line, GET);
+		    consume(RP);
+		    CompiledFunction b2 = new CompiledFunction(sourceName, line, null);
+		    
+		    b.add(line, NEWSCOPE);
+		    
+		    b.add(line, LITERAL, new Integer(1));
+		    b.add(line, SUB);
+		    b.add(line, DUP);
+		    b.add(line, LITERAL, new Integer(0));
+		    b.add(line, LT);
+		    b.add(line, JT, new Integer(7));
+		    b.add(line, GET_PRESERVE);
+		    b.add(line, LITERAL, varName);
+		    b.add(line, LITERAL, varName);
+		    b.add(line, DECLARE);
+		    b.add(line, PUT);
+		    parseStatement(false, b);
+		    
+		    b.add(line, OLDSCOPE);
+		    
+		    break;
+		    
+		} else {
+		    if (hadVar) pushBackToken(VAR, null);
+		    b.add(line, NEWSCOPE);
+		    
+		    parseStatement(false, b);
+		    CompiledFunction e2 = new CompiledFunction(sourceName, line, null);
+		    startExpr(-1, e2);
+		    consume(SEMI);
+		    if (e2 == null) e2 = new CompiledFunction(sourceName, line, null).add(line, b.LITERAL, Boolean.TRUE);
+		    
+		    if (label != null) b.add(line, LABEL, label);
+		    b.add(line, LOOP);
+		    int size2 = b.size();
+		    
+		    b.add(line, JT, new Integer(0));
+		    int size = b.size();
+		    startExpr(-1, b);
+		    if (b.size() > size) b.add(line, POP);
+		    b.set(size - 1, new Integer(b.size() - size + 1));
+		    consume(RP);
+		    
+		    b.paste(e2);
+		    b.add(line, JT, new Integer(2));
+		    b.add(line, BREAK);
+		    parseStatement(false, b);
+		    b.add(line, CONTINUE);
+		    b.set(size2 - 1, new Integer(b.size() - size2 + 1));      // end of the loop
+		    
+		    b.add(line, OLDSCOPE);
+		    break;
 		}
-		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();
+	    }
+		
+	    case NAME: {
+		consume(NAME);
+		String possiblyTheLabel = string;
+		if (peekToken() == COLON) {
+		    consume(COLON);
+		    label = possiblyTheLabel;
+		    System.out.println("label == " + label);
+		    parseStatement(false, b, label);
+		    break;
+		} else {
+		    pushBackToken(NAME, possiblyTheLabel);
+		    // fall through to default case
 		}
-		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); }
+            // fall through
+	    case RC:
+		if (tok == RC && braced) { consume(RC); return; }
+            // fall through
+	    default: {
+		int size = b.size();
+		startExpr(-1, b);
+		if (size == b.size()) return;
+		b.add(line, POP);
+		if (peekToken() == SEMI) consume(SEMI);
+		break;
+	    }
+	    }
+	    
+	    if (!braced) return;
 	}
     }
-
-	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 {
+    
+    private 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());
-	}
- }
+    
+}