Exemple #1
0
        // Act is the only entry point into the evaluator.  It requires
        // that we already have a continuation.  (I suggest cooking up one
        // that invokes Eval.)  This whole function is one big loop.  CPS
        // turns recursion into tail recursion, and our calling convention
        // turns tail recursion into iteration.  BEHOLD!
        public static Datum Act(Action call)
        {
            while (call.target != Actor.Continue)
            {
                Shell.TraceAction("Entering", call);
                switch (call.target)
                {
                    // Evaluate a single form.  There's a case for each
                    // sort of form.

                    case Actor.Eval:
                    {
                        Datum exp = call.arg;
                        Environment env = call.env;

                        if (exp is Symbol)
                        {
                            // Symbol.  Look up the value.

                            call.target = Actor.Continue;
                            call.arg = env.Lookup((Symbol)exp);
                            goto NextCall;
                        }
                        if (exp is Pair)
                        {
                            // A list evaluates as a function call, unless
                            // it's a special form.

                            Pair form = (Pair)exp;

                            if (form.car is Symbol)
                            {
                                string name = (form.car as Symbol).name;
                                try
                                {
                                    switch (name)
                                    {
                                        case "lambda":
                                        {
                                            // Evaluates to a closure.

                                            Pair formals = (Pair)form.Second;
                                            Datum body = form.Cdr.Cdr;

                                            call.target = Actor.Continue;
                                            call.arg = new Closure(
                                                env, formals, body);
                                            goto NextCall;
                                        }

                                        case "quote":
                                        {
                                            // Evaluates to its
                                            // (unevaluated) argument.

                                            call.target = Actor.Continue;
                                            call.arg = form.Second;
                                            goto NextCall;
                                        }

                                        case "begin":
                                        {
                                            // Evaluates to its last
                                            // argument, after evaluating
                                            // the others in sequence for
                                            // their side-effects.

                                            call.target =
                                                Actor.EvalSequence;
                                            call.arg = form.cdr;
                                            goto NextCall;
                                        }

                                        case "if":
                                        {
                                            // It looks exactly like every
                                            // other IF you've ever seen,
                                            // except that this one is CPS
                                            // so all we do here is enqueue
                                            // evaluation of the test
                                            // expression followed by an
                                            // actor which will branch to
                                            // the then or else clause.

                                            Datum test = form.Second;
                                            Datum conseq = form.Third;
                                            Datum alts = form.Cdr.Cdr.Cdr;

                                            call.target = Actor.Eval;
                                            call.arg = test;
                                            call.env = env;

                                            call.next = new Action(
                                                Actor.ExecuteIf,
                                                new Pair(conseq, alts),
                                                env,
                                                call.next);

                                            goto NextCall;
                                        }

                                        case "cond":
                                        {
                                            // COND is sneaky and will live
                                            // entirely in its own actor.

                                            Datum clauses = form.Cdr;

                                            call.target = Actor.ExecuteCond;
                                            call.arg = new Pair(clauses, null);
                                            call.env = env;
                                            goto NextCall;
                                        }

                                        case "set!":
                                        {
                                            // Assignment.  Enqueue
                                            // evaluation of the value
                                            // expression, followed by a
                                            // helper actor that does the
                                            // assignment.

                                            Symbol what = (Symbol)form.Second;
                                            Datum val_exp = form.Third;

                                            call.target = Actor.Eval;
                                            call.arg = val_exp;
                                            call.next = new Action(
                                                Actor.ExecuteSetQ,
                                                what,
                                                env,
                                                call.next);
                                            goto NextCall;
                                        }

                                        case "define":
                                        {
                                            // Bind a new symbol in the
                                            // current environment.  Has a
                                            // helper actor.

                                            Datum what = form.Second;
                                            Symbol who;
                                            if (what is Symbol)
                                            {
                                                who =
                                                    (Symbol)what;
                                                Datum val_exp = form.Third;

                                                call.target = Actor.Eval;
                                                call.arg = val_exp;
                                                call.env = env;
                                            }
                                            else
                                            {
                                                who = (Symbol)what.Car;
                                                Pair formals = (Pair)what.Cdr;
                                                Datum body = form.Cdr.Cdr;

                                                call.target =
                                                    Actor.Continue;
                                                call.arg = new Closure(
                                                    env, formals, body);
                                            }

                                            call.next = new Action(
                                                Actor.ExecuteDefine,
                                                who,
                                                env,
                                                call.next);

                                            goto NextCall;

                                        }

                                        case "let":
                                        {
                                            // A macro.  Perform the
                                            // transformation and evaluate
                                            // the resulting expression.  A
                                            // beautiful case for tail
                                            // calls.

                                            call.target = Actor.Eval;
                                            call.arg =
                                                Transform.Let(form);
                                            goto NextCall;
                                        }

                                        case "let*":
                                        {
                                            // Another macro.

                                            call.target = Actor.Eval;
                                            call.arg =
                                                Transform.LetStar(form);
                                            goto NextCall;
                                        }
                                    }
                                }
                                catch (NullReferenceException)
                                {
                                    throw new BadFormException(name);
                                }
                                catch (InvalidCastException)
                                {
                                    throw new BadFormException(name);
                                }
                            }

                            // If we've gotten here, we aren't a special
                            // form, so our list is a function application.
                            // We'll evaluate each element of the list and
                            // then feed the cdr to the car.  I've just
                            // mentioned two actions, and sure enough,
                            // we've about to enqueue them both...

                            call.target = Actor.EvalList;
                            call.arg = new Pair(form, null);
                            call.env = env;

                            call.next = new Action(
                                Actor.ExecuteApply,
                                null,
                                env,
                                call.next);

                            goto NextCall;
                        }
                        else
                        {
                            // All other data types (strings, numbers, &c)
                            // are self-evaluating.
                            call.target = Actor.Continue;
                            call.arg = exp;
                            goto NextCall;
                        }
                    }

                    // Evaluate a list of forms, in sequence.

                    case Actor.EvalList:
                    {
                        Pair p = (Pair)call.arg;
                        Pair exps = (Pair)p.car;
                        Pair acc = (Pair)p.cdr;

                        if (call.HasResult)
                            acc = new Pair(call.Result, acc);

                        if (exps == null)
                        {
                            call.target = Actor.Continue;
                            call.arg = acc;
                            goto NextCall;
                        }
                        else
                        {
                            call.target = Actor.Eval;
                            call.arg = exps.car;
                            call.next = new Action(
                                Actor.EvalList,
                                new Pair(exps.cdr, acc),
                                call.env,
                                call.next);

                            goto NextCall;
                        }
                    }

                    // Receive the product of EvalList and feed it to
                    // Apply.  We need this glue so that we can also invoke
                    // Apply normally, without a result.

                    case Actor.ExecuteApply:
                    {
                        call.target = Actor.Apply;
                        call.arg = call.Result;
                        goto NextCall;
                    }

                    // Apply a function to its arguments.  Ugly kludge: the
                    // argument list is backwards, with the function itself
                    // last.  Sorry.  It was easier to generate this way.

                    case Actor.Apply:
                    {
                        Environment env = call.env;
                        Pair vals = (Pair)call.arg;

                        // Juggle the backwards linked list.

                        List<Datum> args = new List<Datum>();
                        while (vals != null)
                        {
                            args.Add(vals.car);
                            vals = (Pair)vals.cdr;
                        }
                        args.Reverse();

                        Datum func = args[0];
                        args.RemoveAt(0);

                        // Apply a primitive procedure: call the
                        // implementation delegate.

                        Primitive prim = func as Primitive;
                        if (prim != null)
                        {
                            // Ouch.  CALL/CC's implementation has to be
                            // "inline" so that it won't use the CLR stack
                            // and violate CPS.  It's okay for all the
                            // other primitives to do so, because they'll
                            // return immediately and are "conceptually
                            // inline", if you will.  But since CALL/CC
                            // may not return normally, it can't get away
                            // with being on the CLR stack.
                            //
                            // For all that, the actual implementation is
                            // trivial: package up the Action chain into a
                            // Scheme Continuation object, and apply the
                            // argument to it.

                            if (prim.name == "call-with-current-continuation")
                            {
                                Continuation current =
                                    new Continuation(
                                        new Action(
                                            call.next.target,
                                            call.next.arg,
                                            call.next.env,
                                            call.next.next));
                                Shell.TraceAction(
                                    "Creating continuation which will",
                                    call.next);
                                Datum recip = args[0];
                                call.target = Actor.Apply;
                                call.arg =
                                    new Pair(current, new Pair(recip, null));
                                goto NextCall;
                            }
                            else
                            {
                                // If it's not CALL/CC, just call the
                                // delegate, passing an implicit argument
                                // if there is one.

                                call.target = Actor.Continue;
                                if (prim.magicEnvironment)
                                {
                                    args.Insert(0, env);
                                }
                                call.arg = prim.implementation(args);
                                goto NextCall;
                            }
                        }

                        // Apply a continuation.  Delightfully simple.

                        Continuation cont = func as Continuation;
                        if (cont != null)
                        {
                            Shell.TraceAction(
                                "Invoking continuation which will",
                                cont.call);
                            call.target = Actor.Continue;
                            call.arg = args[0];
                            // We cheerfully blow away the existing value
                            // of call.next, because this is a Scheme goto.
                            // This is the place where we "break the
                            // chain".
                            call.next = cont.call;
                            goto NextCall;
                        }

                        // Apply a closure.  If you've read the wizard
                        // book, you can recite the mantra in your sleep:
                        // extend the defining environment, bind the params
                        // to the formals in the new environment, then
                        // evaluate the body in the new environment...

                        Closure closure = func as Closure;

                        if (closure != null)
                        {
                            Environment new_env = new Environment(closure.env);
                            Pair paramlist = closure.formals;
                            foreach (Datum arg in args)
                            {
                                new_env.Bind((Symbol)paramlist.car, arg);
                                paramlist = (Pair)paramlist.cdr;
                            }

                            call.target = Actor.EvalSequence;
                            call.arg = closure.body;
                            call.env = new_env;
                            goto NextCall;
                        }

                        // Well, if we're still here, it means some jerk
                        // has asked us to apply a non-function.

                        throw new InapplicableException(func);
                    }

                    // Continue evaluating an IF.  We end up here after
                    // evaluating the test.  We branch to the appropriate
                    // result clause.

                    case Actor.ExecuteIf:
                    {
                        Pair p = (Pair)call.arg;
                        Datum conseq = p.car;
                        Datum alts = p.cdr;

                        if (!Datum.IsTrue(call.Result))
                        {
                            call.target =
                                Actor.EvalSequence;
                            call.arg = alts;
                            goto NextCall;
                        }
                        else
                        {
                            call.target = Actor.Eval;
                            call.arg = conseq;
                            goto NextCall;
                        }
                    }

                    // Evaluate a COND.  Just keep cdring down the list
                    // until a clause matches.  We'll do lots of two-action
                    // calls to keep coming back here after evaluating a
                    // test.  If there's a result waiting for us, it means
                    // this isn't our first trip through the loop and we
                    // need to check if it's time yet to branch to the
                    // consequent.

                    case Actor.ExecuteCond:
                    {
                        Datum clauses = call.arg.Car;
                        Datum thisConsequent = call.arg.Cdr;
                        Environment env = call.env;

                        // If we've just executed a successful test,
                        // continue with the consequent.
                        if (call.HasResult &&
                            Datum.IsTrue(call.Result))
                        {
                            call.target = Actor.Eval;
                            call.arg = thisConsequent;
                            call.env = env;
                            goto NextCall;
                        }

                        // Are we done?
                        if (clauses == null)
                        {
                            // Didn't match any clauses.
                            call.target = Actor.Continue;
                            call.arg = new Unspecified();
                            goto NextCall;
                        }

                        Datum test = clauses.Car.First;
                        Datum consequent = clauses.Car.Second;

                        // Are we at an ELSE?
                        Symbol symTest = test as Symbol;
                        if (symTest != null &&
                            symTest.name == "else")
                        {
                            call.target = Actor.Eval;
                            call.arg = consequent;
                            call.env = env;
                            goto NextCall;
                        }

                        // We've got more clauses.  Do the test, and reenter.
                        call.target = Actor.Eval;
                        call.arg = test;
                        call.env = env;
                        call.next = new Action(
                            Actor.ExecuteCond,
                            new Pair(clauses.Cdr, consequent),
                            env,
                            call.next);
                        goto NextCall;
                    }

                    // Continue assignment.  We've just evaluated the
                    // value, so assign it to the curried name.

                    case Actor.ExecuteSetQ:
                    {
                        call.env.Set((Symbol)call.arg, call.Result);

                        call.target = Actor.Continue;
                        call.arg = new Unspecified();
                        goto NextCall;
                    }

                    // Similarly, continue definition by binding the
                    // result expression to the curried name.

                    case Actor.ExecuteDefine:
                    {

                        call.env.Bind((Symbol)call.arg, call.Result);

                        call.target = Actor.Continue;
                        call.arg = new Unspecified();
                        goto NextCall;
                    }

                    // Evaluate multiple expressions in order, discarding
                    // all but the last result.

                    case Actor.EvalSequence:
                    {
                        if (null == call.arg)
                        {
                            call.target = Actor.Continue;
                            call.arg = new Pair(new Unspecified(), null);
                        }

                        Pair exps = (Pair)call.arg;
                        Environment env = call.env;

                        if (null == exps.cdr)
                        {
                            call.target = Actor.Eval;
                            call.arg = exps.car;
                            call.env = env;
                            goto NextCall;
                        }
                        else
                        {
                            call.target = Actor.Eval;
                            call.arg = exps.car;
                            call.env = env;
                            call.next = new Action(
                                Actor.EvalSequence,
                                exps.cdr,
                                env,
                                call.next);
                            goto NextCall;
                        }
                    }
                }

            NextCall:
                // Ahh, the fabled land of NextCall, whither go all actors
                // when their part is played out.  Here we process the
                // Continue actor by shuffling arg and result.  We cdr down
                // the action chain and then finish the body of the while,
                // returning back to the very top of Evaluator.Act to begin
                // the cycle again.

                if (call.target != Actor.Continue)
                {
                    call.ClearResult();
                }

                if (call.target == Actor.Continue &&
                    call.next != null)
                {
                    Shell.Trace("Continuing with result ", call.arg);
                    call.next.Result = call.arg;
                    call = call.next;
                }
            }

            // Well, we've managed to exit the great cosmic while loop.
            // Ths means that we hit an Actor.Continue token which didn't
            // have a next; in other words, the last actor told us to
            // continue but there's nothing to continue doing.  This means
            // we've finally finished performing the act that we were
            // originally called for, "called" in (for once!) the prosaic
            // C# sense.  And so... we return!  Actually, honest-to-gosh
            // return, pop the CLR stack, bid a fond farewell to CPS-land.
            // Sayonara!

            Shell.Trace("Returning...");
            return call.arg;
        }