anchor.diff:                          (cddr arg)
                           env fenv))))
   
  -(defun smack-flet (fns body env fenv)
  +(defun smack-flet (fns body env fenv denv)
     (smack-progn body
                  env
                  (extend-env (mapcar #'first fns)
  
positive.code:    (interp-toplevel x :timeout timeout)))
   
  
  (defun smack-string (s &key timeout)
    "takes a string, reads it, interprets it and converts the result to a string"
    (smack-error-handle
     (with-output-to-string (ss)
       (let* ((*standard-output* ss)
              (results (multiple-value-list
                           (interp-toplevel (read-from-string s)
                                            :timeout timeout))))
         (mapcar #'fresh-print results)))))
  
  (defun smack (&key timeout)
    "A Smacklisp read-eval-print loop (using interp)"
    (loop
      (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)
    (let ((goto nil))
      (tagbody top
         (setq goto
  
negative.code:      (make-function (make-parms slots) (make-body imake slots) nil nil))
      (link-smack-cl-function imake imake)))
  
  (defun  smack-defstruct (denv name options slots)
    (declare (ignore options denv))
    (let* ((simple-slots (mapcar #'car slots))
           (internal-name (gensym (string name))))
      (eval `(defstruct ,internal-name ,@simple-slots))
  