-// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
-package org.xwt.js;
-
-import java.io.*;
-import org.xwt.util.*;
-
-/** sorta like gcc trees */
-public class Expr {
- int code = -1;
-
- final Expr left;
- final Expr right;
- Expr next = null; // if this expr is part of a list
-
- 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);
- if (next != null) ret += next.toString(indent);
- return ret;
- }
-
- public Expr(String s) { this(Lexer.STRING); this.string = s; } // an identifier or label
- public Expr(int code, String s) { this(code); this.string = s; }
- public Expr(Number n) { this(Lexer.NUMBER); this.number = n; } // an identifier or label
- public Expr(int code) { this(code, null, null); }
- public Expr(int code, Expr left) { this(code, left, null); }
- public Expr(int code, Expr left, Expr right) { this.code = code; this.left = left; this.right = right; }
-
- public static Number toNumber(Object o) {
- if (o == null) return new Long(0);
- if (o instanceof Number) return ((Number)o);
- if (o instanceof String) return new Double((String)o);
- if (o instanceof Boolean) return ((Boolean)o).booleanValue() ? new Long(1) : new Long(0);
- if (o instanceof JS) return ((JS)o).coerceToNumber();
- throw new Error("toNumber() got object of type " + o.getClass().getName());
- }
-
- public static double toDouble(Object o) { return toNumber(o).doubleValue(); }
- public static long toLong(Object o) { return toNumber(o).longValue(); }
- public static boolean toBoolean(Object o) {
- if (o == null) return false;
- if (o instanceof Boolean) return ((Boolean)o).booleanValue();
- if (o instanceof Number) return o.equals(new Integer(0));
- return true;
- }
-
- public Object eval(final JS.Scope s) throws ControlTransferException, JS.Exn {
- switch(code) {
-
- case Lexer.BITOR: return new Long(toLong(left.eval(s)) | toLong(right.eval(s)));
- case Lexer.BITXOR: return new Long(toLong(left.eval(s)) ^ toLong(right.eval(s)));
- case Lexer.BITAND: return new Long(toLong(left.eval(s)) & toLong(right.eval(s)));
- case Lexer.BITNOT: return new Long(~toLong(left.eval(s)));
-
- case Lexer.ADD: {
- Object l = left.eval(s);
- Object r = right.eval(s);
- if (l instanceof String || r instanceof String) return l.toString() + r.toString();
- return new Double(toDouble(l) + toDouble(r));
- }
-
- case Lexer.SUB: return new Double(toDouble(left.eval(s)) - toDouble(right.eval(s)));
- case Lexer.MUL: return new Double(toDouble(left.eval(s)) * toDouble(right.eval(s)));
- case Lexer.DIV: return new Double(toDouble(left.eval(s)) / toDouble(right.eval(s)));
- case Lexer.MOD: return new Double(toDouble(left.eval(s)) % toDouble(right.eval(s)));
-
- case Lexer.LSH: return new Long(toLong(left.eval(s)) << toLong(right.eval(s)));
- case Lexer.RSH: return new Long(toLong(left.eval(s)) >> toLong(right.eval(s)));
- case Lexer.URSH: return new Long(toLong(left.eval(s)) >>> toLong(right.eval(s)));
-
- case Lexer.LT: return toDouble(left.eval(s)) < toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
- case Lexer.LE: return toDouble(left.eval(s)) <= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
- case Lexer.GT: return toDouble(left.eval(s)) > toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
- case Lexer.GE: return toDouble(left.eval(s)) >= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
-
- case Lexer.OR: return new Boolean(toBoolean(left.eval(s)) || toBoolean(right.eval(s)));
- case Lexer.AND: return new Boolean(toBoolean(left.eval(s)) && toBoolean(right.eval(s)));
-
- case Lexer.EQ:
- case Lexer.NE: {
- // FIXME: should use Javascript coercion-equality rules
- boolean ret = left.eval(s).equals(right.eval(s));
- return new Boolean(code == Lexer.EQ ? ret : !ret);
- }
-
- case Lexer.INC:
- case Lexer.DEC:
- case Lexer.ASSIGN: {
- Object v = (code == Lexer.ASSIGN) ? right.eval(s) : new Double(toDouble(left.eval(s)) + (code == Lexer.INC ? 1 : -1));
- if (left.code == Lexer.DOT) {
- Object o = left.left.eval(s);
- if (o instanceof String) {
- throw new Error("can't set properties on a String");
- } else if (o instanceof Number) {
- throw new Error("can't set properties on a Number");
- } else if (o instanceof Boolean) {
- throw new Error("can't set properties on a Boolean");
- } else {
- ((JS)left.left.eval(s)).put(left.right.eval(s), v);
- return v;
- }
- } else {
- s.put(left.string, v);
- return v;
- }
- }
-
- case Lexer.TYPEOF: {
- Object o = left.eval(s);
- if (o == null) return "null";
- if (o.getClass() == String.class) return "string";
- if (o.getClass() == Boolean.class) return "boolean";
- if (o instanceof Number) return "number";
- if (o instanceof JS.Array) return "array";
- if (o instanceof JS) return "object";
- throw new Error("typeof " + o.getClass().getName() + " unknown");
- }
-
- case Lexer.NUMBER: return number;
- case Lexer.STRING: return string;
-
- case Lexer.NULL: return null;
- case Lexer.THIS: return s;
- case Lexer.FALSE: return Boolean.FALSE;
- case Lexer.TRUE: return Boolean.TRUE;
- case Lexer.ASSERT: if (!toBoolean(left.eval(s))) throw new Error("assertion failed");
- case Lexer.THROW: throw new JS.Exn(left.eval(s));
-
- case Lexer.NAME: return s.get(string);
- case Lexer.DOT: {
- Object o = left.eval(s);
- Object v = right.eval(s);
- if (o instanceof String) {
- if (v.equals("length")) return new Integer(((String)o).length());
- 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) {
- throw new Error("Not Implemented: properties on Number objects");
- } else if (o instanceof JS) {
- return ((JS)o).get(v);
- }
- }
-
- case Lexer.TRY: {
- boolean safeToExit = false;
- try {
- Object ret = left.eval(s);
- safeToExit = true;
- return ret;
- } catch (JS.Exn e) {
- Expr c = right;
- if (c.code == Lexer.CATCH) {
- JS.Scope scope = new JS.Scope(s);
- s.put(c.left.string, e);
- c.right.eval(scope);
- c = c.next;
- }
- if (c.code == Lexer.FINALLY) {
- JS.Scope scope = new JS.Scope(s);
- c.left.eval(scope);
- }
- } finally {
- if (!safeToExit) Log.log(this, "WARNING: Java exception penetrated a JavaScript try{} block");
- }
- return null;
- }
-
- case Lexer.LP:
- JS.Function f = (JS.Function)left.eval(s);
- JS.Array arguments = new JS.Array();
- for(Expr e = right; e != null; e = e.next) arguments.addElement(e.eval(s));
- return f.call(arguments);
-
- case Lexer.FUNCTION:
- return new JS.ObjFunction() {
- public JS.Scope getParentScopeOfDeclaration() { return s; }
- public Object call(JS.Array args) throws JS.Exn {
- JS.Scope scope = new JS.Scope(getParentScopeOfDeclaration()) {
- public Object get(Object key) throws JS.Exn {
- if (key.equals("trapee")) return org.xwt.Trap.currentTrapee();
- return super.get(key);
- }
- };
- // FIXME
- args.put("cascade", org.xwt.Trap.cascadeFunction);
- scope.put("arguments", args);
- int i = 0;
- for(Expr e = left; e != null; e = e.next) scope.put(e.string, args.get(new Integer(i++)));
- try {
- return right.eval(scope);
- } catch (ReturnException r) {
- return r.retval;
- } catch (ControlTransferException c) {
- throw new Error("error, ControlTransferException tried to leave a function: " + c);
- }
- }
- };
-
- case Lexer.FOR:
- Object[] keys = ((JS)left.right.eval(s)).enumerateProperties();
- try {
- for(int i=0; i<keys.length; i++) {
- JS.Scope scope = new JS.Scope(s);
- scope.put(left.left.string, keys[i]);
- try {
- right.eval(scope);
- } catch (ContinueException c) { /* FIXME: handle labels */ }
- }
- } catch (BreakException b) { /* FIXME: handle labels */ }
- return null;
-
- case Lexer.SWITCH:
- Object switchVal = left.eval(s);
- boolean go = false;
- try {
- for(Expr e = right; e != null; e = e.next) {
- if (go || e.code == Lexer.DEFAULT || e.left.eval(s).equals(switchVal)) go = true;
- if (go) e.right.eval(s);
- }
- } catch (BreakException b) { /* FIXME: handle labels */ }
- return null;
-
- case Lexer.LB: {
- JS.Array ret = new JS.Array();
- for(Expr e = left; e != null; e = e.next) ret.addElement(e.eval(s));
- return ret;
- }
-
- case Lexer.LC: // block
- for(Expr e = left; e != null; e = e.next) e.eval(s);
- return null;
-
- case Lexer.RC: { // Object ctor
- JS.Obj ret = new JS.Obj();
- for(Expr e = left; e != null; e = e.next)
- ret.put(e.left.string, e.right.eval(s));
- return ret;
- }
-
- case Lexer.VAR:
- for(Expr e = left; e != null; e = e.next)
- if (e.code == Lexer.NAME) {
- s.declare(e.string);
- } else {
- s.declare(e.left.string);
- e.eval(s);
- }
- return null;
-
- case Lexer.HOOK: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s);
- case Lexer.IF: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s);
-
- case Lexer.BREAK: throw new BreakException(string);
- case Lexer.CONTINUE: throw new ContinueException(string);
- case Lexer.RETURN: throw new ReturnException(left == null ? null : left.eval(s));
-
- case Lexer.WHILE:
- case Lexer.DO:
- try {
- boolean first = true;
- while((first && code == Lexer.DO) || toBoolean(left.eval(s))) {
- first = false;
- try { right.eval(s); }
- catch (ContinueException e) {
- if (e.label != null && !e.label.equals(string)) throw e;
- }
- }
- } catch (BreakException e) {
- if (e.label != null && !e.label.equals(string)) throw e;
- }
- return null;
-
- default: throw new Error("don't know how to eval an Expr with code " + Lexer.codeToString[code]);
- }
- }
-
- private static abstract class ControlTransferException extends Exception { }
- private static class BreakException extends ControlTransferException {
- public String label;
- BreakException(String label) { this.label = label; }
- }
- private static class ContinueException extends ControlTransferException {
- public String label;
- ContinueException(String label) { this.label = label; }
- }
- private static class ReturnException extends ControlTransferException {
- public Object retval;
- ReturnException(Object retval) { this.retval = retval; }
- }
-}
-
// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL]
-
+
package org.xwt.js;
import org.xwt.util.*;
+import java.io.*;
+import java.util.*;
/** The public API for the JS engine */
// FEATURE: try using mutable, recycled 'Num' objects
-public interface JS {
+public abstract class JS {
+
+ // Static Methods //////////////////////////////////////////////////////////////////////
+
+ public static Function getCurrentFunction() {
+ return (Function)currentFunction.get(Thread.currentThread());
+ }
+ public static String getCurrentFunctionSourceName() {
+ return getCurrentFunctionSourceName(Thread.currentThread());
+ }
+ public static String getCurrentFunctionSourceName(Thread t) {
+ Function f = (Function)currentFunction.get(t);
+ if (f == null) return "null";
+ return f.getSourceName();
+ }
+ public static String getFileAndLine() {
+ return "unknown:??";
+ }
+
+
+ // Instance Methods ////////////////////////////////////////////////////////////////////
public abstract Object get(Object key) throws JS.Exn;
public abstract void put(Object key, Object val) throws JS.Exn;
- public abstract Object[] enumerateProperties();
+ public abstract Object[] keys();
+
+ public Number coerceToNumber() { throw new Error("you cannot coerce a " + this.getClass().getName() + " into a Number"); }
+ public String coerceToString() { throw new Error("you cannot coerce a " + this.getClass().getName() + " into a String"); }
+ public boolean coerceToBoolean() { throw new Error("you cannot coerce a " + this.getClass().getName() + " into a Boolean"); }
- public abstract Number coerceToNumber() throws JS.Exn;
- public abstract boolean coerceToBoolean() throws JS.Exn;
- public abstract String coerceToString() throws JS.Exn;
- public static class Obj implements JS {
- private Hash entries;
- public Obj() { }
+ // Subclasses /////////////////////////////////////////////////////////////////////////
+
+ public static class Obj extends JS {
+ private Hash entries = new Hash();
+ private boolean sealed = false;
+ public Obj() { this(false); }
+ public Obj(boolean sealed) { this.sealed = sealed; }
+ public void setSeal(boolean sealed) { this.sealed = sealed; }
public Object get(Object key) { return entries.get(key); }
- public void put(Object key, Object val) { entries.put(key, val); }
- public Object[] enumerateProperties() { return(entries.keys()); }
- public Number coerceToNumber() { throw new Error("tried to turn a Object into a Number"); }
- public String coerceToString() { throw new Error("tried to turn a Object into a String"); }
- public boolean coerceToBoolean() { throw new Error("tried to turn a Object into a Boolean"); }
+ public void put(Object key, Object val) { if (!sealed) entries.put(key, val); }
+ public Object[] keys() { return(entries.keys()); }
}
+ public static class Exn extends RuntimeException {
+ private Object js = null;
+ public Exn(Object js) { this.js = js; }
+ public String toString() { return "JS.Exn: " + js.toString(); }
+ public String getMessage() { return toString(); }
+ public Object getObject() { return js; }
+ }
+
public static class Array extends Obj {
private Vec vec = new Vec();
private static int intVal(Object o) {
return Integer.parseInt(s);
}
public Object get(Object key) {
+ // FIXME: HACK!
+ if (key.equals("cascade")) return org.xwt.Trap.cascadeFunction;
if (key.equals("length")) return new Long(vec.size());
int i = intVal(key);
if (i == Integer.MIN_VALUE) return super.get(key);
return vec.elementAt(i);
}
public void put(Object key, Object val) {
- if (key.equals("length")) vec.setSize(Expr.toNumber(val).intValue());
+ if (key.equals("length")) vec.setSize(Parser.toNumber(val).intValue());
int i = intVal(key);
if (i == Integer.MIN_VALUE) super.put(key, val);
else vec.setElementAt(val, i);
}
- public Object[] enumerateProperties() { return null; } // FIXME
- void addElement(Object o) { vec.addElement(o); }
+ public Object[] keys() {
+ Object[] sup = super.keys();
+ Object[] ret = new Object[vec.size() + 1 + sup.length];
+ System.arraycopy(sup, 0, ret, vec.size(), sup.length);
+ for(int i=0; i<vec.size(); i++) ret[i] = new Integer(i);
+ ret[vec.size()] = "length";
+ return ret;
+ }
+ public int length() { return vec.size(); }
+ public Object elementAt(int i) { return vec.elementAt(i); }
+ public void addElement(Object o) { vec.addElement(o); }
+ public void setElementAt(Object o, int i) { vec.setElementAt(o, i); }
}
- public static interface Function extends JS {
- public abstract Object call(JS.Array args) throws JS.Exn; // FEATURE: try to recycle these arrays?
- public abstract Scope getParentScopeOfDeclaration();
+ public static Hashtable currentFunction = new Hashtable();
+ public static abstract class Function extends Obj {
+ public abstract Object _call(JS.Array args) throws JS.Exn;
+ public String getSourceName() throws JS.Exn { return "unknown"; }
+ public final Object call(JS.Array args) throws JS.Exn { return _call(args); }
}
- public static abstract class ObjFunction extends Obj implements Function { }
-
- /** if JS calls a Java method, and the Java method throws an exception, it can only be caught by JS if it is a subclass of Exn. */
- public static class Exn extends RuntimeException {
- private Object js = null;
- public Exn(Object js) { this.js = js; }
- public Object getObject() { return js; }
- }
+ public static class Script extends Function {
+ Parser.Expr e = null;
+ private Script(Parser.Expr e) { this.e = e; }
+ public Object _call(JS.Array args) throws JS.Exn {
+ Scope rootScope = (Scope)args.elementAt(0);
+ try {
+ e.eval(rootScope);
+ } catch (Parser.ReturnException e) {
+ // ignore
+ } catch (Parser.ControlTransferException e) {
+ throw new JS.Exn("block threw a ControlTransferException: " + e);
+ }
+ return null;
+ }
+ public static Script parse(Reader r, String sourceName, int line) throws IOException {
+ Parser p = new Parser(r, sourceName, line);
+ p.pushBackToken(Lexer.LC); // FIXME: hack
+ try {
+ return new Script(p.parseBlock(true));
+ } catch (Exception e) {
+ if (Log.on) Log.log(Parser.class, e);
+ return null;
+ }
+ }
+ }
/** Any object which becomes part of the scope chain must support this interface */
public static class Scope extends Obj {
private Scope parentScope;
private static Object NULL = new Object();
- public Scope(Scope parentScope) { this.parentScope = parentScope; }
- public JS getParentScope() { return parentScope; }
+ public Scope(Scope parentScope) { this(parentScope, false); }
+ public Scope(Scope parentScope, boolean sealed) { super(sealed); this.parentScope = parentScope; }
+ public Scope getParentScope() { return parentScope; }
+
+ // transparent scopes are not returned by THIS
+ public boolean isTransparent() { return false; }
+
public boolean has(Object key) { return super.get(key) != null; }
public Object get(Object key) {
- if (!has(key)) return getParentScope().get(key);
+ if (!has(key)) return parentScope == null ? null : getParentScope().get(key);
Object ret = super.get(key); return ret == NULL ? null : ret;
}
public void put(Object key, Object val) {
- if (!has(key)) getParentScope().put(key, val);
+ if (!has(key) && parentScope != null) getParentScope().put(key, val);
else super.put(key, val == null ? NULL : val);
}
- public Object[] enumerateProperties() { throw new Error("you can't enumerate the properties of a Scope"); }
- public void declare(String s) { super.put(s, NULL); }
+ public Object[] keys() { throw new Error("you can't enumerate the properties of a Scope"); }
+ public void declare(String s) { if (isTransparent()) getParentScope().declare(s); else super.put(s, NULL);}
}
+
}
// Constructors //////////////////////////////////////////////////////
- public Parser(Reader r) throws IOException { super(r); }
+ public Parser(Reader r, String sourceName, int line) throws IOException {
+ super(r);
+ this.sourceName = sourceName;
+ this.line = line;
+ }
public static void main(String[] s) throws Exception {
- Parser p = new Parser(new InputStreamReader(System.in));
+ Parser p = new Parser(new InputStreamReader(System.in), "stdin", 0);
while(true) {
Expr block = p.parseBlock(false);
if (block == null) return;
// Statics ////////////////////////////////////////////////////////////
static byte[] precedence = new byte[MAX_TOKEN + 1];
+ static boolean[] isRightAssociative = new boolean[MAX_TOKEN + 1];
static {
- precedence[COMMA] = 1;
- precedence[ASSIGN] = 2;
- precedence[GT] = precedence[GE] = 3;
- precedence[OR] = precedence[AND] = 4;
- precedence[BITOR] = 5;
- precedence[BITXOR] = 6;
- precedence[BITAND] = 7;
- precedence[EQ] = precedence[NE] = 8;
- precedence[LT] = precedence[LE] = 9;
- precedence[SHEQ] = precedence[SHNE] = 10;
- precedence[LSH] = precedence[RSH] = precedence[URSH] = 11;
- precedence[ADD] = precedence[SUB] = 12;
- precedence[MUL] = precedence[DIV] = precedence[MOD] = 13;
- precedence[BITNOT] = precedence[INSTANCEOF] = 14;
- precedence[INC] = precedence[DEC] = 15;
- precedence[LP] = 16;
- precedence[DOT] = 17;
+ precedence[ASSIGN] = 1;
+ isRightAssociative[ASSIGN] = true;
+ precedence[HOOK] = 2;
+ precedence[COMMA] = 3;
+ precedence[GT] = precedence[GE] = 4;
+ precedence[OR] = precedence[AND] = 5;
+ precedence[BITOR] = 6;
+ precedence[BITXOR] = 7;
+ precedence[BITAND] = 8;
+ precedence[EQ] = precedence[NE] = 9;
+ precedence[LT] = precedence[LE] = 10;
+ precedence[SHEQ] = precedence[SHNE] = 11;
+ precedence[LSH] = precedence[RSH] = precedence[URSH] = 12;
+ precedence[ADD] = precedence[SUB] = 13;
+ precedence[MUL] = precedence[DIV] = precedence[MOD] = 14;
+ precedence[BITNOT] = precedence[INSTANCEOF] = 15;
+ precedence[INC] = precedence[DEC] = 16;
+ precedence[LP] = 17;
+ precedence[LB] = 18;
+ precedence[DOT] = 19;
}
Expr ret = null;
int tok = peekToken();
boolean braced = tok == LC;
- if (requireBraces && !braced) throw new Error("expected {");
+ if (requireBraces && !braced) throw new ParserException("expected {");
if (braced) getToken();
Expr head = null;
Expr tail = null;
+ int curLine = line;
OUTER: while(true) {
Expr smt;
case LC: smt = parseBlock(true); break;
case THROW: case RETURN: case ASSERT:
getToken();
- smt = new Expr(tok, parseMaximalExpr());
- if (getToken() != SEMI) throw new Error("expected ;");
+ smt = new Expr(curLine, tok, parseMaximalExpr());
+ if (getToken() != SEMI) throw new ParserException("expected ;");
break;
- case GOTO: case BREAK: case CONTINUE:
+ /*
+ FIXME
+ case NAME: {
getToken();
- if (getToken() == NAME)
- smt = new Expr(tok, new Expr(string));
- else if (tok == GOTO)
- throw new Error("goto must be followed by a label");
- else
- smt = new Expr(tok);
- if (getToken() != SEMI) throw new Error("expected ;");
+ String str = string;
+ if (getToken() != COLON) throw new ParserException("expected COLON after label");
+ Expr labeledBlock = parseBlock(false);
+ if (labeledBlock.code != WHILE && labeledBlock.code != FOR && labeledBlock.code != SWITCH)
+ throw new ParserException("you can only label a WHILE, FOR, or SWITCH block");
+ labeledBlock.string = str;
+ return labeledBlock;
+ }
+ */
+
+ case GOTO: case BREAK: case CONTINUE: {
+ getToken();
+ int t = peekToken();
+ if (t == NAME) {
+ getToken();
+ smt = new Expr(curLine, tok, new Expr(curLine, string));
+ } else if (t == GOTO) {
+ throw new ParserException("goto must be followed by a label");
+ } else if (t == SEMI) {
+ getToken();
+ smt = new Expr(curLine, tok);
+ } else {
+ throw new ParserException(codeToString[tok] + " followed by a " + codeToString[t] + "; expected NAME or SEMI");
+ }
break;
+ }
case RC:
if (braced) getToken();
default:
smt = parseMaximalExpr();
if (smt == null) {
- if (head == null) throw new Error("empty statement list; next token is " + codeToString[peekToken()]);
+ if (head == null) throw new ParserException("empty statement list; next token is " + codeToString[peekToken()]);
break OUTER;
}
break;
}
if (head == null) head = tail = smt; else tail = (tail.next = smt);
}
- return new Expr(LC, head);
+ return new Expr(curLine, LC, head);
}
/** throws an error if the next token is not <tt>code</tt> */
public void expect(int code) throws IOException {
int got = peekToken();
if (got != code)
- throw new Error("expected " + codeToString[got] + ", got " + (got == -1 ? "EOL" : codeToString[got]));
+ throw new ParserException("expected " + codeToString[code] + ", got " + (got == -1 ? "EOL" : codeToString[got]));
}
/** parses the largest possible expression */
Expr save = prefix;
prefix = parseSingleExpr(prefix, minPrecedence);
if (save == prefix) break;
- if (prefix == null) throw new Error("parseSingleExpr() returned null");
+ if (prefix == null) throw new ParserException("parseSingleExpr() returned null");
}
return prefix;
}
Expr e1 = null, e2 = null, e3 = null, head = null, tail = null, ret = null;
int tok = peekToken();
- if (minPrecedence > 0 && tok < precedence.length && precedence[tok] != 0 && precedence[tok] <= minPrecedence) return prefix;
+ if (minPrecedence > 0 &&
+ tok < precedence.length &&
+ precedence[tok] != 0 &&
+ (isRightAssociative[tok] ?
+ (precedence[tok] < minPrecedence) :
+ (precedence[tok] <= minPrecedence))) {
+ return prefix;
+ }
getToken();
+ int curLine = line;
// these case arms match the precedence of operators; each arm is a precedence level.
switch (tok) {
- case WITH: throw new Error("XWT does not allow the WITH keyword");
- case VOID: case RESERVED: throw new Error("reserved word that you shouldn't be using");
- case NAME: if (prefix != null) { pushBackToken(); return prefix; } else return parseMaximalExpr(new Expr(NAME, string), minPrecedence);
- case STRING: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(string);
- case NUMBER: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(number);
- case NULL: case TRUE: case FALSE: case NOP: if (prefix != null) { pushBackToken(); return prefix; } else return new Expr(tok);
+ case 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(ASSIGN, prefix, new Expr(tok - 1, prefix, parseMaximalExpr(null, precedence[ASSIGN])));
+ 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 SUB: case MUL: case DIV: case MOD:
- case COMMA: case ASSIGN: case GT: case GE: case OR: case AND:
+ 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:
- return new Expr(tok, prefix, parseMaximalExpr(null, precedence[tok]));
-
- case DOT:
- e1 = parseMaximalExpr(null, precedence[tok]);
- if (e1.code == NAME) e1.code = STRING;
- else throw new Error("argument to DOT must be a NAME");
- return new Expr(DOT, prefix, e1);
+ 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 BITNOT: case INSTANCEOF:
- if (prefix != null) throw new Error("didn't expect non-null prefix!");
- return new Expr(tok, parseMaximalExpr(null, precedence[tok]));
+ case BANG: case BITNOT: case INSTANCEOF: case TYPEOF:
+ if (prefix != null) { pushBackToken(); return prefix; }
+ return new Expr(curLine, tok, parseMaximalExpr(null, precedence[tok]));
case INC: case DEC:
if (prefix == null) {
// prefix
e1 = parseMaximalExpr(null, precedence[tok]);
- return new Expr(ASSIGN, e1, new Expr(tok == INC ? ADD : SUB, e1, new Expr(new Integer(1))));
+ return new Expr(curLine, ASSIGN, e1, new Expr(curLine, tok == INC ? ADD : SUB, e1, new Expr(curLine, new Integer(1))));
} else {
// postfix
- return new Expr(tok, prefix);
+ return new Expr(curLine, tok, prefix);
}
case LP:
if (head == null) head = tail = e; else tail = tail.next = e;
tok = getToken();
if (tok == RP) { pushBackToken(); break; }
- if (tok != COMMA) throw new Error("expected comma or right paren, got " + codeToString[tok]);
+ if (tok != COMMA) throw new ParserException("expected comma or right paren, got " + codeToString[tok]);
}
getToken();
- return new Expr(LP, prefix, head);
+ return new Expr(curLine, LP, prefix, head);
}
case LB:
if (prefix != null) {
// subscripting
e1 = parseMaximalExpr();
- if (getToken() != RB) throw new Error("expected a right brace");
- return new Expr(DOT, prefix, e1);
+ if (getToken() != RB) throw new ParserException("expected a right brace");
+ return new Expr(curLine, DOT, prefix, e1);
} else {
// array ctor
- tok = getToken();
while(true) {
- if (tok == RB) return new Expr(LB, prefix, head);
- if (head == null) head = tail = parseMaximalExpr();
- else tail = tail.next = parseMaximalExpr();
+ if (peekToken() == RB) { getToken(); return new Expr(curLine, LB, prefix, head); }
+ Expr eee = parseMaximalExpr();
+ if (eee != null) {
+ if (head == null) head = tail = eee;
+ else tail.next = tail = eee;
+ }
tok = getToken();
- if (tok != COMMA && tok != RP) throw new Error("expected right bracket or comma");
+ if (tok == RB) return new Expr(curLine, LB, prefix, head);
+ if (tok != COMMA) throw new ParserException("expected right bracket or comma");
}
}
case LC:
- if (prefix != null) throw new Error("didn't expect non-null prefix");
+ if (prefix != null) { pushBackToken(); return prefix; }
tok = getToken();
+ if (tok == RC) return new Expr(curLine, RC, head);
while(true) {
- if (tok == RC) return new Expr(RC, head);
- if (tok != NAME) throw new Error("expecting name");
- expect(NAME); getToken();
- Expr name = new Expr(NAME, string);
- if (tok != COLON) throw new Error("expecting colon");
- e1 = new Expr(COLON, name, parseMaximalExpr());
+ if (tok != NAME && tok != STRING) throw new ParserException("expecting name, got " + codeToString[tok]);
+ Expr name = new Expr(curLine, NAME, string);
+ if (getToken() != COLON) throw new ParserException("expecting colon");
+ e1 = new Expr(curLine, COLON, name, parseMaximalExpr());
if (head == null) head = tail = e1; else tail = tail.next = e1;
tok = getToken();
- if (tok != COMMA && tok != RP) throw new Error("expected right curly or comma");
+ if (tok != COMMA && tok != RC) throw new ParserException("expected right curly or comma, got " + codeToString[tok]);
+ if (tok == RC) return new Expr(curLine, RC, head);
+ tok = getToken();
+ if (tok == RC) return new Expr(curLine, RC, head);
}
case HOOK:
e2 = parseMaximalExpr();
- if (getToken() != COLON) throw new Error("expected colon to close ?: expression");
+ if (getToken() != COLON) throw new ParserException("expected colon to close ?: expression");
e3 = parseMaximalExpr();
- return new Expr(HOOK, prefix, new Expr(ELSE, e2, e3));
+ return new Expr(curLine, HOOK, prefix, new Expr(curLine, ELSE, e2, e3));
case SWITCH: {
- if (prefix != null) throw new Error("didn't expect non-null prefix");
- if (getToken() != LP) throw new Error("expected left paren");
+ if (prefix != null) { pushBackToken(); return prefix; }
+ if (getToken() != LP) throw new ParserException("expected left paren");
Expr switchExpr = parseMaximalExpr();
- if (getToken() != RP) throw new Error("expected left paren");
- if (getToken() != LC) throw new Error("expected left brace");
+ if (getToken() != RP) throw new ParserException("expected left paren");
+ if (getToken() != LC) throw new ParserException("expected left brace");
Expr firstExpr = null;
Expr lastExpr = null;
while(true) {
if (tok == DEFAULT) {
caseExpr = null;
} else if (tok == CASE) {
+ // FIXME: we don't support non-brace-enclosed CASE blocks
caseExpr = parseMaximalExpr();
} else {
- throw new Error("expected CASE");
+ throw new ParserException("expected CASE");
}
expect(COLON); getToken();
- e1 = new Expr(tok, caseExpr, parseBlock(false));
- if (lastExpr == null) firstExpr = e1;
- else lastExpr.next = e1;
+ head = tail = null;
+ while(peekToken() != CASE && peekToken() != DEFAULT && peekToken() != RC) {
+ e1 = parseBlock(false);
+ if (e1 == null) break;
+ if (head == null) head = tail = e1; else tail = tail.next = e1;
+ }
+ e1 = new Expr(curLine, tok, caseExpr, new Expr(curLine, LC, head));
+ if (lastExpr == null) firstExpr = e1; else lastExpr.next = e1;
lastExpr = e1;
- if (getToken() == RC) return new Expr(SWITCH, switchExpr, firstExpr);
+ if (peekToken() == RC) {getToken(); return new Expr(curLine, SWITCH, switchExpr, firstExpr); }
}
}
case FUNCTION: {
- if (prefix != null) throw new Error("didn't expect non-null prefix");
- if (getToken() != LP) throw new Error("function keyword must be followed by a left paren");
+ if (prefix != null) { pushBackToken(); return prefix; }
+ if (getToken() != LP) throw new ParserException("function keyword must be followed by a left paren");
Expr formalArgs = null, cur = null;
tok = getToken();
while(tok != RP) {
- if (tok != NAME) throw new Error("expected a variable name");
- if (cur == null) { formalArgs = cur = new Expr(string); }
- else { cur.next = new Expr(NAME, string); cur = cur.next; }
+ if (tok != NAME) throw new ParserException("expected a variable name");
+ if (cur == null) { formalArgs = cur = new Expr(curLine, string); }
+ else { cur.next = new Expr(curLine, NAME, string); cur = cur.next; }
tok = getToken();
if (tok == RP) break;
- if (tok != COMMA) throw new Error("function argument list must consist of alternating NAMEs and COMMAs");
+ if (tok != COMMA) throw new ParserException("function argument list must consist of alternating NAMEs and COMMAs");
tok = getToken();
}
- return new Expr(FUNCTION, formalArgs, parseBlock(true));
+ return new Expr(curLine, FUNCTION, formalArgs, parseBlock(true));
}
case VAR:
- if (prefix != null) throw new Error("didn't expect non-null prefix");
+ if (prefix != null) { pushBackToken(); return prefix; }
while(true) {
- if (getToken() != NAME) throw new Error("variable declarations must start with a variable name");
- Expr name = new Expr(NAME, string);
+ if (getToken() != NAME) throw new ParserException("variable declarations must start with a variable name");
+ Expr name = new Expr(curLine, NAME, string);
Expr initVal = null;
tok = peekToken();
Expr e = null;
getToken();
initVal = parseMaximalExpr();
tok = peekToken();
- e = new Expr(ASSIGN, name, initVal);
+ e = new Expr(curLine, ASSIGN, name, initVal);
} else {
- e = new Expr(NAME, name);
+ e = new Expr(curLine, NAME, name);
}
if (head == null) head = tail = e; else tail = tail.next = e;
if (tok != COMMA) break;
getToken();
}
- return new Expr(VAR, head);
+ return new Expr(curLine, VAR, head);
case TRY: {
// We deliberately allow you to omit braces in catch{}/finally{} if they are single statements...
- if (prefix != null) throw new Error("didn't expect non-null prefix");
+ if (prefix != null) { pushBackToken(); return prefix; }
Expr tryBlock = parseBlock(true);
tok = peekToken();
if (tok == CATCH) {
getToken();
- if (getToken() != LP) throw new Error("expected (");
- if (getToken() != NAME) throw new Error("expected name");
- Expr name = new Expr(NAME, string);
- if (getToken() != RP) throw new Error("expected )");
- head = tail = new Expr(CATCH, name, parseBlock(false));
+ if (getToken() != LP) throw new ParserException("expected (");
+ if (getToken() != NAME) throw new ParserException("expected name");
+ Expr name = new Expr(curLine, NAME, string);
+ if (getToken() != RP) throw new ParserException("expected )");
+ head = tail = new Expr(curLine, CATCH, name, parseBlock(false));
tok = peekToken();
}
if (tok == FINALLY) {
getToken();
- e1 = new Expr(FINALLY, parseBlock(false));
+ e1 = new Expr(curLine, FINALLY, parseBlock(false));
if (head == null) head = tail = e1; else tail = tail.next = e1;
}
- if (head == null) throw new Error("try without catch or finally");
- return new Expr(TRY, tryBlock, head);
+ if (head == null) throw new ParserException("try without catch or finally");
+ return new Expr(curLine, TRY, tryBlock, head);
}
case IF: case WHILE: {
- if (prefix != null) throw new Error("didn't expect non-null prefix");
- if (getToken() != LP) throw new Error("expected left paren");
+ if (prefix != null) { pushBackToken(); return prefix; }
+ if (getToken() != LP) throw new ParserException("expected left paren");
Expr parenExpr = parseMaximalExpr();
int t;
- if ((t = getToken()) != RP) throw new Error("expected right paren, but got " + codeToString[t]);
+ if ((t = getToken()) != RP) throw new ParserException("expected right paren, but got " + codeToString[t]);
Expr firstBlock = parseBlock(false);
if (tok == IF && peekToken() == ELSE) {
getToken();
- return new Expr(tok, parenExpr, new Expr(ELSE, firstBlock, parseBlock(false)));
+ return new Expr(curLine, tok, parenExpr, new Expr(curLine, ELSE, firstBlock, parseBlock(false)));
+ } else if (tok == IF) {
+ return new Expr(curLine, tok, parenExpr, new Expr(curLine, ELSE, firstBlock, new Expr(curLine, LC)));
+ } else if (tok == WHILE) {
+ return new Expr(curLine, tok, parenExpr, firstBlock);
}
- return new Expr(tok, parenExpr, firstBlock);
}
- case IN: return prefix;
+ case IN: pushBackToken(); return prefix;
+
case FOR:
- if (prefix != null) throw new Error("didn't expect non-null prefix");
- if (getToken() != LP) throw new Error("expected left paren");
+ if (prefix != null) { pushBackToken(); return prefix; }
+ if (getToken() != LP) throw new ParserException("expected left paren");
e1 = parseMaximalExpr(null, -1);
- if (e1.code == NAME && peekToken() == IN) {
+ if (peekToken() == IN) {
getToken();
e2 = parseMaximalExpr(null, -1);
- if (getToken() != RP) throw new Error("expected right paren");
- return new Expr(FOR, new Expr(IN, e1, e2), parseBlock(false));
+ if (getToken() != RP) throw new ParserException("expected right paren");
+ return new Expr(curLine, FOR, new Expr(curLine, IN, e1, e2), parseBlock(false));
} else {
- if (getToken() != SEMI) throw new Error("expected ;");
- e2 = parseMaximalExpr(null, -1);
- if (getToken() != SEMI) throw new Error("expected ;");
- e3 = parseMaximalExpr(null, -1);
- if (getToken() != RP) throw new Error("expected right paren");
- return new Expr(LC, e1, new Expr(WHILE, e2, new Expr(LC, parseBlock(false), e3)));
+ if (getToken() != SEMI) throw new ParserException("expected ;");
+ e2 = parseMaximalExpr();
+ if (getToken() != SEMI) throw new ParserException("expected ;");
+ e3 = parseMaximalExpr();
+ if (getToken() != RP) throw new ParserException("expected right paren");
+ return new Expr(curLine, LC, e1, new Expr(curLine, WHILE, e2, new Expr(curLine, LC, parseBlock(false), e3)));
}
case DO: {
- if (prefix != null) throw new Error("didn't expect non-null prefix");
+ if (prefix != null) { pushBackToken(); return prefix; }
Expr firstBlock = parseBlock(false);
- if (getToken() != WHILE) throw new Error("expecting WHILE");
- if (getToken() != LP) throw new Error("expected left paren");
+ if (getToken() != WHILE) throw new ParserException("expecting WHILE");
+ if (getToken() != LP) throw new ParserException("expected left paren");
Expr whileExpr = parseMaximalExpr();
- if (getToken() != RP) throw new Error("expected right paren");
- if (getToken() != SEMI) throw new Error("semicolon");
- return new Expr(DO, firstBlock, whileExpr);
+ if (getToken() != RP) throw new ParserException("expected right paren");
+ if (getToken() != SEMI) throw new ParserException("semicolon");
+ return new Expr(curLine, DO, firstBlock, whileExpr);
}
default:
}
}
-}
+ // Expr //////////////////////////////////////////////////////////////////////
+
+ /** sorta like gcc trees */
+ class Expr {
+ int code = -1;
+
+ final Expr left;
+ final Expr right;
+ Expr next = null; // if this expr is part of a list
+ int line = -1;
+ String sourceName = "unknown";
+
+ String string = null;
+ Number number = null;
+
+ public String toString() { return toString(0); }
+ public String toString(int indent) {
+ String ret = "";
+ for(int i=0; i<indent; i++) ret += " ";
+ ret += Lexer.codeToString[code];
+ if (code == Lexer.NUMBER) ret += " " + number;
+ else if (string != null) ret += " \"" + string + "\"";
+ ret += "\n";
+ if (left != null) ret += left.toString(indent + 2);
+ if (right != null) ret += right.toString(indent + 2);
+ if (next != null) ret += next.toString(indent);
+ return ret;
+ }
+
+ public Expr(int line, String s) { this(line, Lexer.STRING); this.string = s; } // an identifier or label
+ public Expr(int line, int code, String s) { this(line, code); this.string = s; }
+ public Expr(int line, Number n) { this(line, Lexer.NUMBER); this.number = n; } // an identifier or label
+ public Expr(int line, int code) { this(line, code, null, null); }
+ public Expr(int line, int code, Expr left) { this(line, code, left, null); }
+ public Expr(int line, int code, Expr left, Expr right) {
+ this.code = code; this.left = left; this.right = right;
+ this.line = line;
+ this.sourceName = Parser.this.sourceName;
+ }
+
+ public double toDouble(Object o) { return toNumber(o).doubleValue(); }
+ public long toLong(Object o) { return toNumber(o).longValue(); }
+ public boolean toBoolean(Object o) {
+ if (o == null) return false;
+ if (o instanceof Boolean) return ((Boolean)o).booleanValue();
+ if (o instanceof Number) return o.equals(new Integer(0));
+ return true;
+ }
+
+ public Object eval(final JS.Scope s) throws ControlTransferException, JS.Exn {
+ switch(code) {
+
+ case Lexer.BITOR: return new Long(toLong(left.eval(s)) | toLong(right.eval(s)));
+ case Lexer.BITXOR: return new Long(toLong(left.eval(s)) ^ toLong(right.eval(s)));
+ case Lexer.BITAND: return new Long(toLong(left.eval(s)) & toLong(right.eval(s)));
+ case Lexer.BITNOT: return new Long(~toLong(left.eval(s)));
+
+ case Lexer.ADD: {
+ Object l = left.eval(s);
+ Object r = right.eval(s);
+ if (l instanceof String || r instanceof String) {
+ if (l == null) l = "null";
+ if (r == null) r = "null";
+ if (l instanceof Number && ((Number)l).doubleValue() == ((Number)l).longValue())
+ l = new Long(((Number)l).longValue());
+ if (r instanceof Number && ((Number)r).doubleValue() == ((Number)r).longValue())
+ r = new Long(((Number)r).longValue());
+ return l.toString() + r.toString();
+ }
+ return new Double(toDouble(l) + toDouble(r));
+ }
+
+ case Lexer.SUB: return new Double(toDouble(left.eval(s)) - toDouble(right.eval(s)));
+ case Lexer.MUL: return new Double(toDouble(left.eval(s)) * toDouble(right.eval(s)));
+ case Lexer.DIV: return new Double(toDouble(left.eval(s)) / toDouble(right.eval(s)));
+ case Lexer.MOD: return new Double(toDouble(left.eval(s)) % toDouble(right.eval(s)));
+
+ case Lexer.LSH: return new Long(toLong(left.eval(s)) << toLong(right.eval(s)));
+ case Lexer.RSH: return new Long(toLong(left.eval(s)) >> toLong(right.eval(s)));
+ case Lexer.URSH: return new Long(toLong(left.eval(s)) >>> toLong(right.eval(s)));
+
+ case Lexer.LT: return toDouble(left.eval(s)) < toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
+ case Lexer.LE: return toDouble(left.eval(s)) <= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
+ case Lexer.GT: return toDouble(left.eval(s)) > toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
+ case Lexer.GE: return toDouble(left.eval(s)) >= toDouble(right.eval(s)) ? Boolean.TRUE : Boolean.FALSE;
+
+ case Lexer.OR: return new Boolean(toBoolean(left.eval(s)) || toBoolean(right.eval(s)));
+ case Lexer.AND: return new Boolean(toBoolean(left.eval(s)) && toBoolean(right.eval(s)));
+ case Lexer.BANG: return new Boolean(!toBoolean(left.eval(s)));
+
+ case Lexer.EQ:
+ case Lexer.NE: {
+ // FIXME: should use Javascript coercion-equality rules
+ Object l = left.eval(s);
+ Object r = right.eval(s);
+ boolean ret = (l == null && r == null) || (l != null && l.equals(r));
+ return new Boolean(code == Lexer.EQ ? ret : !ret);
+ }
+
+ case Lexer.INC:
+ case Lexer.DEC:
+ case Lexer.ASSIGN: {
+ Object v = (code == Lexer.ASSIGN) ? right.eval(s) : new Double(toDouble(left.eval(s)) + (code == Lexer.INC ? 1 : -1));
+ if (left.code == Lexer.DOT) {
+ Object o = left.left.eval(s);
+ if (o instanceof String) {
+ throw new EvaluatorException("can't set properties on a String");
+ } else if (o instanceof Number) {
+ throw new EvaluatorException("can't set properties on a Number");
+ } else if (o instanceof Boolean) {
+ throw new EvaluatorException("can't set properties on a Boolean");
+ } else {
+ JS target = (JS)left.left.eval(s);
+ if (target == null) throw new JS.Exn(new EvaluatorException("attempted to put to the null value"));
+ target.put(left.right.eval(s), v);
+ return v;
+ }
+ } else {
+ s.put(left.string, v);
+ return v;
+ }
+ }
+
+ case Lexer.TYPEOF: {
+ Object o = left.eval(s);
+ if (o == null) return "null";
+ if (o.getClass() == String.class) return "string";
+ if (o.getClass() == Boolean.class) return "boolean";
+ if (o instanceof Number) return "number";
+ if (o instanceof JS.Array) return "array";
+ if (o instanceof JS) return "object";
+ throw new EvaluatorException("typeof " + o.getClass().getName() + " unknown");
+ }
+
+ case Lexer.NUMBER: return number;
+ case Lexer.STRING: return string;
+
+ case Lexer.NULL: return null;
+ case Lexer.FALSE: return Boolean.FALSE;
+ case Lexer.TRUE: return Boolean.TRUE;
+ case Lexer.ASSERT: if (!toBoolean(left.eval(s))) throw new EvaluatorException("assertion failed");
+ case Lexer.THROW: throw new JS.Exn(left.eval(s));
+ case Lexer.NAME: return s.get(string);
+ case Lexer.THIS: return s.isTransparent() ? s : this.eval(s.getParentScope());
+
+ case Lexer.DOT: {
+ final Object o = left.eval(s);
+ Object v = ((right.code == Lexer.NAME) || (right.code == Lexer.STRING)) ? right.string : right.eval(s);
+ if (o instanceof String) {
+ if (v.equals("length")) return new Integer(((String)o).length());
+ else if (v.equals("substring")) return new JS.Function() {
+ public Object _call(JS.Array args) {
+ if (args.length() == 1) return ((String)o).substring(toNumber(args.elementAt(0)).intValue());
+ else if (args.length() == 2) return ((String)o).substring(toNumber(args.elementAt(0)).intValue(),
+ toNumber(args.elementAt(1)).intValue());
+ else throw new EvaluatorException("String.substring() can only take one or two arguments");
+ }
+ };
+ else if (v.equals("indexOf")) return new JS.Function() {
+ public Object _call(JS.Array args) {
+ if (args.length() != 1) return null;
+ return new Integer(((String)o).indexOf(args.elementAt(0).toString()));
+ }
+ };
+ throw new EvaluatorException("Not Implemented: properties on String objects");
+ } else if (o instanceof Boolean) {
+ throw new EvaluatorException("Not Implemented: properties on Boolean objects");
+ } else if (o instanceof Number) {
+ throw new EvaluatorException("Not Implemented: properties on Number objects");
+ } else if (o instanceof JS) {
+ return ((JS)o).get(v);
+ }
+ }
+
+ case Lexer.TRY: {
+ boolean safeToExit = false;
+ try {
+ Object ret = left.eval(s);
+ safeToExit = true;
+ return ret;
+ } catch (JS.Exn e) {
+ Expr c = right;
+ if (c.code == Lexer.CATCH) {
+ JS.Scope scope = new JS.Scope(s);
+ s.put(c.left.string, e);
+ c.right.eval(scope);
+ c = c.next;
+ }
+ if (c.code == Lexer.FINALLY) {
+ JS.Scope scope = new JS.Scope(s);
+ c.left.eval(scope);
+ }
+ } finally {
+ if (!safeToExit) Log.log(this, "WARNING: Java exception penetrated a JavaScript try{} block");
+ }
+ return null;
+ }
+
+ case Lexer.LP:
+ JS.Function f = (JS.Function)left.eval(s);
+ JS.Array arguments = new JS.Array();
+ for(Expr e = right; e != null; e = e.next) arguments.addElement(e.eval(s));
+ if (f == null) throw new JS.Exn(new EvaluatorException("attempted to call null"));
+ return f.call(arguments);
+
+ case Lexer.FUNCTION:
+ return new JS.Function() {
+ public String toString() { return right.sourceName + ":" + right.line; }
+ public String getSourceName() throws JS.Exn { return right.sourceName; }
+ public Object _call(final JS.Array args) throws JS.Exn {
+ Function save = JS.getCurrentFunction();
+ JS.currentFunction.put(Thread.currentThread(), this);
+ JS.Scope scope = new JS.Scope(s) {
+ // FIXME
+ public String getSourceName() { return sourceName; }
+ public boolean isTransparent() { return true; }
+ public Object get(Object key) throws JS.Exn {
+ if (key.equals("trapee")) return org.xwt.Trap.currentTrapee();
+ else if (key.equals("cascade")) return org.xwt.Trap.cascadeFunction;
+ else if (key.equals("arguments")) return args;
+ return super.get(key);
+ }
+ };
+ int i = 0;
+ for(Expr e = left; e != null; e = e.next) scope.put(e.string, args.get(new Integer(i++)));
+ try {
+ return right.eval(scope);
+ } catch (ReturnException r) {
+ return r.retval;
+ } catch (ControlTransferException c) {
+ throw new EvaluatorException("error, ControlTransferException tried to leave a function: "
+ + c);
+ } finally {
+ if (save == null) JS.currentFunction.remove(Thread.currentThread());
+ else JS.currentFunction.put(Thread.currentThread(), save);
+ }
+ }
+ };
+
+ case Lexer.FOR:
+ Object[] keys = ((JS)left.right.eval(s)).keys();
+ for(int i=0; i<keys.length; i++) {
+ JS.Scope scope = new JS.Scope(s);
+ scope.put(left.left.string, keys[i]);
+ try {
+ right.eval(scope);
+ } catch (ContinueException c) {
+ if (c.label == null || c.label.equals(string)) continue;
+ } catch (BreakException b) {
+ if (b.label == null || b.label.equals(string)) return null;
+ throw (BreakException)b.fillInStackTrace();
+ }
+ }
+ return null;
+
+ case Lexer.SWITCH:
+ Object switchVal = left.eval(s);
+ boolean go = false;
+ try {
+ for(Expr e = right; e != null; e = e.next) {
+ if (go || e.code == Lexer.DEFAULT || e.left.eval(s).equals(switchVal)) go = true;
+ if (go) e.right.eval(s);
+ }
+ } catch (BreakException b) {
+ if (b.label == null || b.label.equals(string)) return null;
+ throw (BreakException)b.fillInStackTrace();
+ }
+ return null;
+
+ case Lexer.LB: {
+ JS.Array ret = new JS.Array();
+ for(Expr e = left; e != null; e = e.next) ret.addElement(e.eval(s));
+ return ret;
+ }
+
+ case Lexer.LC: // block
+ for(Expr e = left; e != null; e = e.next) e.eval(s);
+ return null;
+
+ case Lexer.RC: { // Object ctor
+ JS.Obj ret = new JS.Obj();
+ for(Expr e = left; e != null; e = e.next)
+ ret.put(e.left.string, e.right.eval(s));
+ return ret;
+ }
+
+ case Lexer.VAR:
+ for(Expr e = left; e != null; e = e.next)
+ if (e.code == Lexer.NAME) {
+ s.declare(e.string);
+ } else {
+ s.declare(e.left.string);
+ e.eval(s);
+ }
+ return null;
+
+ case Lexer.HOOK: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s);
+ case Lexer.IF: return toBoolean(left.eval(s)) ? right.left.eval(s) : right.right.eval(s);
+ case Lexer.BREAK: throw new BreakException(string);
+ case Lexer.CONTINUE: throw new ContinueException(string);
+ case Lexer.RETURN: throw new ReturnException(left == null ? null : left.eval(s));
+
+ case Lexer.WHILE:
+ case Lexer.DO:
+ try {
+ boolean first = true;
+ while((first && code == Lexer.DO) || toBoolean(left.eval(s))) {
+ first = false;
+ try { right.eval(s);
+ } catch (ContinueException c) {
+ if (c.label == null || c.label.equals(string)) continue;
+ } catch (BreakException b) {
+ if (b.label == null || b.label.equals(string)) return null;
+ throw (BreakException)b.fillInStackTrace();
+ }
+ }
+ } catch (BreakException e) {
+ if (e.label != null && !e.label.equals(string)) throw e;
+ }
+ return null;
+
+ default: throw new EvaluatorException("don't know how to eval an Expr with code " + Lexer.codeToString[code] + "\n" + this);
+ }
+ }
+
+ class EvaluatorException extends RuntimeException {
+ public EvaluatorException(String s) { super(sourceName + ":" + line + " " + s); }
+ }
+ }
+
+ static abstract class ControlTransferException extends Exception { }
+ static class BreakException extends ControlTransferException {
+ public String label;
+ BreakException(String label) { this.label = label; }
+ }
+ static class ContinueException extends ControlTransferException {
+ public String label;
+ ContinueException(String label) { this.label = label; }
+ }
+ static class ReturnException extends ControlTransferException {
+ public Object retval;
+ ReturnException(Object retval) { this.retval = retval; }
+ }
+
+ class ParserException extends RuntimeException {
+ public ParserException(String s) { super(sourceName + ":" + line + " " + s); }
+ }
+
+ public static Number toNumber(Object o) {
+ if (o == null) return new Long(0);
+ if (o instanceof Number) return ((Number)o);
+ if (o instanceof String) return new Double((String)o);
+ if (o instanceof Boolean) return ((Boolean)o).booleanValue() ? new Long(1) : new Long(0);
+ if (o instanceof JS) return ((JS)o).coerceToNumber();
+ // FIXME
+ throw new Error("toNumber() got object of type " + o.getClass().getName());
+ }
+ }
projects / org.ibex.core.git / commitdiff