public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("read-dict", node, 2);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node dictNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
Node key = Evaluator.Evaluate(NodeOps.GetChild(node, 2), env);
if (StdNodeTypes.Dict.Equals(dictNode.NodeType))
{
if (dictNode.Content is Dictionary <string, Node> dict)
{
if (dict.TryGetValue(key.Content.ToString(), out Node value))
{
return(value);
}
}
}
return(new Node(StdNodeTypes.Error, "Malformed call to read-dict: " + dictNode + ", " + key));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("quote", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
return(NodeOps.GetChild(node, 1));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("create-dict", node, 0);
if (checkResult != Node.NIL)
{
return(checkResult);
}
return(new Node(StdNodeTypes.Dict, new Dictionary <string, Node>()));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("type?", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node param = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
return(new Node(StdNodeTypes.Identifier, param.NodeType));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("cons", node, 2);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node head = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
Node tail = Evaluator.Evaluate(NodeOps.GetChild(node, 2), env);
Node cons = new Node(StdNodeTypes.Cons, head, tail, null);
return(cons);
}
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("=", node, 2);
if (checkResult != Node.NIL)
{
return(checkResult);
}
string val1 = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env).Content.ToString();
string val2 = Evaluator.Evaluate(NodeOps.GetChild(node, 2), env).Content.ToString();
if (val1.Equals(val2))
{
return(Node.TRUE);
}
return(Node.FALSE);
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("save-file", node, 2);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node fileNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
string file = fileNode.Content.ToString();
Node contentNode = Evaluator.Evaluate(NodeOps.GetChild(node, 2), env);
string content = contentNode.Content.ToString();
File.WriteAllText(file, content);
return(Node.NIL);
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("keys-dict", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node dictNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
if (StdNodeTypes.Dict.Equals(dictNode.NodeType))
{
if (dictNode.Content is Dictionary <string, Node> dict)
{
Node list = null;
Node listStart = null;
foreach (string key in dict.Keys)
{
Node keyNode = new Node(StdNodeTypes.String, key);
Node newCons = new Node(StdNodeTypes.Cons, null);
newCons.Head = keyNode;
if (listStart == null)
{
listStart = newCons;
}
else
{
list.Tail = newCons;
}
list = newCons;
}
return(listStart);
}
}
return(new Node(StdNodeTypes.Error, "Malformed call to keys-dict: " + dictNode));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("int-to-char", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node intNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
if (int.TryParse(intNode.Content.ToString(), out int result))
{
string c = char.ConvertFromUtf32(result);
return(new Node(StdNodeTypes.String, c));
}
string errorMsg = "Invalid parameter to IntToCharFun";
return(new Node(StdNodeTypes.Error, errorMsg));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("load-file", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node fileNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
string file = fileNode.Content.ToString();
if (File.Exists(file))
{
string input = File.ReadAllText(file);
return(new Node(StdNodeTypes.String, input));
}
return(new Node(StdNodeTypes.String, "File not found"));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("string-length", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node strNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
if (!StdNodeTypes.String.Equals(strNode.NodeType))
{
return(Node.NIL);
}
string str = strNode.Content.ToString();
string result = str.Length.ToString(CultureInfo.InvariantCulture);
return(new Node(StdNodeTypes.Identifier, result));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("char-to-int", node, 1);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node charNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
if (charNode.Content.ToString().Length != 1)
{
string errorMsg = "Invalid parameter to CharToIntFun";
return(new Node(StdNodeTypes.Error, errorMsg));
}
int c = char.ConvertToUtf32(charNode.Content.ToString(), 0);
return(new Node(StdNodeTypes.String, c.ToString(CultureInfo.InvariantCulture)));
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters(">", node, 2);
if (checkResult != Node.NIL)
{
return(checkResult);
}
string val1String = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env).Content.ToString();
string val2String = Evaluator.Evaluate(NodeOps.GetChild(node, 2), env).Content.ToString();
double val1 = double.Parse(val1String, CultureInfo.InvariantCulture);
double val2 = double.Parse(val2String, CultureInfo.InvariantCulture);
if (val1 > val2)
{
return(Node.TRUE);
}
return(Node.FALSE);
}
public Node TryEval(Node node, Env env, Logger logger)
{
Node checkResult = BuiltinOps.CheckParameters("char-at", node, 2);
if (checkResult != Node.NIL)
{
return(checkResult);
}
Node strNode = Evaluator.Evaluate(NodeOps.GetChild(node, 1), env);
if (!StdNodeTypes.String.Equals(strNode.NodeType))
{
return(Node.NIL);
}
Node indexNode = Evaluator.Evaluate(NodeOps.GetChild(node, 2), env);
int index = int.Parse(indexNode.Content.ToString(), CultureInfo.InvariantCulture);
string result = strNode.Content.ToString().Substring(index, 1);
return(new Node(StdNodeTypes.String, result));
}
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);
}
