package org.xwt.js;
import org.xwt.util.*;
-
+
/** The public API for the JS engine */
+// FEATURE: try using mutable, recycled 'Num' objects
public interface JS {
- public Object get(Object key) throws JS.Exn;
- public Object put(Object key, Object val) throws JS.Exn;
- public Object[] enumerateProperties();
- public String coerceToString() throws JS.Exn;
- /*
- public Num coerceToNumber() throws JS.Exn;
- public boolean coerceToBoolean() throws JS.Exn;
- public Object call(Object[] args) throws JS.Exn;
- */
+ 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 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() { }
+ 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 static class Array extends Obj {
+ private Vec vec = new Vec();
+ private static int intVal(Object o) {
+ if (o instanceof Number) {
+ int intVal = ((Number)o).intValue();
+ if (intVal == ((Number)o).doubleValue()) return intVal;
+ return Integer.MIN_VALUE;
+ }
+ if (!(o instanceof String)) return Integer.MIN_VALUE;
+ String s = (String)o;
+ for(int i=0; i<s.length(); i++) if (s.charAt(i) < '0' || s.charAt(i) > '9') return Integer.MIN_VALUE;
+ return Integer.parseInt(s);
+ }
+ public Object get(Object key) {
+ 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());
+ 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 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 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; }
}
-
+
/** Any object which becomes part of the scope chain must support this interface */
- public static interface Scope extends JS {
- public boolean has(Object key);
- public void declare(String s);
- public JS getParentScope();
+ 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 boolean has(Object key) { return super.get(key) != null; }
+ public Object get(Object key) {
+ if (!has(key)) return 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);
+ 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); }
}
- /** A mutable, boxed numeric value. These are recycled -- never duplicate references -- use duplicate() instead. */
- /*
- public static class Num implements Cloneable, JS {
-
- private Num() { }
- public boolean isDouble = false;
- public long longVal = -1;
- public double doubleVal = -1;
-
- private static Vec pool = new Vec();
- public static synchronized void recycle(Num n) { pool.push(n); }
- public static synchronized Num getOne() { return (pool.size() > 0) ? (Num)pool.pop() : new Num(); }
-
- public Num duplicate() { try { return (Num)clone(); } catch (CloneNotSupportedException c) { throw new Error(c); } }
-
- public Object get(Object key) throws JS.Exn { return null; }
- public Object put(Object key, Object val) throws JS.Exn { throw new JS.Exn("attempt to set a property on a Number"); }
- public Object[] enumerateProperties() { return new Object[] { }; }
- public String coerceToString() throws JS.Exn { return isDouble ? String.valueOf(doubleVal) : String.valueOf(longVal); }
- public Num coerceToNumber() throws JS.Exn { return duplicate(); }
- public Object call(Object[] args) throws JS.Exn { throw new JS.Exn("attempt to apply the () operator to a Number"); }
- }
- */
}
+
+
+
+
projects / org.ibex.core.git / blobdiff