public static Cell Eval(Cell code, CodeResult cr, SchemeEnvironment env) { List <Cell> args = new List <Cell>(); args.Add(code); args.Add(new Cell(env)); Machine machine = new Machine(cr, args); try { System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch(); sw.Start(); while (machine.Finished == false) { machine.Step(); } StepsExecuted += machine.Steps; sw.Stop(); Console.WriteLine("!Eval ran in {0}", sw.Elapsed); } catch (Exception e) { Debug.WriteLine("Eval failed: {0}", e.Message); } return(machine.A); }
static void Main(string[] args) { ProgramArguments PArgs = ReadArguments(args); if (PArgs.Help) { Console.WriteLine("Usage: executable [-I] [-E evaluator] [-T] [-t] [-d] [file1 file2 ..] [-help]"); Console.WriteLine(""); Console.WriteLine("Where:"); Console.WriteLine("\t-I Enter interactive (REPL) mode. Default if no files specified."); Console.WriteLine("\t-E evaluator Use given evaluator, valid options: cell, classic, frame"); Console.WriteLine("\t-T Run tests"); Console.WriteLine("\t-t Enable timing"); Console.WriteLine("\t-d Enable instruction debugging"); Console.WriteLine("\tfile1.. File to run"); Console.WriteLine("\t-help Show this help"); Console.WriteLine(""); Console.WriteLine("Evaluators:"); Console.WriteLine("\tframe Frame evaluator. Combines cell and classic benefits. Default."); Console.WriteLine("\tcell Cell virtual machine."); Console.WriteLine("\tclassic Classic eval loop, no multitasking."); return; } Debug = PArgs.Debug; ShowTimings = PArgs.Timing; Evaluator = Activator.CreateInstance(PArgs.EvaluatorType) as ISchemeEval; SchemeEnvironment env = new SchemeEnvironment(); StandardRuntime.AddGlobals(env); AddProgramGlobals(env); if (PArgs.Tests) { RunTests(); } else if (PArgs.Files.Count == 0) { PArgs.Interactive = true; } if (PArgs.Files.Count > 0) { foreach (string file in PArgs.Files) { RunSpecifiedFile(file, env); } } if (PArgs.Interactive) { REPL(env); } else if (System.Diagnostics.Debugger.IsAttached) { Console.WriteLine("[DEBUG] Press ENTER to end."); Console.ReadLine(); } }
public override Cell Eval(Cell Arg, SchemeEnvironment Env) { CodeResult cr = GetCodeResult("Eval.asm"); Machine machine = new Machine(cr, new Cell[] { Arg, new Cell(Env) }); machine.DebugMode = useDebug; while (machine.Finished == false) { machine.Step(); } stepCounter += machine.Steps; return(Result = machine.A); }
protected static Cell DoEval(Cell code, SchemeEnvironment env) { // Update/set (debug) function env.Insert("debug", new Cell(btargs => { if (btargs.Length > 0) { Evaluator.Debug = (btargs[0] == StandardRuntime.True); } Debug = Evaluator.Debug; return(Debug ? StandardRuntime.True : StandardRuntime.False); })); Evaluator.Debug = Debug; Evaluator.Eval(code, env); return(Evaluator.Result); }
static void RunSpecifiedFile(string path, SchemeEnvironment env = null) { try { // Read in specified file string specCode = File.ReadAllText(GetFilePath(path)); Cell specCodeCell = StandardRuntime.Read(specCode); if (env == null) { // Create environment env = new SchemeEnvironment(); StandardRuntime.AddGlobals(env); } Stopwatch sw = new Stopwatch(); DoEval(specCodeCell, env); sw.Stop(); if (ShowTimings) { Console.WriteLine("=== Executed {0} steps in {1}ms", Evaluator.Steps, sw.ElapsedMilliseconds); } Console.Error.WriteLine("Finish with value: {0}", Evaluator.Result); } catch (Exception e) { Console.Error.WriteLine("!!! {0}", e.Message); } }
public static Cell Eval(string code, CodeResult cr, SchemeEnvironment env) { Cell codeCell = StandardRuntime.Read(code); return(Eval(codeCell, cr, env)); }
public static void TestCompileEval() { string eval = System.IO.File.ReadAllText(Program.GetFilePath("Eval.asm")); string entry = "main"; CellMachineAssembler assembler = new CellMachineAssembler(eval, entry); CodeResult cr; try { cr = CellMachineAssembler.Assemble(eval, entry); } catch (Exception e) { Console.WriteLine("Failed to assemble: {0}", e.Message); #if DEBUG Console.WriteLine("Stack trace:"); Console.WriteLine(e.StackTrace); #endif return; } Console.WriteLine("Compiled Core/Eval.asm, {0} bytes into:", eval.Length); Console.WriteLine(" Code: {0} instructions ({1} bytes)", cr.Code.Count, cr.Code.Count * sizeof(int)); int wordlength = 0; foreach (Cell c in cr.Data) { wordlength += c.Value.Length; } Console.WriteLine(" Data: {0} elements ({1} bytes)", cr.Data.Count, wordlength); SchemeEnvironment env = new SchemeEnvironment(); StandardRuntime.AddGlobals(env); string code = "" + "(begin " + " (define fac (lambda (n) (if (<= n 1) 1 (* n (fac (- n 1))))))" + " (fac 10))"; if (1 == 1) { AssertEqual(Eval(StandardRuntime.True.Value, cr, env), StandardRuntime.True); } if (1 == 1) { AssertEqual(Eval("1", cr, env), new Cell(1)); } if (1 == 1) { AssertEqual(Eval(new Cell(new Cell[] { }), cr, env), StandardRuntime.Nil); } if (1 == 1) { AssertEqual(Eval("()", cr, env), StandardRuntime.Nil); } if (1 == 1) { AssertEqual(Eval("(quote 1 2 3)", cr, env), new Cell(1)); } if (1 == 1) { AssertEqual(Eval("(define x 123)", cr, env), new Cell(123)); } if (1 == 1) { AssertEqual(Eval("x", cr, env), new Cell(123)); } if (1 == 1) { AssertEqual(Eval("(set! x 456)", cr, env), new Cell(456)); } if (1 == 1) { AssertEqual(Eval("x", cr, env), new Cell(456)); } if (1 == 1) { AssertEqual(Eval("(lambda (x y) (+ x y))", cr, env), new Cell("#Lambda((x y) (+ x y))")); } if (1 == 1) { AssertEqual(Eval("(begin (define y 789) y)", cr, env), new Cell(789)); } if (1 == 1) { AssertEqual(Eval("(+ 1 2)", cr, env), new Cell(3)); } if (1 == 1) { AssertEqual(Eval("(begin (define add (lambda (x y) (+ x y))) (add 1 2))", cr, env), new Cell(3)); } if (1 == 1) { AssertEqual(Eval("(if (= 1 1) 1 0)", cr, env), new Cell("1")); } if (1 == 1) { AssertEqual(Eval("(if (= 0 1) 0 1)", cr, env), new Cell("1")); } if (1 == 1) { AssertEqual(Eval("(if (= 1 1) 1)", cr, env), new Cell("1")); } if (1 == 1) { AssertEqual(Eval("(if (= 1 0) 1)", cr, env), StandardRuntime.Nil); } if (1 == 1) { AssertEqual(Eval(code, cr, env), new Cell(3628800)); } if (1 == 1) { AssertEqual(Eval("(if (= 1 1) (+ 1 1) (- 1 1))", cr, env), new Cell(2)); } if (1 == 1) { AssertEqual(Eval("(if (= 1 1) (begin 1) (- 1 1))", cr, env), new Cell(1)); } }
public virtual void Init(Cell item, SchemeEnvironment env) { Item = item; Environment = env; }
public override void Init(Cell item, SchemeEnvironment env) { base.Init(item, env); machine = new CellMachine.Machine(cr, new Cell[] { Item, new Cell(Environment) }); }
public override void Init(Cell item, SchemeEnvironment env) { base.Init(item, env); state = new FrameEval.FrameState(Item, new Cell(Environment)); }
static void REPL(SchemeEnvironment env) { env["help"].ProcValue(new Cell[] { }); // invoke env["repl"].ProcValue(new Cell[] { }); // invoke }
static void AddProgramGlobals(SchemeEnvironment env) { List <Cell> history = new List <Cell>(); bool quit = false; bool timing = false; // Add a function to get a history result env.Insert("h", new Cell(args => new Cell(history[(int)(args[0])]))); env.Insert("eval", new Cell((args, subenv) => { if (args.Length > 1) { subenv = args[1].Environment; } return(DoEval(new Cell(args[0]), subenv)); })); env.Insert("env", new Cell((args, subenv) => new Cell(subenv))); env.Insert("str", new Cell(args => new Cell(args[0].ToString()))); env.Insert("env-str", new Cell(args => new Cell(args[0].Environment.ToString()))); env.Insert("exit", new Cell(args => { quit = true; return(StandardRuntime.Nil); })); env.Insert("quit", env.Lookup(new Cell("exit"))); env.Insert("timing", new Cell(args => { if (args.Length > 0) { timing = ((string)args[0] == "on" || args[0] == StandardRuntime.True); Console.Error.WriteLine("Timing is now " + (timing ? "on" : "off")); } return(timing ? StandardRuntime.True : StandardRuntime.False); })); // Add evaluator constants env.Insert("evcell", new Cell("evcell")); env.Insert("evclassic", new Cell("evclassic")); env.Insert("evframe", new Cell("evframe")); // Add function to change evaluator env.Insert("sweval", new Cell(args => { if (args.Length == 0) { if (Evaluator.GetType() == typeof(CellMachineEval)) { return(new Cell("evcell")); } else if (Evaluator.GetType() == typeof(StandardEval)) { return(new Cell("evclassic")); } else if (Evaluator.GetType() == typeof(FrameEval)) { return(new Cell("evframe")); } else { throw new InvalidDataException(); } } ISchemeEval newEvaluator; Cell result; switch (args[0].Value) { case "evcell": newEvaluator = new CellMachineEval(); result = new Cell("evcell"); break; case "evclassic": newEvaluator = new StandardEval(); result = new Cell("evclassic"); break; case "evframe": newEvaluator = new FrameEval(); result = new Cell("evframe"); break; default: return(new Cell("#invalid_argument")); } // Copy details to new evaluator newEvaluator.Debug = Evaluator.Debug; Evaluator = newEvaluator; return(result); })); // Add function to run unit tests on evaluator env.Insert("swtest", new Cell(args => { var results = SchemeEval.RunTests(Evaluator); Cell result = new Cell(CellType.LIST); result.ListValue.Add(new Cell(results.Success)); result.ListValue.Add(new Cell(results.Failures)); return(result); })); env.Insert("help", new Cell(args => { Console.Write("SchemingSharply v {0}", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version); #if DEBUG Console.WriteLine(" debug"); #else Console.WriteLine(" release"); #endif Console.WriteLine("Type `quit' or `\\q' to quit"); Console.WriteLine("Type `(env-str (env))' to display environment"); //Console.WriteLine("Use `(eval expr)' or `(eval expr (env))' for testing"); Console.WriteLine("Use `(h n)' to view history item n"); Console.WriteLine("Use `(timing #true)` to enable timing, `(debug #true)` to enable debugging"); Console.WriteLine("Use `(sweval ...)` to get or set evaluator; valid options: evcell, evclassic, evframe"); Console.WriteLine("Use `(swtest)` to run unit tests"); Console.WriteLine("Use `(help)' to display this message again"); Console.WriteLine(); return(StandardRuntime.Nil); })); env.Insert("repl", new Cell(args => { quit = false; while (!quit) { int index = history.Count; string entry = ReadLine(string.Format("{0}> ", index)).Trim(); if (entry.Equals("quit", StringComparison.OrdinalIgnoreCase) || entry.Equals("exit", StringComparison.OrdinalIgnoreCase) || entry == "\\q") { break; } if (entry.Equals("")) { continue; } try { Stopwatch sw = new Stopwatch(); sw.Start(); Cell entered = StandardRuntime.Read(entry); LastExecutedSteps = Evaluator.Steps; Cell result = DoEval(entered, env); string steps = (Evaluator.Steps - LastExecutedSteps).ToString(); if (Evaluator.Steps < LastExecutedSteps) { steps = "??"; } sw.Stop(); Console.WriteLine("===> {0}", result); if (timing) { Console.WriteLine("=== Executed {0} steps in {1}ms", steps, sw.ElapsedMilliseconds); } history.Add(result); } catch (Exception e) { Console.WriteLine("!!!> {0}", e.Message); } } return(StandardRuntime.Nil); })); }