anchor.diff:    (let ((bcode (maybe-add 'progn code)))
       (multiple-value-bind (required optional rest keyword)
           (smack-parse-parms parms)
  -      #'(lambda (&rest args)
  +      #'(lambda (denv &rest args)
             (dolist (p required)
               (when (null args)
                 (error "invalid number of arguments"))
  -            (setq env (extend-env-1 p (pop args) env)))
  +            (if (special-var-p p denv)
  +                (setq denv (extend-env-1 p (pop args) denv))
  +                (setq env (extend-env-1 p (pop args) env))))
             (dolist (p optional)
               (destructuring-bind (var default supplied-p-var) p
                 (let ((supplied-p (consp args))
                       (val (cond ((consp args) (pop args))
                                  (default (interp default env fenv))
                                  (t nil))))
  -                (setq env (extend-env-1 var val env))
  +                (if (special-var-p var denv)
  +                    (setq denv (extend-env-1 var val denv))
  +                    (setq env (extend-env-1 var val env)))
                   (when supplied-p-var
                     (setq env (extend-env-1 supplied-p-var supplied-p env))))))
             (when (and args (null rest) (null keyword))
  
positive.code:                        (val (cond (supplied-p (getf args ky))
                                    (default (interp default env fenv))
                                    (t nil))))
                    (setq env (extend-env-1 var val env))
                    (when supplied-p-var
                      (setq env (extend-env-1 supplied-p-var supplied-p env)))))))
            (interp bcode env fenv)))))
  
  ;; (defun make-function (parms code env fenv)
  ;;   (let ((bcode (maybe-add 'progn code)))
  
negative.code:    (interp-toplevel x :timeout timeout)))
   
  
  
  (defun smack-string-simple (s &key timeout)
    "takes a string, reads it, interprets it and converts the result to a string"
    (with-output-to-string (ss)
      (with-smack-readtable ()
        (let* ((*standard-output* ss)
               (results (multiple-value-list
                         (interp-toplevel (read-from-string s)
                                          :timeout timeout))))
          (mapcar #'fresh-print results)))))
  
  
  (defun smack-string (s &key timeout)
    "takes a string, reads it, interprets it and converts the result to a string"
    (smack-error-handle
     (smack-string-simple s :timeout timeout)))
  
  (defun smack-string-values (s &key timeout)
    "takes a string, reads it, interprets it and converts the result to a string"
    (let ((value-str (make-adjustable-string 0))
          (output-str (make-adjustable-string 0))
          (success-p nil))
      (with-output-to-string (sv value-str)
        (with-output-to-string (so output-str)
          (with-smack-readtable ()
            (handler-case
                (let* ((*standard-output* so)
                       (results (multiple-value-list
                                 (interp-toplevel (read-from-string s)
                                                  :timeout timeout))))
                  (let ((*standard-output* sv))
                    (mapcar #'fresh-print results))
                  (setf success-p t))
              (simple-condition (condition)
                (apply 'format sv
                       (simple-condition-format-control condition)
                       (simple-condition-format-arguments condition)))
              (serious-condition (condition)
                (format sv "~A" condition))))))
      (values value-str output-str success-p)))
  
  (defun smack (&key timeout)
    "A Smacklisp read-eval-print loop (using interp)"
    (with-smack-readtable ()
      (loop
        (clear-input )
        (format t "~&==> ")
  
        (when (eq :smack-quit
                  (first (mapcar #'fresh-print
                                 (multiple-value-list
                                  (smack-error-handle
                                   (interp-toplevel (read)
                                                    :timeout timeout))))))
          (return "Bye")))))
  
  
  (defmacro fresh-smack (&rest x)
    `(let ((*smack-symbols* (make-hash-table)))
       (smack ,@x)))
  
  (defun smack-tagbody (body env fenv denv)
    (let ((goto nil))
      (tagbody top
         (setq goto
  