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) throws JS.Exn {
+ // we use _get instead of get solely to work around a GCJ bug
+ public Object _get(Object key) throws JS.Exn {
// FIXME: HACK!
if (key.equals("cascade")) return org.xwt.Trap.cascadeFunction;
if (key.equals("trapee")) return org.xwt.Trap.currentTrapee();
return null;
}
}
+ // we use _put instead of put solely to work around a GCJ bug
public void put(Object key, Object val) {
if (key.equals("length")) vec.setSize(toNumber(val).intValue());
int i = intVal(key);
public Object elementAt(int i) { return super.elementAt(i); }
public void addElement(Object o) { super.addElement(o); }
public void setElementAt(Object o, int i) { super.setElementAt(o, i); }
- public Object get(Object key) { return super.get(key); }
- public void put(Object key, Object val) { super.put(key, val); }
+ public Object get(Object key) { return super._get(key); }
+ public void put(Object key, Object val) { super._put(key, val); }
}
/** Any object which becomes part of the scope chain must support this interface */
/** transparent scopes are not returned by THIS */
public boolean isTransparent() { return super.isTransparent(); }
public boolean has(Object key) { return super.has(key); }
- public Object get(Object key) { return super.get(key); }
- public void put(Object key, Object val) { super.put(key, val); }
+ public Object get(Object key) { return super._get(key); }
+ public void put(Object key, Object val) { super._put(key, val); }
public void declare(String s) { super.declare(s); }
}
/** gets a token and throws an exception if it is not <tt>code</tt> */
private void consume(int code) throws IOException {
- if (getToken() != code) throw new ParserException("expected " + codeToString[code] + ", got " + (op == -1 ? "EOF" : codeToString[op]));
+ if (getToken() != code) throw pe("expected " + codeToString[code] + ", got " + (op == -1 ? "EOF" : codeToString[op]));
}
/**
CompiledFunctionImpl b = appendTo;
switch (tok) {
- case -1: throw new ParserException("expected expression");
+ case -1: throw pe("expected expression");
// all of these simply push values onto the stack
case NUMBER: b.add(parserLine, LITERAL, number); break;
case INC: case DEC: { // prefix (not postfix)
startExpr(b, precedence[tok]);
if (b.get(b.size() - 1) != GET)
- throw new ParserException("prefixed increment/decrement can only be performed on a valid assignment target");
+ throw pe("prefixed increment/decrement can only be performed on a valid assignment target");
b.set(b.size() - 1, tok, new Boolean(true));
break;
}
if (peekToken() != RC)
while(true) {
if (peekToken() != NAME && peekToken() != STRING)
- throw new ParserException("expected NAME or STRING");
+ throw pe("expected NAME or STRING");
getToken();
b.add(parserLine, LITERAL, string); // grab the key
consume(COLON);
break;
}
- default: throw new ParserException("expected expression, found " + codeToString[tok] + ", which cannot start an expression");
+ default: throw pe("expected expression, found " + codeToString[tok] + ", which cannot start an expression");
}
// attempt to continue the expression
b.add(parserLine, BREAK); // break out of the loop if we 'fall through'
break;
} else {
- throw new ParserException("expected CASE, DEFAULT, or RC; got " + codeToString[peekToken()]);
+ throw pe("expected CASE, DEFAULT, or RC; got " + codeToString[peekToken()]);
}
b.set(size0 - 1, new Integer(b.size() - size0 + 1)); // end of the loop
break;
// ParserException //////////////////////////////////////////////////////////////////////
-
- private class ParserException extends IOException { public ParserException(String s) { super(sourceName + ":" + parserLine + " " + s); } }
+ private IOException pe(String s) { return new IOException(sourceName + ":" + parserLine + " " + s); }
}
}
public Object[] keys() { throw new Error("you can't enumerate the properties of a Scope"); }
public boolean has(Object key) { return super.get(key) != null; }
- public Object get(Object key) {
+ // we use _get instead of get solely to work around a GCJ bug
+ public Object _get(Object key) {
if (!has(key)) return parentScope == null ? null : parentScope.get(key);
Object ret = super.get(key); return ret == NULL ? null : ret;
}
- public void put(Object key, Object val) {
+ // we use _put instead of put solely to work around a GCJ bug
+ public void _put(Object key, Object val) {
if (!has(key) && parentScope != null) parentScope.put(key, val);
else super.put(key, val == null ? NULL : val);
}