anchor.diff:                     (mark-sexp)
                      (region-string (region-beginning) (region-end))))))
       (when str
  -      (eval-string str)
  +      (lisp-eval-string str)
         t)))
   
  -(define-key *lisp-mode-keymap* (kbd "M-C-x") 'eval-defun)
  -(define-command eval-defun () ()
  +(define-key *lisp-mode-keymap* (kbd "M-C-x") 'lisp-eval-defun)
  +(define-command lisp-eval-defun () ()
     (%eval-sexp #'top-of-defun))
   
  -(define-key *lisp-mode-keymap* (kbd "C-x u") 'eval-last-sexp)
  -(define-command eval-last-sexp () ()
  +(define-key *lisp-mode-keymap* (kbd "C-x u") 'lisp-eval-last-sexp)
  +(define-command lisp-eval-last-sexp () ()
     (%eval-sexp #'backward-sexp))
   
  -(define-key *lisp-mode-keymap* (kbd "C-x y") 'eval-buffer)
  -(define-command eval-buffer () ()
  -  (eval-string
  +(define-key *lisp-mode-keymap* (kbd "C-x y") 'lisp-eval-buffer)
  +(define-command lisp-eval-buffer () ()
  +  (lisp-eval-string
      (region-string (progn (beginning-of-buffer) (point))
                     (progn (end-of-buffer) (point)))))
   
  -(define-key *lisp-mode-keymap* (kbd "C-x l") 'load-file)
  -(define-key *lisp-mode-keymap* (kbd "C-x C-l") 'load-file)
  -(define-command load-file (filename) ("fLoad File: ")
  +(define-key *lisp-mode-keymap* (kbd "C-x l") 'lisp-load-file)
  +(define-key *lisp-mode-keymap* (kbd "C-x C-l") 'lisp-load-file)
  +(define-command lisp-load-file (filename) ("fLoad File: ")
     (when (and (file-exist-p filename)
                (not (file-directory-p filename)))
  -    (eval-string
  +    (lisp-eval-string
        (format nil "(load ~s)" filename))))
   
  -(define-key *lisp-mode-keymap* (kbd "C-x m") 'macroexpand-lisp)
  -(define-command macroexpand-lisp (arg) ("P")
  +(define-key *lisp-mode-keymap* (kbd "C-x m") 'lisp-macroexpand)
  +(define-command lisp-macroexpand (arg) ("P")
     (let ((expr
            (read-from-string
             (region-string (point)
  
positive.code:     (cons 'progn (nreverse exps))))
  
  (defun eval-from-string (str)
    (eval (string-to-exps str)))
  
  (defvar *eval-thread*)
  (defvar *mi-thread*)
  
negative.code:   (mark-sexp)
    (lisp-indent-region))
  
  (defun %string-to-exps (str)
    (let ((str str)
          (exps)
          (eof-value (make-symbol "eof")))
  