public Node TryEval(Node node, Env env, Logger logger)
{
int numberOfParameters = ListOps.CalculateListLength(node);
if (numberOfParameters < 3 || numberOfParameters > 4)
{
string errorMsg = "Wrong number of parameters for if: " + ListOps.CalculateListLength(node);
return(new Node(StdNodeTypes.Error, errorMsg));
}
Node condition = NodeOps.GetChild(node, 1);
logger.LogVerbose("if: comparsion: " + NodeOps.Serialize(condition));
Node compareResult = Evaluator.Evaluate(condition, env);
string compare = compareResult.Content.ToString();
logger.LogVerbose("if: compare result: " + NodeOps.Serialize(compareResult));
if ("True".Equals(compare))
{
return(Evaluator.Evaluate(NodeOps.GetChild(node, 2), env));
}
// If we have an else part...
if (numberOfParameters == 4)
{
return(Evaluator.Evaluate(NodeOps.GetChild(node, 3), env));
}
return(Node.NIL);
}
private static Node EvaluateEnvFunction(Node functionNode, Node node, Env env, Logger logger)
{
logger.LogVerbose("Trying to evaluate: " + NodeOps.Serialize(node));
Node parameterNames = functionNode.Head;
Node errorNode = CreateParameterizedEnv(parameterNames, node, env, logger, out Env localEnv);
if (errorNode != Node.NIL)
{
return(errorNode);
}
Node functionBody = functionNode.Tail;
logger.LogVerbose("Starting functionBody evaluation: " + NodeOps.Serialize(functionBody));
// Evaluate function.
Node result = Evaluator.Evaluate(functionBody, localEnv);
logger.LogVerbose("Evaluation result: " + result);
// Discard child env.
localEnv.CloseEnv();
// Return function result.
return(result);
}
public Node TryEval(Node node, Env env, Logger logger)
{
// What all functions do.
Node firstEvaluationResult = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
logger.LogVerbose("EvalFun: After first eval: " + NodeOps.Serialize(firstEvaluationResult));
logger.LogVerbose("EvalFun: After first eval: Type:" + firstEvaluationResult.NodeType);
int listLength = ListOps.CalculateListLength(node);
logger.LogVerbose("EvalFun: Eval number of parameters: " + listLength);
// Create copy so we don't change the original data.
firstEvaluationResult = NodeOps.CloneTree(firstEvaluationResult);
for (int i = 2; i < listLength; i++)
{
Node additional = Evaluator.Evaluate(NodeOps.GetChild(node, i), env);
logger.LogVerbose("EvalFun: Additional value: " + NodeOps.Serialize(additional));
ListOps.AppendToList(additional, firstEvaluationResult);
}
// What eval does.
Node evalResult = Evaluator.Evaluate(firstEvaluationResult, env);
logger.LogVerbose("EvalFun: After second eval: " + NodeOps.Serialize(evalResult));
return(evalResult);
}
public void TestStringEvaluation()
{
string expr = "Test";
Node node = new Node(StdNodeTypes.String, expr);
Node nodeResult = Evaluator.Evaluate(node, env);
string result = NodeOps.Serialize(nodeResult);
Assert.AreEqual("\"Test\"", result);
}
public static string Evaluate(string line, TraceLevel traceLevel = TraceLevel.Error, Env env = null, bool traceStdLib = false)
{
Node node = Parse(line);
if (node == null)
{
return(null);
}
if (traceLevel == TraceLevel.Verbose)
{
Console.WriteLine("Parsed input:");
Console.WriteLine(NodeOps.Serialize(node));
}
if (traceStdLib)
{
Evaluator.Logger.TraceLevel = traceLevel;
}
else
{
Evaluator.Logger.TraceLevel = TraceLevel.Error;
}
if (env == null)
{
env = EnvOps.CreateStdLibEnv();
}
Evaluator.Logger.TraceLevel = traceLevel;
node = ExpandMacros(node, env);
if (traceLevel == TraceLevel.Verbose)
{
Console.WriteLine("Expanded input:");
Console.WriteLine(NodeOps.Serialize(node));
}
Node resultNode = Evaluator.Evaluate(node, env);
if (traceLevel == TraceLevel.Verbose)
{
Console.WriteLine("Evaluated input:");
Console.WriteLine(NodeOps.Serialize(resultNode));
}
string result = NodeOps.Serialize(resultNode);
return(result);
}
public void TestLambdaApplicationEvaluation()
{
string expr = "(eval (list (lambda (x) (+ 1 x)) 3))";
Node parseTree = HighLevel.Parse(expr);
Node nodeResult = Evaluator.Evaluate(parseTree, env);
Assert.IsNotNull(nodeResult);
Assert.AreEqual(StdNodeTypes.Identifier, nodeResult.NodeType);
string result = NodeOps.Serialize(nodeResult);
Assert.AreEqual("4", result);
}
public void TestSimpleParse()
{
string line = "(seq (defmacro inc (x) (+ x 1)) (inc 2))";
Node node = HighLevel.Parse(line);
Assert.IsNotNull(node);
Env env = new Env(null);
node = MacroExpander.ExpandMacros(node, env);
string serialization = NodeOps.Serialize(node);
Assert.AreEqual("(seq (+ 2 1))", serialization);
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("print", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node parameter = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
string result = NodeOps.Serialize(parameter);
Console.WriteLine(result);
return(Node.NIL);
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("tail", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node list = Evaluator.Evaluate(node.Tail.Head, env);
if (list == Node.NIL)
{
return(Node.NIL);
}
if (!StdNodeTypes.Cons.Equals(list.NodeType))
{
string errorMsg = "Invalid parameter type for tail: " + list.NodeType + " (should be Cons): " + NodeOps.Serialize(list);
return(new Node(StdNodeTypes.Error, errorMsg));
}
return(list.Tail);
}
