anchor.diff:    (make-hash-table ))
   
   (defvar *max-interp-depth* 10000)
  +
  +(defun sharp-illegal (stream sub-char arg)
  +  (declare (ignore stream arg))
  +  (error  "illegal sharp macro character: ~S" sub-char))
  +
  +(defreadtable smack-readtable
  +  (:merge :standard)
  +  (:dispatch-macro-char #\# #\. #'sharp-illegal)
  +  (:dispatch-macro-char #\# #\+ #'sharp-illegal)
  +  (:dispatch-macro-char #\# #\- #'sharp-illegal)
  +  (:dispatch-macro-char #\# #\= #'sharp-illegal)
  +  (:dispatch-macro-char #\# #\# #'sharp-illegal))
  +
  +
  +
  +(defmacro with-smack-readtable (() &body body)
  +  `(with-named-readtable ('smack-readtable)
  +    ,@body))
   
   (defmacro get-smackprop (symbol prop)
     `(getf (gethash ,symbol *smack-symbols*) ,prop))
  
positive.code: 
  
  (defun get-global-func (symbol)
    (unless (smack-fboundp symbol) 
      (error "Unbound smacklisp function: ~a" symbol))
    (get-smackprop symbol 'global-func))
  
  
  ;;(defmacro defun-smack (parms &rest body)
  ;;  `  (set-global-func name
  ;;                   (lambda
  (defun smack-quit()
    :smack-quit)
  
  (defun smack-boundp (symbol)
    (smackprop-p symbol 'global-val))
        
  
  (defun smack-fboundp (symbol)
    (smackprop-p symbol 'global-func))
        
  
  (defun smack-fdefinition (symbol)
    (unless (smack-fboundp symbol)
      (error "Unbound global smacklisp function: ~a" symbol))
    (get-global-func symbol))
  
  (defun smack-fmakunbound (symbol)
    (rem-smackprop symbol 'global-func))
    
  
  (defun smack-funcall (fn &rest args)
    (apply fn args))
  
  (defun smack-defconstant (symbol val)
    (rem-smackprop symbol 'constant)
    (set-global-var symbol val)
    (set-smackprop symbol 'constant t))
  
  (defun smack-defun (symbol parms body env fenv)
    (set-global-func symbol (make-function parms body env fenv)))
    
  (defun extend-env (vars vals env)
    "Add some variables and values to an environment."
    (nconc (mapcar #'list vars vals) env))
  
  (defun extend-env-1 (var val env)
    "Add one variable and value to an environment."
    (push (list var val) env))
  
  (defun smack-symbol-plist (symbol)
    (get-smackprop symbol 'symbol-plist))
  
  (defun smack-get (symbol indicator &optional default)
   (getf (get-smackprop symbol 'symbol-plist) indicator default))
  
  (defun smack-put-prop (symbol indicator value)
    (setf (getf (get-smackprop symbol 'symbol-plist) indicator)
          value))
  
  (defun smack-putf (plist indicator value)
    (setf (getf plist indicator) value)
    plist)
  
  
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
  