private Val atom() { Token t = lex.nextToken(); if (t.type == Token.Type.number) { return new Num((Double) t.value); } else if (t.type == Token.Type.string) { return new Str("" + t.value); } else if (t.type == Token.Type.id) { Val res = env.val(t.value.toString()); if (res.getType() == Val.Type.nil) { res = new Id("" + t.value); Val expr = expr(); env.set(t.value.toString(), expr); } return res; } else if (t.matchOperator("(")) { Val v = expr(); t = lex.nextToken(); if (!t.matchOperator(")")) { throw new EvalException("lexical error: ) was expected"); } return v; } else { lex.returnToken(); return Nil.NIL; } }
/** @see java.io.Externalizable#readExternal(java.io.ObjectInput) */ @SuppressWarnings("unchecked") public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { this.sender = (String) in.readObject(); this.receiver = (String) in.readObject(); // Read the context short nbrVars = in.readShort(); this.context = new HashMap<String, Val>(nbrVars); if (nbrVars > 0) { // Read the info about the first variable String var = (String) in.readObject(); Val val = (Val) in.readObject(); this.context.put(var, val); final boolean externalize = val.externalize(); // Read the remaining variables for (short i = 1; i < nbrVars; i++) { var = (String) in.readObject(); if (externalize) { val = val.getZero(); val.readExternal(in); val = (Val) val.readResolve(); } else val = (Val) in.readObject(); this.context.put(var, val); } } // Read the bounds this.lb = (U) in.readObject(); if (this.lb.externalize()) { this.ub = this.lb.getZero(); this.ub.readExternal(in); this.ub = (U) this.ub.readResolve(); } else this.ub = (U) in.readObject(); }
@Override public Val eval(Environment env) { Val leftValue = left.eval(env); if (leftValue.getBool()) { return leftValue; } else { return right.eval(env); } }
protected Object eval(Object candidate, Object orig, StoreContext ctx, Object[] params) { Object str = _val.eval(candidate, orig, ctx, params); StringBuilder cat = new StringBuilder(str.toString()); Object arg = _args.eval(candidate, orig, ctx, params); if (arg instanceof Object[]) { for (int i = 0; i < ((Object[]) arg).length; i++) cat.append((((Object[]) arg)[i]).toString()); } else cat.append(arg.toString()); return cat.toString(); }
private Val moreFactors(Val val) { Token t = lex.nextToken(); if (t.matchOperator("*")) { return new Num(val.evalNum(env) * levelFactor().evalNum(env)); } else if (t.matchOperator("/")) { return new Num(val.evalNum(env) / levelFactor().evalNum(env)); } else if (t.matchOperator("%")) { return new Num(val.evalNum(env) % levelFactor().evalNum(env)); } else { lex.returnToken(); return val; } }
Val Eval(HashMap<String, Val> state) { // Make it work like a like list. ExpList t = expList; Val i = null; if (t != null) { i = t.exp.Eval(state); t = t.expList; if (i.getClass() == ErrVal.class) { return i; } if (i.getClass() == BoolVal.class) { return new ErrVal(">= operator cannot be applied to non-number: " + i.toString()); } } while (t != null) { Val e = t.exp.Eval(state); Class eClass = e.getClass(); Class iClass = i.getClass(); if (i.getClass() == ErrVal.class) { return i; } if (e.getClass() == BoolVal.class) { return new ErrVal(">= operator cannot be applied to non-number: " + e.toString()); } if (iClass == IntVal.class && eClass == IntVal.class) { if (((IntVal) i).val <= ((IntVal) e).val) { return new BoolVal(false); } } else if (iClass == IntVal.class) // eClass == FloatVal.class { if (((IntVal) i).val <= ((FloatVal) e).val) { return new BoolVal(false); } } else // termClass == FloatVal.class { if (((FloatVal) i).val <= ((FloatVal) e).val) { return new BoolVal(false); } } t = t.expList; e = i; } return new BoolVal(true); }
private Val moreTerms(Val val) { Token t = lex.nextToken(); if (t.matchOperator("+")) { Val rVal = levelFactor(); Val eval; if (val.getType() == Val.Type.string) { eval = new Str(val.evalStr(env) + rVal.evalStr(env)); } else { eval = new Num(val.evalNum(env) + rVal.evalNum(env)); } return moreTerms(eval); } else if (t.matchOperator("-")) { Val rVal = levelFactor(); Val eval = new Num(val.evalNum(env) - rVal.evalNum(env)); return moreTerms(eval); } else { lex.returnToken(); return val; } }
private Val moreCond(Val val) { Token t = lex.nextToken(); if (t.matchOperator("?")) { Val trueNode = expr(); Token delim = lex.nextToken(); if (delim.matchOperator("!")) { Val falseNode = expr(); if (val.evalNum(env) > 0) { return trueNode; } else { return falseNode; } } else { throw new EvalException("Unrecognized ternary operation " + lex.getLastLine()); } } else { lex.returnToken(); return val; } }
private Val moreComp(Val val) { Token t = lex.nextToken(); if (t.matchOperator("<")) { Val rVal = moreComp(levelTerm()); return val.evalNum(env) < rVal.evalNum(env) ? new Num(1d) : new Num(0d); } else if (t.matchOperator(">")) { Val rVal = moreComp(levelTerm()); return val.evalNum(env) > rVal.evalNum(env) ? new Num(1d) : new Num(0d); } else if (t.matchOperator(">=")) { Val rVal = moreComp(levelTerm()); return val.evalNum(env) >= rVal.evalNum(env) ? new Num(1d) : new Num(0d); } else if (t.matchOperator("<=")) { Val rVal = moreComp(levelTerm()); return val.evalNum(env) <= rVal.evalNum(env) ? new Num(1d) : new Num(0d); } else if (t.matchOperator("=")) { Val rVal = moreComp(levelTerm()); return val.evalNum(env).equals(rVal.evalNum(env)) ? new Num(1d) : new Num(0d); } else if (t.matchOperator("<>")) { Val rVal = moreComp(levelTerm()); return !val.evalNum(env).equals(rVal.evalNum(env)) ? new Num(1d) : new Num(0d); } else { lex.returnToken(); return val; } }
public void acceptVisit(ExpressionVisitor visitor) { visitor.enter(this); _val.acceptVisit(visitor); visitor.exit(this); }
public Class getType() { if (_cast != null) return _cast; return _map.getType(); }
public void calculateValue( Select sel, ExpContext ctx, ExpState state, Val other, ExpState otherState) { GetMapValueExpState gstate = (GetMapValueExpState) state; _map.calculateValue(sel, ctx, gstate.mapState, null, null); _key.calculateValue(sel, ctx, gstate.keyState, null, null); }
public void selectColumns(Select sel, ExpContext ctx, ExpState state, boolean pks) { GetMapValueExpState gstate = (GetMapValueExpState) state; _map.selectColumns(sel, ctx, gstate.mapState, true); _key.selectColumns(sel, ctx, gstate.keyState, true); }
@Override public boolean eq(Val v, Frame frame) { return v.getType() == Type.nil; }
protected boolean eval(Object candidate, Object orig, StoreContext ctx, Object[] params) { Object o = _val.eval(candidate, orig, ctx, params); return o != null && ((Boolean) o).booleanValue(); }
protected boolean eval(Collection candidates, StoreContext ctx, Object[] params) { Collection c = _val.eval(candidates, null, ctx, params); Object o = (c == null || c.isEmpty()) ? null : c.iterator().next(); return o != null && ((Boolean) o).booleanValue(); }
public ExpState initialize(Select sel, ExpContext ctx, int flags) { ExpState mapState = _map.initialize(sel, ctx, 0); ExpState keyState = _key.initialize(sel, ctx, 0); return new GetMapValueExpState(sel.and(mapState.joins, keyState.joins), mapState, keyState); }
public Object toDataStoreValue(Select sel, ExpContext ctx, ExpState state, Object val) { GetMapValueExpState gstate = (GetMapValueExpState) state; return _map.toDataStoreValue(sel, ctx, gstate.mapState, val); }
protected Object eval(Object candidate, Object orig, StoreContext ctx, Object[] params) { return ((Map) _map.eval(candidate, orig, ctx, params)) .get(_arg.eval(candidate, orig, ctx, params)); }