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);
}
