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