//syntax: if <test> <consequent> <alternate>
//syntax: if <test> <consequent>
public override Node eval(Node exp, Environment env)
{
var length = Node.length(exp);
if (length < 3 || length > 4)
{
Console.Error.WriteLine("Error: Invalid length for if expression");
return(Nil.getInstance());
}
var test = exp.getCdr().getCar();
var consequent = exp.getCdr().getCdr().getCar();
var alternate = new Node();
if (length == 4) //has alternates
{
alternate = exp.getCdr().getCdr().getCdr().getCar();
}
else //If <test> yields a false value and no <alternate> is specified, then the result of the expression is unspecified.
{
alternate = Unspecific.getInstance();
}
if (test.eval(env) != BoolLit.getInstance(false))
{
return(consequent.eval(env));
}
return(alternate.eval(env));
}
public override Node eval(Node exp, Environment env)
{
if (Node.length(exp) <= 2)
{
Console.Error.WriteLine("Error: invalid let expression");
return(Nil.getInstance());
}
var car = exp.getCdr().getCar();
var cdr = exp.getCdr().getCdr();
if (Node.length(car) <= 0)
{
Console.Error.WriteLine("Error: invalid let expression");
return(Nil.getInstance());
}
var env2 = new Environment(env);
if (initialize(car, env, env2) < 0)
{
Console.Error.WriteLine("Error: invalid let expression");
return(Nil.getInstance());
}
return(evalBody(cdr, env2));
}
public Node eval(Node a, Environment e)
{
Node node = new Cons(new Ident(a.getName()), Nil.getInstance());
Node argument = evalAll(node, e);
if (!argument.getCar().isPair())
{
if (Enviornment.errorMessages.size() == 0)
{
Console.Error.WriteLine("Error: should not be a pair.");
}
else if (argument.getCar().isNumber())
{
return(new IntLit(argument.getCar().getVal()));
}
else if (argument.getCar().isString())
{
return(new StringLit(argument.getCar().getStringVal()));
}
else if (argument.getCar().isBool())
{
return(new boolLit(argument.getCar().getBool()));
}
else
{
Console.Write("just chilling here for the time being.");
return(Nil.getInstance());
}
}
else
{
reutn null;
}
return(new stringLit(""));
}
// to evaluate expressions of the form '(if b t e)',
// evaluate b, then if b is not the boolean constant #f,
// evaluate t and return the result. otherwise, evaluate
// e and return the result.
public override Node eval(Node t, Environment env)
{
// if cdr is nil, return nil (error state)
if (t.getCdr() == Nil.getInstance())
{
Console.Error.WriteLine("Special form 'If' evaluated with no arguments");
return(Nil.getInstance());
}
// get cdr of expression (conditional and execution statements)
t = t.getCdr();
// if cdr of t is nil, expression has a conditional but no executable statements (error state)
if (t.getCdr() == Nil.getInstance())
{
Console.Error.WriteLine("Special form 'If' evaluated with insufficient arguments");
return(Nil.getInstance());
}
// evaluate car of b (conditional). if b is not #f, evaluate and return t.
if (t.getCar().eval(env) != BoolLit.getInstance(false))
{
return(t.getCdr().getCar().eval(env));
}
else
{
// otherwise, b is #f. evaluate and return e.
// if e is nil, statement is still valid. interpreter will parse and return nil.
return(t.getCdr().getCdr().getCar().eval(env));
}
}
public Node evalFrame(Node a, Environment e)
{
if (a == null || a.isNull())
{
return(new Cons(Nil.getInstance(), Nil.getInstance()));
}
else
{
Node argument = a.getCar().getCar();
Node expression = a.getCar().getCdr().getCar();
Node errThangElse = a.getCdr();
if (argument.isSymbol())
{
environment.define(argument, expression.eval(e));
return(evalFrame(errThangElse, e));
}
else if (argument.isPair())
{
return(argument.eval(e));
}
else if (argument == null || argument.isNull)
{
return(Nil.getInstance());
}
}
return(null);
}
private Node apply0()
{
string name = symbol.getName();
if (name.Equals("read"))
{
var parser = new Parser(new Scanner(Console.In), new TreeBuilder());
var exp = (Node)parser.parseExp();
if (exp != null)
{
return(exp);
}
return(new Ident("end-of-file"));
}
if (name.Equals("newline"))
{
Console.WriteLine();
return(Unspecific.getInstance());
}
if (name.Equals("interaction-environment"))
{
return(Scheme4101.env);
}
Console.Error.WriteLine("Error: wrong number of arguments");
return(Nil.getInstance());
}
public void define(Node id, Node val)
{
Node temp = find(id, this.frame);
Node node = new Cons(id, new Cons(val, Nil.getInstance()));
this.frame = new Cons(node, this.frame);
}
private Node evalArithmetic(int arg1, int arg2)
{
string name = symbol.getName();
if (name.Equals("b+"))
{
return(new IntLit(arg1 + arg2));
}
if (name.Equals("b-"))
{
return(new IntLit(arg1 - arg2));
}
if (name.Equals("b*"))
{
return(new IntLit(arg1 * arg2));
}
if (name.Equals("b/"))
{
return(new IntLit(arg1 / arg2));
}
if (name.Equals("b="))
{
return(BoolLit.getInstance(arg1 == arg2));
}
if (name.Equals("b<"))
{
return(BoolLit.getInstance(arg1 < arg2));
}
Console.Error.WriteLine("Error: unknown arithmetic symbol");
return(Nil.getInstance());
}
public Node evalBody(Node t, Environment env)
{
if (t.isNull())
{
return(Nil.getInstance());
}
else
{
Node arg = t.getCar().getCar();
Node func = t.getCar().getCdr().getCar();
Node rest = t.getCdr();
if (arg.isSymbol())
{
env.define(arg, func.eval(env));
return(evalBody(rest, env));
}
else if (arg.isPair())
{
return(arg.eval(env));
}
else if (arg.isNull())
{
return(Nil.getInstance());
}
return(null);
}
}
public Node makeCons(Node exp, Environment env)
{
if (exp.isNull())
{
return(Nil.getInstance());
}
return(new Cons(exp.getCar().eval(env), makeCons(exp.getCdr(), env)));
}
public override Node eval(Node exp, Environment env)
{
if (!exp.isNull())
{
return(exp.getCar().eval(env).apply(makeCons(exp.getCdr(), env)));
}
Console.Error.WriteLine("Error: invalid expression");
return(Nil.getInstance());
}
public override Node eval(Node exp, Environment env)
{
int numArgs = 0;
Node expCdr = exp.getCdr();
while (!expCdr.isNull())
{
numArgs++;
expCdr = expCdr.getCdr();
}
if (numArgs < 2)
{
Console.Error.WriteLine("Error: invalid expression");
return(Nil.getInstance());
}
Node bindings = exp.getCdr().getCar();
Node body = exp.getCdr().getCdr();
Node cdr = exp.getCdr().getCar();
Node car;
int numBindings = 0;
while (!cdr.isNull())
{
car = cdr.getCar();
//bindings have proper format
if (!car.isPair())
{
Console.Error.WriteLine("Error: invalid expression");
return(Nil.getInstance());
}
numBindings++;
cdr = cdr.getCdr();
}
//at least one binding
if (numBindings == 0)
{
Console.Error.WriteLine("Error: invalid expression");
return(Nil.getInstance());
}
Environment letEnv = new Environment(env);
if (define(bindings, env, letEnv) == 0)
{
Node bcar = body.getCar().eval(letEnv);
Node bcdr = body.getCdr();
while (!bcdr.isNull())
{
bcar = bcdr.getCar().eval(letEnv);
bcdr = bcdr.getCdr();
}
return(bcar);
}
Console.Error.WriteLine("Error: invalid expression");
return(Nil.getInstance());
}
public Node eval(Node t, Environment e)
{
Node cdr = t.getCdr();
if (cdr == null)
{
Console.Error.WriteLine("Error: Cond is null");
}
return(Nil.getInstance());
}
private Node buildArgsList(Node exp, Environment env)
{
if (!exp.isNull())
{
var car = exp.getCar();
var cdr = exp.getCdr();
return(new Cons(car.eval(env), buildArgsList(cdr, env)));
}
return(Nil.getInstance());
}
public override Node eval(Node t, Environment env)
{
if (env.lookup(this) != null)
{
return(env.lookup(this).eval(env));
}
else
{
return(Nil.getInstance());
}
}
public override Node eval(Node exp, Environment env)
{
if (Node.length(exp) < 2)
{
Console.Error.WriteLine("Error: invalid cond expression");
return(Nil.getInstance());
}
var exps = exp.getCdr();
return(evalClauses(exps, env));
}
public override Node eval(Node exp, Environment env)
{
if (Node.length(exp) < 1)
{
Console.Error.WriteLine("Error: invalid regular expression");
return(Nil.getInstance());
}
var car = exp.getCar();
var cdr = exp.getCdr();
return(car.eval(env).apply(buildArgsList(cdr, env)));
}
public override Node eval(Node exp, Environment env)
{
if (Node.length(exp) < 2)
{
Console.Error.WriteLine("Error: invalid begin expression");
return(Nil.getInstance());
}
else
{
return(begin(exp.getCdr(), env));
}
}
private Node apply2(Node arg1, Node arg2)
{
string name = symbol.getName();
if (name.Equals("eq?"))
{
if (arg1.isSymbol() && arg2.isSymbol())
{
return(BoolLit.getInstance(arg1.getName().Equals(arg2.getName())));
}
return(BoolLit.getInstance(arg1 == arg2));
}
if (name.Equals("cons"))
{
return(new Cons(arg1, arg2));
}
if (name.Equals("set-car!"))
{
arg1.setCar(arg2);
return(Unspecific.getInstance());
}
if (name.Equals("set-cdr!"))
{
arg1.setCdr(arg2);
return(Unspecific.getInstance());
}
if (name.Equals("eval"))
{
if (arg2.isEnvironment())
{
Environment envArg1 = (Environment)arg1;
return(arg1.eval(envArg1));
}
Console.Error.WriteLine("Error: argument is not an environment");
return(Nil.getInstance());
}
if (name.Equals("apply"))
{
return(arg1.apply(arg2));
}
if (name[0].Equals('b') && name.Length == 2)
{
if (arg1.isNumber() && arg2.isNumber())
{
return(evalArithmetic(arg1.getIntVal(), arg2.getIntVal()));
}
Console.Error.WriteLine("Error: invalid arguments");
return(Nil.getInstance());
}
Console.Error.WriteLine("Error: wrong number of arguments");
return(Nil.getInstance());
}
private Node evalClauses(Node exp, Environment env)
{
if (exp.isNull())
{
return(Unspecific.getInstance());
}
var clause = exp.getCar();
if (Node.length(clause) <= 0)
{
Console.Error.WriteLine("Error: invalid cond expression");
return(Nil.getInstance());
}
var testExp = clause.getCar();
var expression = clause.getCdr();
if (testExp.isSymbol() && testExp.getName().Equals("else"))
{
if (!expression.isNull() && exp.getCdr().isNull())
{
return(evalExp(expression, env));
}
Console.Error.WriteLine("Error: invalid expression");
return((Node)Nil.getInstance());
}
var testValid = testExp.eval(env);
if (testValid == BoolLit.getInstance(false))
{
var nextExps = exp.getCdr();
return(evalClauses(nextExps, env));
}
if (expression.isNull())
{
return(BoolLit.getInstance(true));
}
var exp1 = expression.getCar();
if (!exp1.isSymbol() || !exp1.getName().Equals("=>"))
{
return(evalExp(expression, env));
}
if (Node.length(expression) != 2)
{
Console.Error.WriteLine("Error: invalid cond expression");
return(Nil.getInstance());
}
var cdr = expression.getCdr().getCar();
return(cdr.eval(env).apply(BoolLit.getInstance(true)));
}
public void define(Node id, Node val)
{
Node value = find(id, frame);
if (value == null)
{
frame = new Cons(new Cons(id, new Cons(val, Nil.getInstance())), frame);
}
else
{
value.setCar(val);
}
}
public void define(Node id, Node val)
{
// if frame doesn't exist in scope, create new frame
if (find(id, val) == null)
{
frame = new Cons(new Cons(id, new Cons(val, Nil.getInstance())), frame);
}
else
{
// else, if frame does exist in scope, set term to val
find(id, val).setCar(val);
}
}
public override Node eval(Node exp, Environment env)
{
if (Node.length(exp) != 2)
{
Console.Error.WriteLine("Error: invalid quote expression");
return((Node)Nil.getInstance());
}
else
{
Node quoteExp = exp.getCdr().getCar();
return(quoteExp);
}
}
public override Node eval(Node exp, Environment env)
{
if (Node.length(exp) != 3)
{
Console.Error.WriteLine("Error: invalid set expression");
return((Node)Nil.getInstance());
}
Node var = exp.getCdr().getCar();
Node varExp = exp.getCdr().getCdr().getCar();
env.assign(var, varExp.eval(env));
return(Unspecific.getInstance());
}
public void define(Node id, Node val)
{
Node definition = find(id, frame);
if (definition != null)
{
definition.setCar(val);
}
else
{
Node frame = new Cons(id, new Cons(val, Nil.getInstance()));
this.frame = new Cons(frame, this.frame);
}
}
public Node eval(Node t, Environment e)
{
Node current = t.getCdr().getCar();
if (current != null)
{
return(current);
}
else
{
Console.Error.WriteLine("Error: Null inside Quote");
return(Nil.getInstance());
}
}
public void define(Node id, Node val)
{
Node temp = find(id, this.frame);
if (temp == null)
{
Node node = new Cons(id, new Cons(val, Nil.getInstance()));
this.frame = new Cons(node, this.frame);
}
else
{
Console.WriteLine("error");
}
}
// TODO: implement
public override Node apply(Node args)
{
Environment e = new Environment(env);
Node n = fun.getCar().getCdr();
while (n != Nil.getInstance() && args != Nil.getInstance())
{
e.define(n.getCar(), args.getCar());
n = n.getCdr();
args = args.getCdr();
}
return(Nil.getInstance());
//Node funBody = ;
}
public void assign(Node id, Node val)
{
// search for id in id_value_pair in frame heirarchy
Node result_lookup = lookup(id);
// if nothing found, report error.
if (result_lookup == null)
{
Console.Error.WriteLine("Exception in assigning: variable with that name does not exist");
}
else
{
result_lookup = new Cons(val, Nil.getInstance());
}
}
public override Node apply(Node args)
{
Environment theEnv = new Environment(env);
Node lambda = fun.getCdr().getCar();
while (lambda != Nil.getInstance())
{
theEnv.define(lambda.getCar(), args.getCar());
lambda = lambda.getCdr();
args = args.getCdr();
}
Node function = fun.getCdr().getCdr().getCar();
return(function.eval(theEnv));
}
// TODO: The method apply() should be defined in class Node
// to report an error. It should be overridden only in classes
// BuiltIn and Closure.
public new Node apply(Node args)
{
if(args == null)
{
Console.Write("Error: no Node");
return new Nil(); //was return null;
}
Node car = args.getCar();
Node cdr = args.getCdr();
if(car.isNull()) //IF CAR DOESN'T EXIST
{
car = new Nil();
}
if(cdr.isNull()) //IF CDR DOESN'T EXIST
{
cdr = new Nil();
}
else
{
cdr = cdr.getCar(); //THIS IS THE CADR, DOESNT WORK FOR (1 . 2)
}
String symbolNode = symbol.getName();
if(symbolNode.Equals("symbol?"))
{
return new BoolLit(car.isSymbol());
}
if(symbolNode.Equals("number?"))
{
return new BoolLit(car.isNumber());
}
if(car.isNumber() && cdr.isNumber())
{
int a = car.getValue();
int b = cdr.getValue();
if(symbolNode.Equals("b+"))
{
return new IntLit(a + b);
}
else if(symbolNode.Equals("b-"))
{
return new IntLit(a - b);
}
else if(symbolNode.Equals("b*"))
{
return new IntLit(a * b);
}
else if(symbolNode.Equals("b/"))
{
return new IntLit(a / b);
}
else if(symbolNode.Equals("b="))
{
return new BoolLit(a==b);
}
else if(symbolNode.Equals("b<"))
{
return new BoolLit(a<b);
}
else if(symbolNode.Equals("b>"))
{
return new BoolLit(a>b);
}
else
{
Console.Write("Shit broke in Builtin becuase of pizza and Netflix all day.");
return new Nil();
}
}
if(symbolNode.Equals("car"))
{
car = car.getCar(); //previously had check for null car
if (car.isNull())
Console.WriteLine("OOOOOOH SHIT DEMS BE ERRORS IN BUILTIN APPLY CALL OF CAR");
return car;
}
if(symbolNode.Equals("cdr")) //requires a list, minimum '(example)
{
cdr = car.getCdr();
if (cdr.isNull())
Console.WriteLine("OOOOOOH SHIT DEMS BE ERRORS IN BUILTIN APPLY CALL OF CDR");
return car.getCdr();
}
if(symbolNode.Equals("cons"))
{
return new Cons(car,cdr); //assumes we already have a list going on
}
if(symbolNode.Equals("set-car!")) //needs better checks of criteria, errors
{
car.setCar(cdr); //this looks correct.
return car;
}
if(symbolNode.Equals("set-cdr!")) //needs better checks of criteria, errors
{
car.setCdr(cdr);
return car;
}
if(symbolNode.Equals("null?"))
{
return new BoolLit(car.isNull()); //car is never null.
}
if(symbolNode.Equals("pair?"))
{
return new BoolLit(car.isPair());
}
if(symbolNode.Equals("eq?"))
{
if(car.isNumber() && cdr.isNumber())
{
return new BoolLit(car.getValue()==cdr.getValue());
}
else if(car.isString() && cdr.isString())
{
return new BoolLit(car.getValue().Equals(cdr.getValue()));
}
else if(car.isSymbol() && cdr.isSymbol())
{
return new BoolLit(car.getValue().Equals(cdr.getValue()));
}
else if(car.isBool() && cdr.isBool())
{
return new BoolLit(car.getBool().Equals(cdr.getBool()));
}
}
if(symbolNode.Equals("procedure?"))
{
return new BoolLit(car.isProcedure());
}
if(symbolNode.Equals("read")) // not started
{
return null;
}
if(symbolNode.Equals("write")) // not started
{
car.print(0);
return new StringLit("");
}
if(symbolNode.Equals("display"))
{
return car;
}
if(symbolNode.Equals("newline")) // is this right?!
{
return new StringLit("");
}
if(symbolNode.Equals("eval")) // is this right?!
{
return car;
}
if(symbolNode.Equals("apply"))
{
return car.apply(cdr); //??
}
if(symbolNode.Equals("interaction-environment")) // not started
{
return null;
//what the flying f**k?!?
}
//now???!!!!
return null;
}
public static Nil getNil()
{
if (nil == null)
nil = new Nil();
return nil;
}
