public override object Evaluate(Environment env) { object value; if (Operand is PrimaryNode) value = ((PrimaryNode)Operand).Evaluate(env, AssignType); else value = Operand.Evaluate(env); if (Prefix is NullNode || IsDirectPrimary) return value; else { string prefix = ((AstLeaf)Prefix).Token.Text; if (value is int) { int tmp = (int)value; switch (prefix) { case "+": return tmp; case "-": return -tmp; case "!": return tmp == 0 ? 1 : 0; case "~": return ~tmp; default: throw new LepException("bad prefix: " + prefix, this); } } else throw new LepException("bad type for " + prefix, this); } }
public override object Evaluate(Environment env) { object result = 0; bool flag = true; while (flag) { try { GuardValue guard = ((GuardNode)this[0]).Test(env); flag = guard.GuardExpression; if (flag) result = guard.GuardBody; } catch (JumpSignal signal) { switch (signal.SignalType) { case JumpSignal.BreakSignal: return result; case JumpSignal.ContinueSignal: break; default: throw; } } } return result; }
public override object Evaluate(Environment env) { Tuple tuple = new Tuple(Count); int count = 0; foreach (IAstNode node in this) tuple[count++] = node.Evaluate(env); return tuple; }
public GuardValue Test(Environment env, object prefix) { Environment inner = new Environment(env); if (Condition is FactorNode && ((FactorNode)Condition).IsNoPrefixPrimary && ((PrimaryNode)((FactorNode)Condition).Operand).IsName && ((NameNode)(((PrimaryNode)((FactorNode)Condition).Operand).Operand)).Token.Text == "*") return new GuardValue(true, Evaluate(inner)); object guard = Condition.Evaluate(inner); if (prefix != null && prefix.Equals(guard) || prefix == null && IsTrue(guard)) return new GuardValue(true, Evaluate(inner)); else return new GuardValue(false, 0); }
public override object Evaluate(Environment env) { object result = 0; foreach (IAstNode node in this) if (!(node is NullNode)) { try { result = node.Evaluate(env); } catch (JumpSignal signal) { if ((signal.SignalType == JumpSignal.BreakSignal || signal.SignalType == JumpSignal.ReturnSignal) && signal.ReturnValue == null) throw new JumpSignal(signal.SignalType, result); else throw; } } return result; }
public override object Evaluate(Environment env) { object result = 0; foreach (IAstNode node in this) { GuardNode guard = (GuardNode)node; GuardValue guardResult = guard.Test(env); if (guardResult.GuardExpression) { result = guardResult.GuardBody; if (((AstLeaf)((BlockNode)guard.Body).Ending).Token.Text == ".") break; } } return result; }
public override object Evaluate(Environment env) { Environment inner = new Environment(env); object expression = Expression.Evaluate(inner), result = 0; foreach (IAstNode node in Guards) { GuardNode guard = (GuardNode)node; GuardValue guardResult = (guard).Test(env, expression); if (guardResult.GuardExpression) { result = guardResult.GuardBody; if (((AstLeaf)((BlockNode)guard.Body).Ending).Token.Text == ".") break; } } return result; }
public override object Evaluate(Environment env) { int type; switch (((AstLeaf)Control).Token.Text) { case "!": type = JumpSignal.BreakSignal; break; case ":!": type = JumpSignal.ContinueSignal; break; case "!!": type = JumpSignal.ReturnSignal; break; default: throw new LepException("bad control statement", this); } throw new JumpSignal(type, null); }
public object Evaluate(Environment env, object target) { object[] arr = target as object[]; if (arr != null) { object index = Index.Evaluate(env); if (index is int) return arr[(int)index]; } Dictionary<object, object> table = target as Dictionary<object, object>; if (table != null) { object value; table.TryGetValue(Index.Evaluate(env), out value); if (value != null) return value; } throw new LepException("bad array access", this); }
public override object Evaluate(Environment env) { int total; if (ArrayLength is NullNode) total = Count - 1; else { object value = ArrayLength.Evaluate(env); if (value is int && (int)value < Count - 1) total = (int)value; else throw new LepException("bad array length", this); } object[] array = new object[total]; for (int i = 0; i < total; i++) { if (i >= Count - 1) array[i] = 0; else array[i] = this[i + 1].Evaluate(env); } return array; }
public object EvaluateSub(Environment env, int layer, int type) { if (HasSuffix(layer)) { if (layer > 65535) throw new LepException("too much suffix", this); object target = EvaluateSub(env, layer + 1, type); IAstNode current = Suffix(layer); ArgumentNode arg = current as ArgumentNode; if (arg != null) return arg.Evaluate(env, target); ExpressionArgumentNode exprArg = current as ExpressionArgumentNode; if (exprArg != null) return exprArg.Evaluate(env, target); ArrayReferenceNode arrRef = current as ArrayReferenceNode; if (arrRef != null) return arrRef.Evaluate(env, target); throw new LepException("bad suffix", this); } else if (Operand is NameNode) return ((NameNode)Operand).Evaluate(env, type); else return Operand.Evaluate(env); }
public virtual object Evaluate(Environment env) { throw new LepException("cannot evaluate: " + ToString(), this); }
public GuardValue Test(Environment env) { return Test(env, null); }
public override object Evaluate(Environment env) { return Body.Evaluate(env); }
public object Evaluate(Environment env, int type) { return EvaluateSub(env, 0, type); }
public override object Evaluate(Environment env) { return EvaluateSub(env, 0, Environment.NormalVariable); }