public override LispNode Evaluate(Env env)
{
LispNode func = null;
LambdaNode lambdaNode = null;
func = What.Evaluate(env);
if (!(func is LambdaNode))
{
return(null);
}
lambdaNode = func as LambdaNode;
if (lambdaNode.Arguments.Count != Arguments.Count)
{
return(null);
}
Env newEnv = new Env(lambdaNode.Env); // use the lambda env, not the global env, for lexical closures
for (int i = 0; i < Arguments.Count; i++)
{
newEnv.Add(lambdaNode.Arguments[i], Arguments[i].Evaluate(env));
}
return(lambdaNode.Call(newEnv));
}
public override LispNode Evaluate(Env env)
{
if (env.Find(VariableName) == null)
{
return(null);
}
LispNode exp = Expression.Evaluate(env);
env.Set(VariableName, exp);
return(exp); // probably not ideomatic scheme but we can chain set!s.
}
public LispNode a, b, c; // if a then b else c
public override LispNode Evaluate(Env env)
{
object test = a.Evaluate(env);
if (!(test is BoolNode))
{
return(null);
}
else if ((test as BoolNode).Value)
{
return(b.Evaluate(env));
}
else
{
return(c.Evaluate(env));
}
}
public object Execute(String exp)
{
LispNode program = Read(TokenizeStream(exp));
Env env = CreateGlobals();
LispNode result = program.Evaluate(env);
if (result is IntNode)
{
return((result as IntNode).Value);
}
else if (result is BoolNode)
{
return((result as BoolNode).Value);
}
else if (result is QuoteNode)
{
return((result as QuoteNode).Value);
}
else
{
return(null);
}
}
public virtual LispNode Call(Env env)
{
return(Body.Evaluate(env));
}
public override LispNode Evaluate(Env env)
{
env.Add(Name, Expression.Evaluate(env));
return(this); // return this???
}
