anchor.diff:                      (last (split-string car-name-str
                                           #\:)))))
                    (car-name (intern car-symbol-name :lem))
  -                 (argc (lisp-count-sexps point)))
  +                 (argc (%count-sexps point)))
               (let ((num
                      (do ((val (get car-name 'lisp-indent)))
                          ((or (not val)
  
positive.code:                    (mark-sexp)
                     (region-string (region-beginning) (region-end))))))
      (when str
        (eval-string str)
        t)))
  
  (define-key *lisp-mode-keymap* (kbd "M-C-x") 'eval-defun)
  (define-command eval-defun () ()
    (%eval-sexp #'top-of-defun))
  
  (define-key *lisp-mode-keymap* (kbd "C-x u") 'eval-last-sexp)
  (define-command eval-last-sexp () ()
    (%eval-sexp #'backward-sexp))
  
  (define-key *lisp-mode-keymap* (kbd "C-x y") 'eval-buffer)
  (define-command eval-buffer () ()
    (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: ")
    (when (and (file-exist-p filename)
               (not (file-directory-p filename)))
      (eval-string
       (format nil "(load ~s)" filename))))
  
  (define-key *lisp-mode-keymap* (kbd "C-x m") 'macroexpand-lisp)
  (define-command macroexpand-lisp (arg) ("P")
    (let ((expr
           (read-from-string
            (region-string (point)
  
negative.code:   (mark-sexp)
    (lisp-indent-region))
  
  (defun %string-to-exps (str)
    (let ((str str)
          (exps)
          (eof-value (make-symbol "eof")))
  