KumiScript/interpreter/LispPrimitives.cs

267 lines
10 KiB
C#
Raw Normal View History

2024-01-26 05:37:51 +00:00
namespace KumiScript.Interpreter
{
public class LispPrimitives
{
public static Expression Lambda(ListExpression args, Environment env)
{
Expression car = args.Car();
ListExpression rest = args.Cdr();
ListExpression? head = car as ListExpression;
if (head is null)
throw new InterpreterInvalidDefinitionException();
List<Expression> headl = head.GetMembers();
List<Symbol> arg_names = new List<Symbol>();
for (int i = 0; i < headl.Count; i++)
{
SymbolExpression? argi = headl[i] as SymbolExpression;
if (argi is null)
throw new InterpreterInvalidDefinitionException();
arg_names.Add(argi.GetSymbol());
}
Expression body = rest.Car();
return new ProcedureExpression(new LispProcedure(arg_names, body, env));
}
public static NumberExpression Plus(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
decimal acc = 0;
for (int i = 0; i < argl.Count; i++)
{
NumberExpression? argin = argl[i] as NumberExpression;
if (argin is null)
throw new InterpreterTypingException();
acc += argin.GetValueAsFloat();
}
return NumberFactory.NormalizeFloat(acc);
}
public static NumberExpression Minus(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count == 0)
throw new InterpreterInvalidApplicationException();
NumberExpression? argn0 = argl[0] as NumberExpression;
if (argn0 is null)
throw new InterpreterTypingException();
decimal acc = argn0.GetValueAsFloat();
if (argl.Count == 1)
return NumberFactory.NormalizeFloat(1 - acc);
for (int i = 1; i < argl.Count; i++)
{
NumberExpression? argin = argl[i] as NumberExpression;
if (argin is null)
throw new InterpreterTypingException();
acc -= argin.GetValueAsFloat();
}
return NumberFactory.NormalizeFloat(acc);
}
public static NumberExpression Times(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count < 2)
throw new InterpreterInvalidInvocationException();
NumberExpression? arg0 = argl[0] as NumberExpression;
if (arg0 is null)
throw new InterpreterTypingException();
decimal f = arg0.GetValueAsFloat();
for (int i = 1; i < argl.Count; i++)
{
NumberExpression? argn = argl[i] as NumberExpression;
if (argn is null)
throw new InterpreterTypingException();
f *= argn.GetValueAsFloat();
}
return NumberFactory.NormalizeFloat(f);
}
public static NumberExpression DividedBy(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count != 2)
throw new InterpreterInvalidApplicationException();
NumberExpression? arg0 = argl[0] as NumberExpression;
if (arg0 is null)
throw new InterpreterTypingException();
NumberExpression? arg1 = argl[1] as NumberExpression;
if (arg1 is null)
throw new InterpreterTypingException();
return NumberFactory.NormalizeFloat(arg0.GetValueAsFloat() / arg1.GetValueAsFloat());
}
public static NumberExpression Modulus(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count != 2)
throw new InterpreterInvalidApplicationException();
NumberExpression? arg0 = argl[0] as NumberExpression;
if (arg0 is null)
throw new InterpreterTypingException();
NumberExpression? arg1 = argl[1] as NumberExpression;
if (arg1 is null)
throw new InterpreterTypingException();
return NumberFactory.NormalizeFloat(arg0.GetValueAsFloat() % arg1.GetValueAsFloat());
}
public static Expression Quote(ListExpression args, Environment env)
{
List<Expression> argl = args.GetMembers();
if (argl.Count != 1)
throw new InterpreterInvalidApplicationException();
return argl[0];
}
public static Expression Define(ListExpression args, Environment env)
{
List<Expression> argl = args.GetMembers();
if (argl.Count != 2)
throw new InterpreterInvalidApplicationException();
SymbolExpression? binding = argl[0] as SymbolExpression;
if (binding is null)
throw new InterpreterTypingException();
Symbol name = binding.GetSymbol();
Expression definition = argl[1].Eval(env);
env.AddSymbol(name, definition);
return definition;
}
public static Expression Car(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count != 1)
throw new InterpreterInvalidApplicationException();
ListExpression? list = argl[0] as ListExpression;
if (list is null)
throw new InterpreterTypingException();
return list.Car();
}
public static ListExpression Cdr(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count != 1)
throw new InterpreterInvalidApplicationException();
ListExpression? list = argl[0] as ListExpression;
if (list is null)
throw new InterpreterTypingException();
return list.Cdr();
}
public static ProperListExpression Cons(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count != 2)
throw new InterpreterInvalidApplicationException();
Expression car = argl[0];
ListExpression? cdr = argl[1] as ListExpression;
if (cdr is null)
throw new InterpreterTypingException();
return cdr.Cons(car);
}
public static Expression Quit(ListExpression args, Environment env)
{
System.Environment.Exit(0);
return new SymbolExpression(new Symbol("bye"));
}
public static Expression Cond(ListExpression args, Environment env)
{
List<Expression> argl = args.GetMembers();
for (int i = 0; i < argl.Count; i ++)
{
ProperListExpression? conditional = argl[i] as ProperListExpression;
if (conditional is null)
throw new InterpreterTypingException();
Expression antecedent = conditional.Car();
Expression consequent = conditional.Cdr().Car();
if (!(antecedent.Eval(env) is NilExpression))
return consequent.Eval(env);
}
return NilExpression.GetInstance();
}
public static Expression Eq(ListExpression args, Environment env)
{
List<Expression> argl = args.EvalMembers(env);
if (argl.Count != 2)
throw new InterpreterInvalidApplicationException();
if (argl[0].Equals(argl[1]))
return TrueExpression.GetInstance();
return NilExpression.GetInstance();
}
public static Expression Set(ListExpression args, Environment env)
{
List<Expression> argl = args.GetMembers();
if (argl.Count != 2)
throw new InterpreterInvalidApplicationException();
SymbolExpression? binding = argl[0] as SymbolExpression;
if (binding is null)
throw new InterpreterTypingException();
Symbol name = binding.GetSymbol();
Expression definition = argl[1].Eval(env);
env.RedefineSymbol(name, definition);
return definition;
}
public static Environment RegisterPrimitives()
{
Environment result = new Environment();
result.AddSymbol(new Symbol("lambda"), new ProcedureExpression(new PrimitiveProcedure(Lambda)));
result.AddSymbol(new Symbol("quote"), new ProcedureExpression(new PrimitiveProcedure(Quote)));
result.AddSymbol(new Symbol("define"), new ProcedureExpression(new PrimitiveProcedure(Define)));
result.AddSymbol(new Symbol("car"), new ProcedureExpression(new PrimitiveProcedure(Car)));
result.AddSymbol(new Symbol("cdr"), new ProcedureExpression(new PrimitiveProcedure(Cdr)));
result.AddSymbol(new Symbol("cons"), new ProcedureExpression(new PrimitiveProcedure(Cons)));
result.AddSymbol(new Symbol("quit"), new ProcedureExpression(new PrimitiveProcedure(Quit)));
result.AddSymbol(new Symbol("cond"), new ProcedureExpression(new PrimitiveProcedure(Cond)));
result.AddSymbol(new Symbol("+"), new ProcedureExpression(new PrimitiveProcedure(Plus)));
result.AddSymbol(new Symbol("-"), new ProcedureExpression(new PrimitiveProcedure(Minus)));
result.AddSymbol(new Symbol("*"), new ProcedureExpression(new PrimitiveProcedure(Times)));
result.AddSymbol(new Symbol("/"), new ProcedureExpression(new PrimitiveProcedure(DividedBy)));
result.AddSymbol(new Symbol("%"), new ProcedureExpression(new PrimitiveProcedure(Modulus)));
result.AddSymbol(new Symbol("eq"), new ProcedureExpression(new PrimitiveProcedure(Eq)));
result.AddSymbol(new Symbol("set!"), new ProcedureExpression(new PrimitiveProcedure(Set)));
return result;
}
}
}