anchor.diff:  (defun find-file-command ()
     (let* ((path (read-from-minibuffer (format nil "Find file (default ~S): " *default-pathname-defaults*)))
            (filespec (merge-pathnames path))
  -         (buffer (make-instance 'buffer))
  -         (start (copy-mark (buffer-point buffer) :left)))
  +         (buffer (make-instance 'buffer)))
       (with-open-file (s filespec :if-does-not-exist nil)
         (cond (s
                (loop
  
positive.code: (defun backward-word-command ()
    (move-word (current-buffer *editor*) -1))
  
  (defun move-beginning-of-line-command ()
    (move-beginning-of-line (current-buffer *editor*)))
  
  
negative.code:       ;; And now past alphanumeric characters.
        (funcall fn point (complement #'alphanumericp)))))
  
  (defun scan-sexp-forward (mark)
    (let ((pair-stack '())
          (first-char t))
      (flet ((whitespacep (ch)
               (eql (sys.int::readtable-syntax-type ch nil) :whitespace)))
        ;; Skip past any leading whitespace.
        (scan-forward mark (complement #'whitespacep))
        (loop
           (let ((ch (character-right-of mark)))
             (when (not ch)
               (return nil))
             (when (and (whitespacep ch) (not pair-stack))
               (return t))
             (cond ((eql ch (first pair-stack))
                    (pop pair-stack)
                    (when (not pair-stack)
                      ;; Found last match, finished.
                      (move-mark mark 1)
                      (return t)))
                   ((eql ch #\))
                    (if first-char
                        (error "Unmatched ~C." ch)
                        (return t)))
                   ((eql ch #\")
                    (push #\" pair-stack))
                   ((eql ch #\()
                    (push #\) pair-stack)))
             (move-mark mark 1))
           (setf first-char nil)))))
  
  (defun scan-sexp-backward (mark)
    (let ((pair-stack '())
          (first-char t))
      (flet ((whitespacep (ch)
               (eql (sys.int::readtable-syntax-type ch nil) :whitespace)))
        ;; Skip past any leading whitespace.
        (scan-backward mark (complement #'whitespacep))
        (loop
           (let ((ch (character-left-of mark)))
             (when (not ch)
               (return nil))
             (when (and (whitespacep ch) (not pair-stack))
               (return t))
             (cond ((eql ch (first pair-stack))
                    (pop pair-stack)
                    (when (not pair-stack)
                      ;; Found last match, finished.
                      (move-mark mark -1)
                      (return t)))
                   ((eql ch #\()
                    (if first-char
                        (error "Unmatched ~C." ch)
                        (return t)))
                   ((eql ch #\")
                    (push #\" pair-stack))
                   ((eql ch #\))
                    (push #\( pair-stack)))
             (move-mark mark -1))
           (setf first-char nil)))))
  
  (defun move-sexp (buffer &optional (n 1))
    "Move point forward by N s-expressions. N may be negative."
    (let ((point (buffer-point buffer))
          (fn #'scan-sexp-forward))
      (when (minusp n)
        (setf n (- n)
              fn #'scan-sexp-backward))
      (dotimes (i n)
        (funcall fn point))))
  
  (defun test-fill (buffer)
    (let ((width (1- (truncate (editor-width)
                               (mezzanine.gui.font:glyph-advance (mezzanine.gui.font:character-to-glyph (font *editor*) #\M))))))
      (with-mark (mark point :left)
        (dotimes (i (* (window-rows) 2))
          (dotimes (j width)
            (insert buffer (code-char (+ #x20 i))))
  