public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var argArray = DatumHelpers.enumerate(args).ToArray();
c = c.PushTask(new InvokeFunction(function, argArray.Length));
return(argArray.Aggregate(c, (current, arg) => current.Evaluate(env, arg)));
}
public Datum Evaluate(Datum args)
{
var methodArgs = unwrap(args.Enumerate());
var method = type.GetRuntimeMethods().First(e => e.Name.Equals(methodName));
var result = method.Invoke(null, methodArgs);
return(result == null ? Null.Instance : DatumHelpers.atom(result));
}
public Datum Evaluate(Datum args)
{
if (!DatumHelpers.nil.Equals(args))
{
throw DatumHelpers.error("gensym accepts no arguments");
}
return(Symbol.GenUnique());
}
public Datum Evaluate(Datum args)
{
if (!DatumHelpers.nil.Equals(args))
{
throw DatumHelpers.error("No arguments expected for function '{0}'", name);
}
return(accessor().ToAtom());
}
protected override Datum eval(Datum arg1, Datum arg2)
{
if ((arg1 as Pair) != null ||
(arg2 as Pair) != null)
{
return(DatumHelpers.atom(ReferenceEquals(arg1, arg2)));
}
return(DatumHelpers.atom(arg1.Equals(arg2)));
}
public Datum Evaluate(Datum args)
{
var methodArgs = unwrap(args.Enumerate());
var result = type.InvokeMember(methodName,
BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.Static,
null, null, methodArgs);
return(result == null ? Null.Instance : DatumHelpers.atom(result));
}
private static Continuation asContinuation(Datum arg)
{
var cfunction = arg as CallCC.ContinuationFunction;
if (cfunction == null)
{
throw DatumHelpers.error("'{0}' is not a continuation", arg);
}
return(cfunction.Continuation);
}
public Datum Evaluate(Datum args)
{
var argArray = args.ToArray();
if (argArray.Length != 3)
{
throw DatumHelpers.error("{0}: 3 arguments expected, got {1}", name, argArray.Length);
}
return(funcDelegate(argArray[0], argArray[1], argArray[2]));
}
protected override Datum eval(Datum arg)
{
var input = arg.CastObject();
if (!(input is T))
{
throw DatumHelpers.error("Expected '{0}' to be of type '{1}'", arg, typeof(T).Name);
}
return(funcDelegate((T)input).ToAtom());
}
public static Datum GetSingle(Datum args)
{
var argArray = args.ToArray();
if (argArray.Length != 1)
{
throw DatumHelpers.error("Expected a single argument. Got {0}", argArray.Length);
}
return(argArray[0]);
}
public Datum Evaluate(Datum args)
{
var argDatums = args.ToArray();
if (argDatums.Length != 2)
{
throw DatumHelpers.error("Exactly 2 arguments expected");
}
return(eval(argDatums[0], argDatums[1]));
}
public Continuation Perform(Continuation c)
{
var argResults = DatumHelpers.nil;
for (var i = 0; i < argCount; ++i)
{
argResults = DatumHelpers.cons(c.Result, argResults);
c = c.PopResult();
}
return(function.Evaluate(c, argResults));
}
public Continuation Perform(Continuation c)
{
var args = new Datum[argCount];
for (var i = 0; i < argCount; ++i)
{
args[i] = c.Result;
c = c.PopResult();
}
return(function.Evaluate(c, DatumHelpers.compound(args)));
}
private static Datum getPendingResults(Datum arg)
{
var c = asContinuation(arg);
var stack = DatumHelpers.nil;
while (c.Result != null)
{
stack = DatumHelpers.cons(c.Result, stack);
c = c.PopResult();
}
return(stack);
}
private static Datum getTaskDescriptions(Datum arg)
{
var c = asContinuation(arg);
var stack = DatumHelpers.nil;
while (c.Task != null)
{
stack = DatumHelpers.cons(c.Task.ToString().ToAtom(), stack);
c = c.PopTask();
}
return(stack);
}
private static Datum getEnvironments(Datum arg)
{
var c = asContinuation(arg);
var stack = DatumHelpers.nil;
while (c.Env != null)
{
stack = DatumHelpers.cons(c.Env.ToAtom(), stack);
c = c.PopEnv();
}
return(stack);
}
public override Continuation Evaluate(Continuation c, Datum args)
{
var argArray = args.ToArray();
if (argArray.Length != 2)
{
throw DatumHelpers.error("Invalid syntax. ArgCount ({0}) != 2. Usage: (execute-with-error-handler <error-function> <fn>)", argArray.Length);
}
var errorHandler = makeErrorHandler(c.ErrorHandler, (StackFunction)argArray[0]);
var fn = (StackFunction)argArray[1];
return(fn.Evaluate(c.NewErrorHandler(errorHandler), DatumHelpers.compound()));
}
public Datum Evaluate(Datum args)
{
var argsArray = args.ToArray();
if (argsArray.Length < 1)
{
throw DatumHelpers.error("No type specified for 'new'");
}
var type = (Type)argsArray[0].CastObject();
var constructorArgs = argsArray.Skip(1).Select(DatumHelpers.castObject).ToArray();
var instance = Activator.CreateInstance(type, constructorArgs);
return(instance.ToAtom());
}
static void Main(string[] args)
{
try
{
var env = StandardEnvironment.Create();
env.Define("args", DatumHelpers.atomList(args));
var statistics = new Statistics();
env = statistics.AddTo(env);
ResourceLoader.ExecuteResource(statistics, Assembly.GetExecutingAssembly(), env, "Lisp.REPL.lisp");
}
catch (Exception ex)
{
Console.Error.WriteLine("ERROR:\n{0}\n{1}\n", ex, ex.StackTrace);
}
}
// Thanks to http://stackoverflow.com/questions/2367652/how-type-gettype-works-when-given-partially-qualified-type-name
// for this:
public static Type GetTypeEx(string fullTypeName)
{
var type = Type.GetType(fullTypeName);
if (type != null)
{
return(type);
}
var assembly = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault(a => a.GetType(fullTypeName) != null);
if (assembly != null)
{
return(assembly.GetType(fullTypeName));
}
throw DatumHelpers.error("Could not locate type '{0}' in any of the {1} currently loaded assemblies",
fullTypeName, AppDomain.CurrentDomain.GetAssemblies().Length);
}
// Thanks to http://stackoverflow.com/questions/2367652/how-type-gettype-works-when-given-partially-qualified-type-name
// for this:
public static Type GetTypeEx(string fullTypeName)
{
var type = Type.GetType(fullTypeName);
if (type != null)
{
return(type);
}
var assembly = typeof(ReflectionBuiltins).GetTypeInfo().Assembly;
if (assembly != null)
{
return(assembly.GetType(fullTypeName));
}
throw DatumHelpers.error("Could not locate type '{0}' in loaded assembly",
fullTypeName);
}
public override Continuation Evaluate(Continuation c, Datum args)
{
var argArray = args.ToArray();
if (argArray.Length != 1)
{
throw DatumHelpers.error("call/cc: expect a single function as an argument. Got {0}", argArray.Length);
}
var arg = argArray[0];
var function = arg as StackFunction;
if (function == null)
{
throw DatumHelpers.error("call/cc: {0} must be a function", arg);
}
return(function.Evaluate(c, DatumHelpers.compound(new ContinuationFunction(c))));
}
public static Datum Lookup(this Continuation c, string name)
{
var env = GetEnvironment(c);
if (env == null)
{
return(null);
}
Datum datum;
if (env.TryLookup(name, out datum))
{
return(datum);
}
return(DatumHelpers.atom("undefined"));
}
static void Main(string[] args)
{
var running = true;
while (running)
{
var env = StandardEnvironment.CreateSandbox();
env.Define("args", DatumHelpers.atomList(args));
var statistics = new Statistics();
env = statistics.AddTo(env);
var assembly = typeof(Program).GetTypeInfo().Assembly;
var docEnvironment = new StandardDefinition();
var maker = new Maker()
{
Environment = docEnvironment
};
try
{
var evaluator = new Evaluator();
var input = Console.ReadLine();
Datum result = default(Datum);
foreach (var d in ReadDatums(input))
{
result = evaluator.Evaluate(statistics, env, d);
}
Console.Write(result);
}
catch (Exception ex)
{
Console.Error.WriteLine("ERROR:\n{0}\n{1}\n", ex, ex.StackTrace);
}
}
}
protected override Datum eval(Datum arg)
{
return(DatumHelpers.getIdentifier(arg).ToAtom());
}
private static ErrorHandler makeErrorHandler(ErrorHandler oldErrorHandler, StackFunction f)
{
// Report the "message" from the exception to the Lisp
// error handling function.
// Ensure that the original error handler is in scope before evaluating the error function -
// otherwise we end up in an infinite loop if there's an error in the error function itself.
return((c, ex) => f.Evaluate(c.PopTask().SetErrorHandler(oldErrorHandler), DatumHelpers.compound(ex.Message.ToAtom(), CallCC.MakeContinuationFunction(c))));
}
private static Datum throwMsg(Datum arg)
{
var msg = (String)arg.CastObject();
throw DatumHelpers.error(msg);
}
Exception bindError(Datum args)
{
return(DatumHelpers.error("Could not bind '{0}' to '{1}'", argList(), args));
}
protected override Datum eval(Datum arg)
{
return(DatumHelpers.symbol(DatumHelpers.castString(arg)));
}
protected override Datum eval(Datum arg1, Datum arg2)
{
return(DatumHelpers.cons(arg1, arg2));
}
