internal override PartialResult PartialEval(PartialEnvironment environment) { bool changed = false; PartialResult [] ra = new PartialResult [this.components.Length]; for (int i = 0; i < this.components.Length; i++) { ra [i] = this.components [i].PartialEval(environment); if (ra [i].Residual != this.components [i]) { changed = true; } } if (changed) { SCode [] components = new SCode [ra.Length]; for (int i = 0; i < ra.Length; i++) { components [i] = ra [i].Residual; } return(new PartialResult(new Combination(components))); } else { return(new PartialResult(this)); } }
internal override PartialResult PartialEval(PartialEnvironment environment) { PartialResult pred = this.predicate.PartialEval(environment); PartialResult alt = this.alternative.PartialEval(environment); return(new PartialResult((pred.Residual == this.predicate && alt.Residual == this.alternative) ? this : Disjunction.Make(pred.Residual, alt.Residual))); }
public PartialClosure(LType lambda, PartialEnvironment environment) { this.lambda = lambda; this.environment = environment; this.staticMapping = environment.GetStaticMapping(lambda.FreeVariables); this.exportedTopLevelVariables = lambda.CallsTheEnvironment() ? noUnshadowedTopLevelVariables : ComputeUnshadowedTopLevelVariables(environment.TopLevelVariables, lambda.Formals); }
static public object Initial(SCode expression, Environment environment) { object answer; Thread.CurrentThread.Priority = ThreadPriority.AboveNormal; #if DEBUG Timer tosProbe = new Timer(SCode.TopOfStackProbe, null, 5, 3); SCode.topOfStackTimer = tosProbe; #endif Control residual = expression.PartialEval(PartialEnvironment.Make((ITopLevelEnvironment)environment)).Residual; while (true) { answer = null; while (residual.EvalStep(out answer, ref residual, ref environment)) { } ; if (answer == Interpreter.UnwindStack) { // What are we doing here? Someone unwound the stack! // There are three possibilities to consider: // 1) A cwcc has just performed a destructive read of the stack. // In this case, we convert the newly captured frame list // into a control point and reload it. // // 2) A within-continuation has blown away the stack in order // to install a different control point. In this case we // reload the control point that was stored in the UnwinderState. // // 3) The stack was unwound in order to exit the interpreter. // In this case, we return from the initial continuation. if (((UnwinderState)environment).IsExit) { answer = ((UnwinderState)environment).ExitValue; break; } else { ControlPoint stateToRestore = ((UnwinderState)environment).ToControlPoint(); // the receiver gets control when the stack is put back. Control receiver = ((UnwinderState)environment).Receiver; // the rewind state goes in the closureEnvironment environment = new RewindState(stateToRestore, receiver); // Start reloading by returning control to the lowest // frame. residual = ((RewindState)environment).PopFrame(); } } } Debug.WriteLine("Interpreter exited with value " + answer.ToString()); return(answer); }
public static bool ScodeEval(out object answer, object arg0, object arg1) { Environment env = Environment.ToEnvironment(arg1); //CompileTimeEnvironment ctenv = (env is StandardEnvironment) // ? new CompileTimeEnvironment (((StandardEnvironment) env).Closure.Lambda.Formals) // : new CompileTimeEnvironment (null); SCode sarg0 = SCode.EnsureSCode(arg0); answer = new TailCallInterpreter(sarg0.PartialEval(PartialEnvironment.Make((ITopLevelEnvironment)env)).Residual, env); return(true); }
internal override PartialResult PartialEval(PartialEnvironment environment) { PartialResult rator = this.components [0].PartialEval(environment); PartialResult rand0 = this.components [1].PartialEval(environment); PartialResult rand1 = this.components [2].PartialEval(environment); PartialResult rand2 = this.components [3].PartialEval(environment); return(new PartialResult(rator.Residual == this.components [0] && rand0.Residual == this.components [1] && rand1.Residual == this.components [2] && rand2.Residual == this.components [3] ? this : Combination3.Make(rator.Residual, rand0.Residual, rand1.Residual, rand2.Residual))); }
public static bool SystemPairCons(out object answer, object acode, object car, object cdr) { //TC typeCode = (TC) (int) acode; // for debugging porpoises switch ((TC)acode) { case TC.ACCESS: answer = Access.Make(car, (Symbol)cdr); break; case TC.ASSIGNMENT: answer = Assignment.Make(car, cdr); break; case TC.COMBINATION_1: answer = Combination1.Make(car, cdr); break; case TC.COMMENT: answer = Comment.Make(car, cdr); break; case TC.COMPLEX: answer = new Complex(car, cdr); break; case TC.DEFINITION: answer = Definition.Make((Symbol)car, cdr); break; case TC.DELAY: answer = new Delay(car, cdr); break; case TC.DISJUNCTION: answer = Disjunction.Make(car, cdr); break; case TC.ENTITY: answer = new Entity(car, cdr); break; case TC.LAMBDA: // passed in backwards. object [] names = (object [])cdr; object [] formals = new object [names.Length - 1]; Array.Copy(names, 1, formals, 0, formals.Length); SCode body = SCode.EnsureSCode(car); answer = Lambda.Make(names[0], formals, car); break; case TC.PCOMB1: answer = PrimitiveCombination1.Make((Primitive1)car, cdr); break; case TC.PROCEDURE: // Lambda had better be a `StandardLambda' because we are // constructing an closureEnvironment that needs to be first-class. Environment env = Environment.ToEnvironment(cdr); Lambda ulam = (Lambda)car; Lambda plam = (Lambda)ulam.PartialEval(PartialEnvironment.Make((ITopLevelEnvironment)env)).Residual; StandardLambda slam = (StandardLambda) new StandardLambda(plam.Name, plam.Formals, plam.Body, ulam.FreeVariables, plam.StaticMapping ); answer = new StandardClosure(slam, env); break; case TC.RATNUM: answer = new Ratnum(car, cdr); break; case TC.SCODE_QUOTE: answer = Quotation.Make(car); break; case TC.SEQUENCE_2: answer = Sequence2.Make(car, cdr); break; case TC.UNINTERNED_SYMBOL: // What gives? Uninterned strings are squirrely on the CLR. // We put them in a class object to have more control. answer = Symbol.MakeUninterned(new String((char [])car)); break; case TC.WEAK_CONS: answer = new WeakCons(car, cdr); break; default: throw new NotImplementedException(); } return(false); }
internal override PartialResult PartialEval(PartialEnvironment environment) { return(new PartialResult(this)); }
internal override PartialResult PartialEval(PartialEnvironment environment) { PartialResult po = this.Operator.PartialEval(environment); return(new PartialResult((po.Residual == this.Operator) ? this : Combination0.Make(po.Residual))); }