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