public void repl()
{
// Can't seem to get ResourceLoader to figure out to use *our* assembly
// by default.
var assembly = Assembly.GetCallingAssembly();
ResourceLoader.ExecuteResource(assembly, env, "Lisp.REPL.lisp");
/*
* // TODO: We ought to implement the repl in Lisp also
* // i.e. expose (read), (eval), (print) as builtin functions.
* Console.WriteLine("First Class Lisp REPL. Ctrl-Z + Enter to exit.");
* prompt();
* string line;
* var t = System.Console.In;
* while ((line = Console.ReadLine()) != null)
* {
* try
* {
* var parsed = new Parser(Scanner.Create(line)).parse();
* var result = evaluator.Evaluate(env, parsed);
* Console.WriteLine("{0}", result);
* prompt();
* }
* catch (Exception e)
* {
* Console.Error.WriteLine("Error: {0}", e);
* prompt();
* }
* }
*/
}
public static Environment AddTo(Environment env)
{
env = Arithmetic.Extend(env).ToMutable();
env = env.Extend("append", Append.Instance);
env = SymbolFunctions.Extend(env);
ResourceLoader.ExecuteResource(env, "LispEngine.Bootstrap.Builtins.lisp");
env = Reader.AddTo(env);
return(env);
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
env = Arithmetic.Extend(env);
env.Define("append", Append.Instance);
env = SymbolFunctions.Extend(env);
ResourceLoader.ExecuteResource(env, "LispEngine.Bootstrap.Builtins.lisp");
ResourceLoader.ExecuteResource(env, "LispEngine.Bootstrap.Library.lisp");
env = Reader.AddTo(env);
return(env);
}
public static LexicalEnvironment Create()
{
var env = CreateSandbox();
// Adding reflection builtins enables a lisp engine
// to execute any code.
env = ReflectionBuiltins.AddTo(env);
// Add functions for reading files, executing lisp programs
// defined in files.
ResourceLoader.ExecuteResource(new Statistics(), typeof(StandardEnvironment).GetTypeInfo().Assembly, env, "LispEngine.Bootstrap.IO.lisp");
return(env);
}
public static Environment AddTo(Environment env)
{
// Invoke a given instance method on an object
env = env.Extend("make-instance-method", new MakeInstanceMethod().ToStack());
env = env.Extend("new", new New().ToStack());
// Bring all static symbols from a particular assembly into the current environment.
env = env.Extend("ref", new Ref());
env = env.Extend("atom", new WrapAtom().ToStack());
// Define "." as a macro to invoke a given method
ResourceLoader.ExecuteResource(env, "LispEngine.ReflectionBinding.ReflectionBuiltins.lisp");
return(env);
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
env = Arithmetic.Extend(env);
env.Define("append", Append.Instance);
env = SymbolFunctions.Extend(env);
var assembly = typeof(Builtins).GetTypeInfo().Assembly;
ResourceLoader.ExecuteResource(new Statistics(), assembly, env, "LispEngine.Bootstrap.Builtins.lisp");
ResourceLoader.ExecuteResource(new Statistics(), assembly, env, "LispEngine.Bootstrap.Library.lisp");
env = Reader.AddTo(env);
return(env);
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
// Invoke a given instance method on an object
env.Define("make-instance-method", DelegateFunctions.MakeDatumFunction(MakeInstanceMethod, ",make-instance-method"));
env.Define("get-static-method", DelegateFunctions.MakeDatumFunction(GetStaticMethod, ",get-static-method"));
env.Define("get-type", new GetTypeFunction().ToStack());
env.Define("new", new New().ToStack());
env.Define("atom", new WrapAtom().ToStack());
// Define "dot" and "slash" as a macros which allow us to use
// Clojure-style syntax for invoking and referring to methods.
ResourceLoader.ExecuteResource(env, "LispEngine.ReflectionBinding.ReflectionBuiltins.lisp");
return(env);
}
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);
}
}
