anchor.diff:  ;;;; Variable References
   
   (defmethod evaluate/cps ((var local-variable-reference) env k)
  -  (kontinue k (lookup env :let (name var))))
  +  (kontinue k (lookup env :let (name var) :error-p t)))
  +
  +(defmethod evaluate/cps ((var local-lexical-variable-reference) env k)
  +  (kontinue k (funcall (first (lookup env :lexical-let (name var) :error-p t)))))
   
   (defmethod evaluate/cps ((var free-variable-reference) env k)
     (declare (ignore env))
  
positive.code: 
  (defvar *call/cc-returns* nil)
  
  (defmacro with-call/cc (initial-environment &body body)
    "Execute BODY with delimited partial continuations.
  
    Within the code of BODY almest all common lisp forms maintain
  
negative.code:   passed a continutaion. This object may then be passed to the
    function KALL which will cause execution to resume around the
    call/cc form. "
    (let ((walk-env (make-walk-env e))
          (evaluate-env nil))
      (dolist* ((type name &rest data) walk-env)
        (declare (ignore data))
        (when (eql :lexical-let type)
          (push (list 'list
                      :lexical-let
                      `(quote ,name)
                      ;; NB: this makes the environment, and therefore
                      ;; contiunations, unserializable. we would need to
                      ;; change this to a regular :let and not allow the
                      ;; setting of lexical variables.
                      `(lambda () ,name)
                      (with-unique-names (v)
                        `(lambda (,v) (setf ,name ,v))))
                evaluate-env)))
      (setf evaluate-env `(list ,@(nreverse evaluate-env)))
      `(drive-cps (evaluate/cps ,(walk-form (if (rest body)
                                                `(progn ,@body)
                                                (first body))
  