anchor.diff:          :key #'car :test #'eq))
   
   (defun error-unbound-variable (symbol)
  -  (eval-call [signal-error]
  +  (eval-call (sym-value [signal-error])
                (list (sym-value [unbound-variable]) symbol)))
   
   (defun error-undeclared-variable (symbol)
  -  (eval-call [signal-error]
  +  (eval-call (sym-value [signal-error])
                (list (sym-value [undeclared-variable]) symbol)))
   
   (defun error-constant-modification (symbol)
  -  (eval-call [signal-error]
  +  (eval-call (sym-value [signal-error])
                (list (sym-value [constant-modification]) symbol)))
   
   (defun error-arg-count (args)
  -  (eval-call [signal-error]
  +  (eval-call (sym-value [signal-error])
                (list (sym-value [invalid-argument-count]) args)))
   
   (defun error-not-symbol (datum)
  -  (eval-call [signal-error]
  +  (eval-call (sym-value [signal-error])
                (list (sym-value [class-error])
                      datum
                      (sym-value [symbol]))))
  +
  +(defun error-not-list (datum)
  +  (eval-call (sym-value [signal-error])
  +             (list (sym-value [class-error])
  +                   datum
  +                   (sym-value [list]))))
  +
  +(defun error-not-function (datum)
  +  (eval-call (sym-value [signal-error])
  +             (list (sym-value [class-error])
  +                   datum
  +                   (sym-value [function]))))
  +
  +(defun error-not-callable (datum)
  +  (eval-call (sym-value [signal-error])
  +             (list (sym-value [instance-not-callable])
  +                   datum)))
  +
  +(defun error-not-class-of (datum class)
  +  (eval-call (sym-value [signal-error])
  +             (list (sym-value [class-error])
  +                   datum
  +                   class)))
   
   (defun get-symbol-value (symbol)
     (let ((dynvar (find symbol *dynamic-vars*
                         :key #'car)))
       (if (not dynvar)
         (case (gethash symbol +global-var-info+)
  -        ((:static :constant :macro :dynamic)
  -         (if (eq (sym-value symbol) :unbound)
  -           (error-unbound-variable symbol)
  -           (sym-value symbol)))
  -        (T (error-undeclared-variable symbol)))
  +        ((:static :constant :macro) (sym-value symbol))
  +        (T (if (eq (sym-value symbol) :unbound)
  +             (error-unbound-variable symbol)
  +             (sym-value symbol))))
         (if (eq :unbound (cdr dynvar))
           (error-unbound-variable symbol)
           (cdr dynvar)))))
  
positive.code:       (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))))
  
  ;; Microlisp set of special operators is very similiar to that
  ;;  of Common Lisp, so in case of XI we reuse existing CL control structures
  
negative.code:     (if (null var)
        (case (gethash symbol +global-var-info+)
          (:dynamic (get-symbol-value symbol))
          ((:static :constant) (sym-value symbol))
          (:macro (eval-form (sym-value symbol) env))
          (T (error-undeclared-variable symbol)))
        (ecase (second var)
          (:dynamic (get-symbol-value symbol))   
          (:macro (eval-form (cddr 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))
  