anchor.diff:        (error-not-symbol (second form)))
       (error-arg-count (rest form))))
   
  -;; we pass `nil' here because XI lexenv structure
  -;;  is not suitable for target lisp.
  -;; TODO: make lexenv a lisp object. 
  -(defun eval-macroexpand (expander form)
  -  (let ((*dynamics* '()))
  -    (eval-call expander (list form nil))))
  +(defun eval-macroexpand (expander form lexenv)
  +  (declare (ignore lexenv))
  +  ;; NIL because our env structure is not a lisp instance(yet).
  +  (eval-call expander (list form nil)))
   
   ;; Microlisp set of special operators is very similiar to that
   ;;  of Common Lisp, so in case of XI we reuse existing CL control structures
  
positive.code:     (if (null var)
        (case (gethash symbol +global-var-info+)
          (:dynamic (get-symbol-value symbol))
          ((:static :constant)
           (if (eq :unbound (sym-value symbol))
             (error-unbound-variable symbol)
             (sym-value symbol)))
          (:macro (if (eq :unbound (sym-value symbol))
                    (error-unbound-variable symbol)
                    (eval-form (eval-macroexpand (sym-value symbol) symbol)
                               env)))
          (T (error-undeclared-variable symbol)))
        (ecase (second var)
          (:dynamic (get-symbol-value symbol))   
          (:macro (eval-form (eval-macroexpand (cddr var) symbol)
                             env))
          ((:static :constant) (cddr var))))))
  
  (defun eval-setq (form env)
    (if (= (length form) 3)
      (if (symbol-object-p (second form))
        (let* ((symbol (second form))
  
negative.code: ;; Upcoming Microlisp runtime and compiler should implement all
  ;;   this stuff from scratch.
  
  (defun eval-cons (form env)
    (case (car form)
      ([lambda] (eval-lambda form env))
      ([quote] (eval-quote form env))
      ([setq] (eval-setq form env))
      ([if] (eval-if form env))
      (([toplevel-expansion-too]
        [toplevel-expansion-only]
        [body])
       (eval-body form env))
      ([body1] (eval-body1 form env))
      ([let] (eval-let form env))
      ([let*] (eval-let* form env))
      ([letr] (eval-letr form env))
      ([bind] (eval-bind form env))
      ([catch] (eval-catch form env))
      ([throw] (eval-throw form env))
      ([block] (eval-block form env))
      ([return-from] (eval-return-from env))
      ([tagbody] (eval-tagbody form env))
      ([go] (eval-go form env))
      ([unwind-protect] (eval-unwind-protect form env))
      ([mvcall] (eval-mvcall form env))
      ([the] (eval-the form env))
      (T (let ((f (car form)))
           (if (symbol-object-p f)
             (let ((var (env-var f)))
               (if (null var)
                 (case (gethash f +global-var-info+)
                   ((:static :constant)
                    (eval-call (sym-value f) (eval-args (cdr form) env)))
                   (:dynamic
                    (eval-call (get-symbol-value f) (eval-args (cdr form) env)))
                   (:macro (eval-macroexpand (sym-value f) form env))
                   (T (error-undeclared-variable f)))
                 (ecase (second var)
                   (:dynamic
                    (eval-call (get-symbol-value f) (eval-args (cdr form) env)))
                   ((:static :constant)
                    (eval-call (cddr var) (eval-args (cdr form) env)))
                   (:macro (eval-macroexpand (cddr var) form env)))))
             (eval-call (eval-form (car form) env)
                        (eval-args (cdr form) env)))))))
  
  (defun eval-args (args env)
    (cond ((null args) '())
          ((atom args) (let ((form (eval-form args env)))
                         (if (listp form)
                           form
                           (error-not-list form env))))
          (T (cons (eval-form (car args) env)
                   (eval-args (cdr args) env)))))
  
  (defun eval-call (f args)
  #| TBD
    (let* ((f (typecase f
                (function-object f)
                (instance-object (or (inst-function f)
                                     (error-not-callable f)))
                (T (error-not-function f))))
           (required '())
           (rest nil)
           (*dynamic-vars* *dynamic-vars*))
      (loop :for (p . rp) :on (fun-args f)
            :for (a . ra) :on args
            :if (not (is-p a (cddr p)))
            :do (error-not-class-of a (cddr p))
            :else if (eq :dynamic (cadr p))
            :do (push (cons (car a) p) *dynamic-vars*)
            :else :collect (list* (car p) (cadr p) a) :into req
            :finally )
    )
  |#
    )
  
  (defun eval-form (form env)
    (typecase form
      (null nil)
      (symbol-object (eval-ref form env))
      (cons (eval-cons form env))
      ((or character array number) form)
      (T (lisp-runtime-error
          "Invalid lisp object spotted: ~s" form))))
  
  (disable-xi-syntax)
  