From fc3d3e7efa26add1306f565f8c739f9e0a64588c Mon Sep 17 00:00:00 2001 From: megacz Date: Fri, 30 Jan 2004 07:00:38 +0000 Subject: [PATCH] 2003/06/03 08:56:56 darcs-hash:20040130070038-2ba56-9fcb3bcc9b766ce659e77bfaa9bd2284547c4a28.gz --- src/org/xwt/js/JS.java | 5 +- src/org/xwt/js/Lexer.java | 6 +- src/org/xwt/js/Parser.java | 839 ++++++++++++++++++++++++++++---------------- 3 files changed, 543 insertions(+), 307 deletions(-) diff --git a/src/org/xwt/js/JS.java b/src/org/xwt/js/JS.java index f2946ea..0628891 100644 --- a/src/org/xwt/js/JS.java +++ b/src/org/xwt/js/JS.java @@ -61,6 +61,8 @@ public abstract class JS { public static class Array extends Obj { private Vec vec = new Vec(); + public Array() { } + public Array(int size) { vec.setSize(size); } private static int intVal(Object o) { if (o instanceof Number) { int intVal = ((Number)o).intValue(); @@ -102,6 +104,7 @@ public abstract class JS { ret[vec.size()] = "length"; return ret; } + public void setSize(int i) { vec.setSize(i); } public int length() { return vec.size(); } public Object elementAt(int i) { return vec.elementAt(i); } public void addElement(Object o) { vec.addElement(o); } @@ -142,7 +145,7 @@ public abstract class JS { Vector exprs = new Vector(); while(true) { Parser.Expr ret = p.parseBlock(false); - if (ret == null || (ret.code == Parser.LC && ret.left == null)) break; + if (ret == null) break; exprs.addElement(ret); } return new Script(exprs); diff --git a/src/org/xwt/js/Lexer.java b/src/org/xwt/js/Lexer.java index d7a5725..3a80f5a 100644 --- a/src/org/xwt/js/Lexer.java +++ b/src/org/xwt/js/Lexer.java @@ -482,7 +482,7 @@ class Lexer { int[] pushBackInts = new int[10]; Object[] pushBackObjects = new Object[10]; - public void pushBackToken() { + public void pushBackToken(int op, Object obj) { if (pushBackDepth >= pushBackInts.length - 1) { int[] newInts = new int[pushBackInts.length * 2]; System.arraycopy(pushBackInts, 0, newInts, 0, pushBackInts.length); @@ -492,10 +492,12 @@ class Lexer { pushBackObjects = newObjects; } pushBackInts[pushBackDepth] = op; - pushBackObjects[pushBackDepth] = number != null ? (Object)number : (Object)string; + pushBackObjects[pushBackDepth] = obj; pushBackDepth++; } + public void pushBackToken() { pushBackToken(op, number != null ? (Object)number : (Object)string); } + public int peekToken() throws IOException { int ret = getToken(); pushBackToken(); diff --git a/src/org/xwt/js/Parser.java b/src/org/xwt/js/Parser.java index b7456fe..e99eaa7 100644 --- a/src/org/xwt/js/Parser.java +++ b/src/org/xwt/js/Parser.java @@ -62,6 +62,12 @@ public class Parser extends Lexer { 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])); + } public void expect(int code) throws IOException { int got = peekToken(); if (got != code) throw new ParserException("expected " + codeToString[code] + ", got " + (got == -1 ? "EOL" : codeToString[got])); @@ -98,146 +104,221 @@ public class Parser extends Lexer { // these case arms match the precedence of operators; each arm is a precedence level. switch (tok) { - case WITH: throw new ParserException("XWT does not allow the WITH keyword"); - case VOID: case RESERVED: throw new ParserException("reserved word that you shouldn't be using"); - case NAME: if (prefix != null) { pushBackToken(); return prefix; } else return parseMaximalExpr(new Expr(curLine, NAME, string), minPrecedence); - case STRING: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(curLine, string); - case NUMBER: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(curLine, number); - case NULL: case TRUE: case FALSE: case NOP: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(curLine, tok); - case ASSIGN_BITOR: case ASSIGN_BITXOR: case ASSIGN_BITAND: case ASSIGN_LSH: case ASSIGN_RSH: case ASSIGN_URSH: case ASSIGN_ADD: case ASSIGN_SUB: case ASSIGN_MUL: case ASSIGN_DIV: case ASSIGN_MOD: return new Expr(curLine, ASSIGN, prefix, new Expr(curLine, tok - 1, prefix, parseMaximalExpr(null, precedence[ASSIGN]))); - case COMMA: pushBackToken();return prefix; - - case THIS: - if (prefix != null) { pushBackToken(); return prefix; } - return new Expr(curLine, THIS); - - case SUB: - if (prefix == null && peekToken() == NUMBER) { - getToken(); - return new Expr(curLine, new Double(number.doubleValue() * -1)); - } // else fall through - case BITOR: case BITXOR: case BITAND: case SHEQ: case SHNE: case LSH: - case RSH: case URSH: case ADD: case MUL: case DIV: case MOD: - case ASSIGN: case GT: case GE: case OR: case AND: - case EQ: case NE: case LT: case LE: - if (prefix == null) throw new ParserException("the " + codeToString[tok] + " token cannot start an expression"); - return new Expr(curLine, tok, prefix, parseMaximalExpr(null, precedence[tok])); - - case DOT: { - //e1 = parseMaximalExpr(null, precedence[DOT]); - //if (e1.code == NAME) e1.code = STRING; - //else throw new ParserException("argument to DOT must be a NAME; got a " + codeToString[e1.code]); - //return new Expr(curLine, DOT, prefix, e1); - tok = getToken(); - if (tok != NAME) throw new ParserException("DOT must be followed by a NAME"); - return new Expr(curLine, DOT, prefix, new Expr(curLine, STRING, string)); - } - - case BANG: case BITNOT: case INSTANCEOF: case TYPEOF: - if (prefix != null) { pushBackToken(); return prefix; } - return new Expr(curLine, tok, parseMaximalExpr(null, precedence[tok])); + // DONE // + // FIXME: ugly hack!! case INC: case DEC: if (prefix == null) { // prefix - e1 = parseMaximalExpr(null, precedence[tok]); - return new Expr(curLine, ASSIGN, e1, new Expr(curLine, tok == INC ? ADD : SUB, e1, new Expr(curLine, new Integer(1)))); + ByteCode b = (ByteCode)parseMaximalExpr(null, precedence[tok]); + b.set(b.size() - 1, tok, new Boolean(true)); + return b; } else { // postfix - return new Expr(curLine, tok, 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 - ExprList list = new ExprList(curLine, LP); + ByteCode b = new ByteCode(curLine); + int i = 0; + b.add(b.EXPR, prefix); while(peekToken() != RP) { - list.add(parseMaximalExpr()); + 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(curLine, LP, prefix, list); + 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 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: + case LB: { + ByteCode b = new ByteCode(curLine); if (prefix == null) { - // array ctor - ExprList list = new ExprList(curLine, LB); + b.add(b.ARRAY, new Integer(0)); + int i = 0; while(true) { Expr e = parseMaximalExpr(); - if (e != null) { - list.add(e); - } else { - if (peekToken() == COMMA) list.add(new Expr(curLine, NULL)); - } - if (peekToken() == RB) { consume(RB); return list; } + if (e == null && peekToken() == RB) { consume(RB); return b; } + if (e == null) e = new Expr(curLine, NULL); + b.add(b.LITERAL, new Integer(i++)); + 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 { - // subscripting - e1 = parseMaximalExpr(); - if (getToken() != RB) throw new ParserException("expected a right brace"); - return new Expr(curLine, DOT, prefix, e1); + 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: { - // object ctor if (prefix != null) { pushBackToken(); return prefix; } - tok = getToken(); - ExprList list = new ExprList(curLine, RC); - if (tok == RC) return list; + ByteCode b = new ByteCode(curLine); + b.add(b.OBJECT, null); + if (peekToken() == RC) { consume(RC); return b; } while(true) { - if (tok != NAME && tok != STRING) throw new ParserException("expecting name, got " + codeToString[tok]); - Expr name = new Expr(curLine, NAME, string); - if (getToken() != COLON) throw new ParserException("expecting colon"); - e1 = new Expr(curLine, COLON, name, parseMaximalExpr()); - list.add(e1); - tok = getToken(); - if (tok != COMMA && tok != RC) throw new ParserException("expected right curly or comma, got " + codeToString[tok]); - if (tok == RC) return list; - tok = getToken(); - if (tok == RC) return list; + 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 ParserException("expected colon to close ?: expression"); - e3 = parseMaximalExpr(); - return new Expr(curLine, HOOK, prefix, new Expr(curLine, ELSE, e2, e3)); - - case SWITCH: { - if (prefix != null) { pushBackToken(); return prefix; } - if (getToken() != LP) throw new ParserException("expected left paren"); - Expr switchExpr = parseMaximalExpr(); - if (getToken() != RP) throw new ParserException("expected left paren"); - if (getToken() != LC) throw new ParserException("expected left brace"); - ExprList toplevel = new ExprList(curLine, LC); - while(true) { - 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); - } - toplevel.add(new Expr(curLine, tok, caseExpr, list)); - if (peekToken() == RC) { consume(RC); return new Expr(curLine, SWITCH, switchExpr, toplevel); } - } + 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: { @@ -262,32 +343,69 @@ public class Parser extends Lexer { case VAR: { if (prefix != null) { pushBackToken(); return prefix; } - ExprList list = new ExprList(curLine, VAR); + ByteCode b = new ByteCode(curLine); + b.add(b.THIS, NO_ARG); while(true) { - if (getToken() != NAME) throw new ParserException("variable declarations must start with a variable name"); + consume(NAME); String name = string; - Expr initVal = null; - tok = peekToken(); - Expr e = null; - if (tok == ASSIGN) { - getToken(); - initVal = parseMaximalExpr(); - tok = peekToken(); - e = new Expr(curLine, VAR, - new Expr(curLine, name), - new Expr(curLine, ASSIGN, - new Expr(curLine, name), - initVal)); - } else { - e = new Expr(curLine, VAR, new Expr(curLine, name)); + 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); } - list.add(e); - if (tok != COMMA) break; - getToken(); + if (peekToken() != COMMA) break; + consume(COMMA); } - return list; + 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; + } + + // Needs break // + + case SWITCH: { + if (prefix != null) { pushBackToken(); return prefix; } + if (getToken() != LP) throw new ParserException("expected left paren"); + Expr switchExpr = parseMaximalExpr(); + if (getToken() != RP) throw new ParserException("expected left paren"); + if (getToken() != LC) throw new ParserException("expected left brace"); + ExprList toplevel = new ExprList(curLine, LC); + while(true) { + 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); + } + toplevel.add(new Expr(curLine, tok, caseExpr, list)); + if (peekToken() == RC) { consume(RC); return new Expr(curLine, SWITCH, switchExpr, toplevel); } + } + } + case TRY: { // We deliberately allow you to omit braces in catch{}/finally{} if they are single statements... if (prefix != null) { pushBackToken(); return prefix; } @@ -313,30 +431,21 @@ public class Parser extends Lexer { return new Expr(curLine, TRY, tryBlock, list); } - case IF: case WHILE: { + case WHILE: { if (prefix != null) { pushBackToken(); return prefix; } - if (getToken() != LP) throw new ParserException("expected left paren"); + consume(LP); Expr parenExpr = parseMaximalExpr(); int t; - if ((t = getToken()) != RP) throw new ParserException("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(curLine, tok, parenExpr, new Expr(curLine, ELSE, firstBlock, parseBlock(false))); - } else { - if (tok == IF) return new Expr(curLine, tok, parenExpr, firstBlock); - if (tok == WHILE) { - ExprList list = new ExprList(curLine, WHILE); - list.add(parenExpr); - list.add(firstBlock); - list.add(new Expr(curLine, NULL)); - return list; - } - } + ExprList list = new ExprList(curLine, WHILE); + list.add(parenExpr); + list.add(firstBlock); + list.add(new Expr(curLine, NULL)); + return list; } - case IN: pushBackToken(); return prefix; - case FOR: if (prefix != null) { pushBackToken(); return prefix; } if (getToken() != LP) throw new ParserException("expected left paren"); @@ -389,6 +498,260 @@ 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 + 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 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 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 + public static final byte JF = -21; // < relative_address > -- pop the stack; if false, jump to + public static final byte JMP = -22; // < relative_address > -- jump to + 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 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(JS.Scope s, Parser.Thread t) throws ControlTransferException { + for(int i=0; i= 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: 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: properties 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); } @@ -432,7 +795,8 @@ public class Parser extends Lexer { Expr incExpr = list.elementAt(2); for(;(first && code == Lexer.DO) || toBoolean(whileExpr.eval(s)); bogus = incExpr.eval(s)) { first = false; - try { bodyExpr.eval(s); + try { + bodyExpr.eval(s); } catch (ContinueException c) { if (c.label == null || c.label.equals(string)) continue; } catch (BreakException b) { @@ -463,15 +827,15 @@ public class Parser extends Lexer { if (tok == -1) return null; boolean braced = tok == LC; if (requireBraces && !braced) throw new ParserException("expected {, got " + codeToString[tok]); - if (braced) getToken(); + if (braced) consume(LC); int curLine = line; - ExprList block = new ExprList(curLine, LC); + ByteCode ret = new ByteCode(curLine); + ByteCode block = new ByteCode(curLine); + block.add(ret.LITERAL, Boolean.TRUE); + ret.add(block.SCOPE, block); while(true) { switch(tok = peekToken()) { - case -1: - return block; - case LC: smt = parseBlock(true); break; @@ -503,39 +867,37 @@ public class Parser extends Lexer { case RC: if (braced) consume(RC); - return block; + return block.size() == 0 ? null : ret; case SEMI: consume(SEMI); - if (!braced) return block; + if (!braced) return block.size() == 0 ? null : ret; continue; -/* FIXME: LL(2) case NAME: { String name = string; - getToken(); + consume(NAME); if (peekToken() == COLON) { + consume(COLON); smt = new Expr(curLine, COLON, new Expr(curLine, name), parseBlock(false)); break; } else { - pushBackToken(tok); - string = name; + pushBackToken(NAME, name); // fall through to default case } } -*/ + + case -1: default: smt = parseMaximalExpr(); - if (smt == null) { - if (block.numExprs() == 0) return null; - return block; - } + if (smt == null) return block.size() == 0 ? null : ret; if (peekToken() == SEMI) getToken(); break; } if (!braced) return smt; - block.add(smt); + block.add(block.EXPR, smt); + block.add(block.POP, NO_ARG); } } @@ -588,73 +950,20 @@ public class Parser extends Lexer { public Object eval(final JS.Scope s) throws ControlTransferException, JS.Exn { switch(code) { - case Lexer.BITOR: return new Long(toLong(left.eval(s)) | toLong(right.eval(s))); - case Lexer.BITXOR: return new Long(toLong(left.eval(s)) ^ toLong(right.eval(s))); - case Lexer.BITAND: return new Long(toLong(left.eval(s)) & toLong(right.eval(s))); - case Lexer.BITNOT: return new Long(~toLong(left.eval(s))); - - case Lexer.ADD: { - Object l = left.eval(s); - Object r = right.eval(s); - if (l instanceof String || r instanceof String) { - if (l == null) l = "null"; - if (r == null) r = "null"; - if (l instanceof Number && ((Number)l).doubleValue() == ((Number)l).longValue()) - l = new Long(((Number)l).longValue()); - if (r instanceof Number && ((Number)r).doubleValue() == ((Number)r).longValue()) - r = new Long(((Number)r).longValue()); - return l.toString() + r.toString(); - } - return new Double(toDouble(l) + toDouble(r)); - } - - case Lexer.SUB: return new Double(toDouble(left.eval(s)) - toDouble(right.eval(s))); - case Lexer.MUL: return new Double(toDouble(left.eval(s)) * toDouble(right.eval(s))); - case Lexer.DIV: return new Double(toDouble(left.eval(s)) / toDouble(right.eval(s))); - case Lexer.MOD: return new Double(toDouble(left.eval(s)) % toDouble(right.eval(s))); - - case Lexer.LSH: return new Long(toLong(left.eval(s)) << toLong(right.eval(s))); - case Lexer.RSH: return new Long(toLong(left.eval(s)) >> toLong(right.eval(s))); - case Lexer.URSH: return new Long(toLong(left.eval(s)) >>> toLong(right.eval(s))); - - // FIXME: these need to work on strings - case Lexer.LT: return toDouble(left.eval(s)) < toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE; - case Lexer.LE: return toDouble(left.eval(s)) <= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE; - case Lexer.GT: return toDouble(left.eval(s)) > toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE; - case Lexer.GE: return toDouble(left.eval(s)) >= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE; - - case Lexer.OR: { - boolean b1 = toBoolean(left.eval(s)); - if (b1) return Boolean.TRUE; - return new Boolean(b1 || toBoolean(right.eval(s))); - } - - case Lexer.AND: { - boolean b1 = toBoolean(left.eval(s)); - if (!b1) return Boolean.FALSE; - return new Boolean(b1 && toBoolean(right.eval(s))); + 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.BANG: return new Boolean(!toBoolean(left.eval(s))); - - case Lexer.EQ: - case Lexer.NE: { - // FIXME: should use Javascript coercion-equality rules - Object l = left.eval(s); - Object r = right.eval(s); - boolean ret; - if (l == null) { Object t = r; r = l; l = t; } - 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); - - return new Boolean(code == Lexer.EQ ? ret : !ret); - } + case Lexer.NUMBER: return number; + case Lexer.STRING: return string; - case Lexer.INC: - case Lexer.DEC: case Lexer.ASSIGN: { Object v = (code == Lexer.ASSIGN) ? right.eval(s) : new Double(toDouble(left.eval(s)) + (code == Lexer.INC ? 1 : -1)); if (left.code == Lexer.DOT) { @@ -677,20 +986,6 @@ public class Parser extends Lexer { } } - case Lexer.TYPEOF: { - Object o = left.eval(s); - if (o == null) return "null"; - if (o.getClass() == String.class) return "string"; - if (o.getClass() == Boolean.class) return "boolean"; - if (o instanceof Number) return "number"; - if (o instanceof JS.Array) return "array"; - if (o instanceof JS) return "object"; - throw new EvaluatorException("typeof " + o.getClass().getName() + " unknown"); - } - - case Lexer.NUMBER: return number; - case Lexer.STRING: return string; - case Lexer.NULL: return null; case Lexer.FALSE: return Boolean.FALSE; case Lexer.TRUE: return Boolean.TRUE; @@ -698,53 +993,6 @@ public class Parser extends Lexer { case Lexer.THROW: throw new JS.Exn(left.eval(s)); case Lexer.NAME: return s.get(string); case Lexer.THIS: return s.isTransparent() ? s : this.eval(s.getParentScope()); - case Lexer.DOT: { - final Object o = left.eval(s); - if (o == null) throw new EvaluatorException("tried to get a property from the null value"); - Object v = (right.code == Lexer.STRING) ? right.string : right.eval(s); - if (o instanceof String) { - if (v.equals("length")) return new Integer(((String)o).length()); - else if (v.equals("substring")) return new JS.Function() { - public Object _call(JS.Array args) { - if (args.length() == 1) return ((String)o).substring(toNumber(args.elementAt(0)).intValue()); - else if (args.length() == 2) return ((String)o).substring(toNumber(args.elementAt(0)).intValue(), - toNumber(args.elementAt(1)).intValue()); - else throw new EvaluatorException("String.substring() can only take one or two arguments"); - } - }; - else if (v.equals("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 EvaluatorException("Not Implemented: properties on String objects"); - } else if (o instanceof Boolean) { - throw new EvaluatorException("Not Implemented: properties on Boolean objects"); - } else if (o instanceof Number) { - Log.log(this, "Not Implemented: properties on Number objects"); - return null; - //throw new EvaluatorException("Not Implemented: properties on Number objects"); - } else if (o instanceof JS) { - return ((JS)o).get(v); - } - } case Lexer.TRY: { boolean safeToExit = false; @@ -771,20 +1019,13 @@ public class Parser extends Lexer { return null; } - case Lexer.LP: - JS.Function f = (JS.Function)left.eval(s); - JS.Array arguments = new JS.Array(); - for(int i=0; i<((ExprList)right).numExprs(); i++) arguments.addElement(((ExprList)right).elementAt(i).eval(s)); - if (f == null) throw new JS.Exn(new EvaluatorException("attempted to call null")); - return f.call(arguments); - case Lexer.FUNCTION: return new JS.Function() { public String toString() { return right.sourceName + ":" + right.line; } public String getSourceName() throws JS.Exn { return right.sourceName; } public Object _call(final JS.Array args) throws JS.Exn { Function save = JS.getCurrentFunction(); - JS.currentFunction.put(Thread.currentThread(), this); + JS.currentFunction.put(java.lang.Thread.currentThread(), this); JS.Scope scope = new JS.Scope(s) { // FIXME public String getSourceName() { return sourceName; } @@ -809,8 +1050,8 @@ public class Parser extends Lexer { throw new EvaluatorException("error, ControlTransferException tried to leave a function: " + c); } finally { - if (save == null) JS.currentFunction.remove(Thread.currentThread()); - else JS.currentFunction.put(Thread.currentThread(), save); + if (save == null) JS.currentFunction.remove(java.lang.Thread.currentThread()); + else JS.currentFunction.put(java.lang.Thread.currentThread(), save); } } }; @@ -848,16 +1089,6 @@ public class Parser extends Lexer { } return null; - case Lexer.HOOK: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s); - case Lexer.IF: - if (right.code == ELSE) { - if (toBoolean(left.eval(s))) right.left.eval(s); - else right.right.eval(s); - return null; - } else { - if (toBoolean(left.eval(s))) right.eval(s); - 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)); -- 1.7.10.4