public static LexicalEnvironment Extend(LexicalEnvironment env)
{
env.Define("symbol->string", new SymbolToString().ToStack());
env.Define("string->symbol", new StringToSymbol().ToStack());
env.Define("gensym", new GenSym().ToStack());
return(env);
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
env.Define("read", Read.Instance);
env.Define("open-input-string", OpenInputString.Instance);
env.Define("eof-object?", IsEof.Instance);
env.Define("open-input-stream", OpenInputStream.Instance);
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);
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
return(env.Define("task-descriptions", MakeDatumFunction(getTaskDescriptions, ",task-descriptions"))
.Define("execute-with-error-translator", ExecuteWithErrorTranslator.Instance)
.Define("env-stack", MakeDatumFunction(getEnvironments, ",env-stack"))
.Define("pending-results", MakeDatumFunction(getPendingResults, ",pending-results"))
.Define("throw", MakeDatumFunction(throwMsg, ",throw"))
.Define("get-env", MakeDatumFunction(getEnv, ",get-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 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 Extend(LexicalEnvironment env)
{
return(env
.Define("+", makeOperation("+", (x, y) => x + y))
.Define("-", makeOperation("-", (x, y) => x - y))
.Define("*", makeOperation("*", (x, y) => x * y))
.Define("/", makeOperation("/", (x, y) => x / y))
.Define("<", makeOperation("<", (x, y) => x < y))
.Define(">", makeOperation(">", (x, y) => x > y))
.Define("bit-and", makeOperation("bit-and", (x, y) => x & y))
.Define("bit-or", makeOperation("bit-or", (x, y) => x | y))
.Define("bit-shift", makeOperation("bit-shift", (x, y) => x << y)));
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
env.Define("make-vector", new MakeVector().ToStack());
env.Define("vector", new VectorConstructor().ToStack());
env.Define("vector?", DelegateFunctions.MakeDatumFunction(isVector, ",vector?"));
env.Define("vector-copy", DelegateFunctions.MakeDatumFunction(vectorCopy, ",vector-copy"));
env.Define("vector-set!", DelegateFunctions.MakeDatumFunction(vectorSet, ",vector-set!"));
env.Define("vector-length", DelegateFunctions.MakeDatumFunction(vectorLength, ",vector-length"));
env.Define("vector-ref", DelegateFunctions.MakeDatumFunction(vectorRef, ",vector-ref"));
return(env);
}
public override Continuation Evaluate(Continuation c, LexicalEnvironment env, Datum args)
{
var argList = args.ToArray();
if (argList.Length != 2)
{
throw c.error("Expected 2 arguments: (define <symbol> <expression>). Got {0} instead", argList.Length);
}
var name = argList[0].CastSymbol();
var expression = argList[1];
c = c.PushTask(
tc => { env.Define(name, tc.Result);
return(tc); },
"define '{0}'", name);
return(c.Evaluate(env, expression));
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
env = env
.Define("log", Log.Instance)
.Define("lambda", Lambda.Instance)
.Define("cons", DelegateFunctions.MakeDatumFunction(DatumHelpers.cons, ",cons"))
.Define("set-car!", DelegateFunctions.MakeDatumFunction(DatumHelpers.setCar, ",set-car!"))
.Define("set-cdr!", DelegateFunctions.MakeDatumFunction(DatumHelpers.setCdr, ",set-cdr!"))
.Define("apply", Apply.Instance)
.Define("eq?", EqualFunctions.Eq)
.Define("equal?", EqualFunctions.Equal)
.Define("quote", Quote.Instance)
.Define("define", Define.Instance)
.Define("set!", Set.Instance)
.Define("begin", Begin.Instance)
.Define("call-with-current-continuation", CallCC.Instance)
.Define("eval", Eval.Instance)
.Define("env", Env.Instance);
env = DebugFunctions.AddTo(env);
env = Macro.AddTo(env);
env = VectorFunctions.AddTo(env);
return(env);
}
public static LexicalEnvironment AddTo(LexicalEnvironment env)
{
env.Define("unmacro", Unmacro);
env.Define("macro", Instance);
return(env);
}
