anchor.diff:     (current-charpos)
      c))
   
  +(define-command erase-buffer () ()
  +  (point-set (point-max))
  +  (buffer-erase (current-buffer))
  +  t)
  +
  +(defun delete-while-whitespaces (&optional ignore-newline-p use-kill-ring)
  +  (let ((n (skip-chars-forward
  +            (if ignore-newline-p
  +                '(#\space #\tab)
  +                '(#\space #\tab #\newline)))))
  +    (delete-char (- n) use-kill-ring)))
  +
   (defun blank-line-p ()
     (let ((string (buffer-line-string (current-buffer) (current-linum)))
           (eof-p (buffer-end-line-p (current-buffer) (current-linum))))
  
positive.code:       (+ (length string)
           (if eof-p 0 1)))))
  
  (define-command erase-buffer () ()
    (point-set (point-max))
    (buffer-erase (current-buffer))
    t)
  
  (defun delete-while-whitespaces (&optional ignore-newline-p use-kill-ring)
    (do ((n 0 (1+ n))) ((eobp))
      (let ((c (following-char)))
        (if (or (and ignore-newline-p (char= c #\newline))
                (not (syntax-space-char-p c)))
            (return n)
            (delete-char 1 use-kill-ring)))))
  
  (defun %skip-test (pred not-p char)
    (if (if (consp pred)
            (member char pred)
  
negative.code:       (not not-p)
        not-p))
  
  (defun skip-chars-aux (pred not-p step-char at-char)
    (let ((count 0))
      (loop
        (unless (%skip-test pred not-p (funcall at-char))
          (return count))
        (if (funcall step-char)
            (incf count)
            (return count)))))
  
  (defun skip-chars-forward (pred &optional not-p)
    (skip-chars-aux pred not-p #'next-char #'following-char))
  
  (defun skip-chars-backward (pred &optional not-p)
    (skip-chars-aux pred not-p #'prev-char #'preceding-char))
  
  (define-key *global-keymap* (kbd "M-Spc") 'just-one-space)
  (define-command just-one-space () ()
  