anchor.diff:          (write-sequence (data line) s)
           (when (next-line line)
             (terpri s))))
  -    (setf (buffer-modified buffer) nil)))
  +    (setf (buffer-property buffer 'new-file) nil
  +          (buffer-modified buffer) nil)))
   
   (defun write-file-command ()
     (let* ((buffer (current-buffer *editor*))
  
positive.code:                      :pending-redisplay t
                       :foreground-colour mezzanine.gui:*default-foreground-colour*
                       :background-colour mezzanine.gui:*default-background-colour*
                       :killed-region nil
                       :global-key-map (make-hash-table)
                       :post-command-hooks '()
  
negative.code:               (t (return))))))
    (values))
  
  (defun character-right-of (mark)
    (cond ((eql (mark-charpos mark) (line-length (mark-line mark)))
           (cond
             ((next-line (mark-line mark))
              ;; At end of line.
              #\Newline)
             (t ;; At end of buffer.
              nil)))
          (t (line-character (mark-line mark) (mark-charpos mark)))))
  
  (defun character-left-of (mark)
    (cond ((eql (mark-charpos mark) 0)
           (cond
             ((previous-line (mark-line mark))
              ;; At start of line.
              #\Newline)
             (t ;; At start of buffer.
              nil)))
          (t (line-character (mark-line mark) (1- (mark-charpos mark))))))
  
  (defun scan (mark predicate jump key)
    (loop
       (let ((ch (funcall key mark)))
         (when (not ch)
           (return nil))
         (when (funcall predicate ch)
           (return t))
         (when (not (move-mark mark jump))
           (return nil)))))
  
  (defun scan-forward (mark predicate)
    (scan mark predicate 1 #'character-right-of))
  
  (defun scan-backward (mark predicate)
    (scan mark predicate -1 #'character-left-of))
  
  (defun move-word (buffer &optional (n 1))
    "Move point forward by N words. N may be negative."
  