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 override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var datumArgs = args.ToArray();
if (datumArgs.Length != 1)
{
throw c.error("Ref expect 1s arguments. {0} passed", datumArgs.Length);
}
var assemblyName = datumArgs[0].CastIdentifier();
var assembly = Assembly.Load(assemblyName);
// Keep a hash set to avoid adding things twice.
// Overload resolution is (hopefully) handled by
// InvokeMethod.
var symbols = new HashSet <object>();
// Add all static methods
foreach (var t in assembly.GetTypes())
{
// Make each type have a symbol in the environment also.
env.Define(t.FullName, t.ToAtom());
foreach (var mi in t.GetMethods())
{
var symbol = string.Format("{0}.{1}", t.FullName, mi.Name);
if (mi.IsStatic && symbols.Add(symbol))
{
env.Define(symbol, new StaticMethod(t, mi.Name).ToStack());
}
}
}
return(c.PushResult(DatumHelpers.nil));
}
/**
* Create a "sandbox" environment: the symbols defined in the
* environment don't provide any way for lisp programs to execute
* arbitrary code.
*/
public static Environment CreateSandbox()
{
var env = new Environment(EmptyEnvironment.Instance);
env = CoreForms.AddTo(env);
env = Builtins.AddTo(env);
return env;
}
/**
* Create a "sandbox" environment: the symbols defined in the
* environment don't provide any way for lisp programs to execute
* arbitrary code.
*/
public static Environment CreateSandbox()
{
var env = new Environment(EmptyEnvironment.Instance);
env = CoreForms.AddTo(env);
env = Builtins.AddTo(env);
return(env);
}
public static Environment AddTo(Environment env)
{
env = env.Extend("read", Read.Instance);
env = env.Extend("open-input-string", OpenInputString.Instance);
env = env.Extend("eof-object?", IsEof.Instance);
env = env.Extend("open-input-stream", OpenInputStream.Instance);
return env;
}
public static Environment AddTo(Environment env)
{
env = env.Extend("read", Read.Instance);
env = env.Extend("open-input-string", OpenInputString.Instance);
env = env.Extend("eof-object?", IsEof.Instance);
env = env.Extend("open-input-stream", OpenInputStream.Instance);
return(env);
}
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;
}
/**
* Used for bootstrapping various .lisp files into the environment.
*/
public static void ExecuteResource(Assembly assembly, Environment env, string resourceFile)
{
var evaluator = new Evaluator();
foreach (var d in ReadDatums(assembly, resourceFile))
{
evaluator.Evaluate(env, d);
}
}
public void setupFixture()
{
e = new Evaluator();
env = StandardEnvironment.Create();
var setupDatum = getLispFromResource("setup");
if (setupDatum != nil)
foreach(var f in setupDatum.Enumerate())
e.Evaluate(env, f);
}
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 override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length != 2)
throw c.error("Expected 2 arguments: (set! <symbol> <expression>). Got {0} instead", argList.Length);
var name = argList[0].CastIdentifier();
var expression = argList[1];
c = c.PushTask(new SetName(env, name));
return c.Evaluate(env, expression);
}
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 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 override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length != 2)
{
throw c.error("Expected 2 arguments: (set! <symbol> <expression>). Got {0} instead", argList.Length);
}
var name = argList[0].CastIdentifier();
var expression = argList[1];
c = c.PushTask(new SetName(env, name));
return(c.Evaluate(env, expression));
}
public void setupFixture()
{
e = new Evaluator();
env = StandardEnvironment.Create();
var setupDatum = getLispFromResource("setup");
if (setupDatum != nil)
{
foreach (var f in setupDatum.Enumerate())
{
e.Evaluate(env, f);
}
}
}
private static Datum evaluate(Continuation c, Environment env, Datum args)
{
var macroArgs = args.ToArray();
if (macroArgs.Length % 2 != 0)
throw c.error("Invalid macro syntax for lambda. Argument count for '{0}' is not even ({1}). Syntax is (lambda [args body]+)", args, macroArgs.Length);
var argBodies = new List<ArgBody>();
for (var i = 0; i < macroArgs.Length; i += 2)
{
var closureArgs = macroArgs[i];
var body = macroArgs[i + 1];
argBodies.Add(new ArgBody(closureArgs, body));
}
return new Closure(env, argBodies);
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length < 1)
throw c.error("Expected at least 1 expression for begin. Got none.");
// Scope any local definitions.
var localEnv = new Environment(env);
var remaining = argList.Reverse().ToArray();
for (var i = 0; i < remaining.Length; ++i)
{
if (i > 0)
c = c.PushTask(Ignore.Instance);
c = c.Evaluate(localEnv, remaining[i]);
}
return c;
}
public static Environment AddTo(Environment env)
{
env = env
.Extend("log", Log.Instance)
.Extend("lambda", Lambda.Instance)
.Extend("cons", Cons.Instance)
.Extend("apply", Apply.Instance)
.Extend("eq?", Eq.Instance)
.Extend("macro", Macro.Instance)
.Extend("quote", Quote.Instance)
.Extend("define", Define.Instance)
.Extend("set!", Set.Instance)
.Extend("begin", Begin.Instance)
.Extend("call/cc", CallCC.Instance)
.Extend("eval", Eval.Instance)
.Extend("env", Env.Instance);
return(env);
}
public static Environment AddTo(Environment env)
{
env = env
.Extend("log", Log.Instance)
.Extend("lambda", Lambda.Instance)
.Extend("cons", Cons.Instance)
.Extend("apply", Apply.Instance)
.Extend("eq?", Eq.Instance)
.Extend("macro", Macro.Instance)
.Extend("quote", Quote.Instance)
.Extend("define", Define.Instance)
.Extend("set!", Set.Instance)
.Extend("begin", Begin.Instance)
.Extend("call/cc", CallCC.Instance)
.Extend("eval", Eval.Instance)
.Extend("env", Env.Instance);
return env;
}
private static Datum evaluate(Continuation c, Environment env, Datum args)
{
var macroArgs = args.ToArray();
if (macroArgs.Length % 2 != 0)
{
throw c.error("Invalid macro syntax for lambda. Argument count for '{0}' is not even ({1}). Syntax is (lambda [args body]+)", args, macroArgs.Length);
}
var argBodies = new List <ArgBody>();
for (var i = 0; i < macroArgs.Length; i += 2)
{
var closureArgs = macroArgs[i];
var body = macroArgs[i + 1];
argBodies.Add(new ArgBody(closureArgs, body));
}
return(new Closure(env, argBodies));
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length < 1)
{
throw c.error("Expected at least 1 expression for begin. Got none.");
}
// Scope any local definitions.
var localEnv = new Environment(env);
var remaining = argList.Reverse().ToArray();
for (var i = 0; i < remaining.Length; ++i)
{
if (i > 0)
{
c = c.PushTask(Ignore.Instance);
}
c = c.Evaluate(localEnv, remaining[i]);
}
return(c);
}
public static void ExecuteResource(Environment env, string resourceFile)
{
ExecuteResource(Assembly.GetCallingAssembly(), env, resourceFile);
}
public SetName(Environment env, string name)
{
this.env = env;
this.name = name;
}
public Closure(Environment env, IEnumerable <ArgBody> argBodies)
{
this.env = env;
this.argBodies = argBodies;
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
return(c.PushResult(env.ToAtom()));
}
public EvaluateExpansion(Environment env)
{
this.env = env;
}
public Closure(Environment env, IEnumerable<ArgBody> argBodies)
{
this.env = env;
this.argBodies = argBodies;
}
public static Environment Extend(Environment env)
{
env = env.Extend("symbol->string", new SymbolToString().ToStack());
env = env.Extend("string->symbol", new StringToSymbol().ToStack());
return(env);
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
return c.PushResult(evaluate(c, env, args));
}
public EvaluateExpansion(Environment env)
{
this.env = env;
}
/**
* Used for bootstrapping various .lisp files into the environment.
*/
public static void ExecuteResource(Assembly assembly, Environment env, string resourceFile)
{
var evaluator = new Evaluator();
foreach (var d in ReadDatums(assembly, resourceFile))
evaluator.Evaluate(env, d);
}
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 override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
c = c.PushTask(new EvaluateExpansion(env));
return argFunction.Evaluate(c, args);
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
c = c.PushTask(new EvaluateExpansion(env));
return(argFunction.Evaluate(c, args));
}
public SetName(Environment env, string name)
{
this.env = env;
this.name = name;
}
public static Environment Extend(Environment env)
{
env = env.Extend("symbol->string", new SymbolToString().ToStack());
env = env.Extend("string->symbol", new StringToSymbol().ToStack());
return env;
}
public override Continuation Evaluate(Continuation c, Environment env, Datum args)
{
var datumArgs = args.ToArray();
if (datumArgs.Length != 1)
throw c.error("Ref expect 1s arguments. {0} passed", datumArgs.Length);
var assemblyName = datumArgs[0].CastIdentifier();
var assembly = Assembly.Load(assemblyName);
// Keep a hash set to avoid adding things twice.
// Overload resolution is (hopefully) handled by
// InvokeMethod.
var symbols = new HashSet<object>();
// Add all static methods
foreach (var t in assembly.GetTypes())
{
// Make each type have a symbol in the environment also.
env.Define(t.FullName, t.ToAtom());
foreach (var mi in t.GetMethods())
{
var symbol = string.Format("{0}.{1}", t.FullName, mi.Name);
if (mi.IsStatic && symbols.Add(symbol))
env.Define(symbol, new StaticMethod(t, mi.Name).ToStack());
}
}
return c.PushResult(DatumHelpers.nil);
}
public static void ExecuteResource(Environment env, string resourceFile)
{
ExecuteResource(Assembly.GetCallingAssembly(), env, resourceFile);
}