anchor.diff:    (unless (buffer-mark-p (current-buffer))
       (editor-error "Not mark in this buffer")))
   
  -(defun set-current-mark (marker)
  -  (let ((buffer (point-buffer marker)))
  +(defun set-current-mark (point)
  +  (let ((buffer (point-buffer point)))
       (cond ((buffer-mark-p buffer)
              (move-point (buffer-mark buffer)
  -                       marker))
  +                       point))
             (t
              (setf (buffer-mark-p buffer) t)
              (setf (buffer-mark buffer)
  -                 (copy-point marker :right-inserting)))))
  -  marker)
  +                 (copy-point point :right-inserting)))))
  +  point)
   
   (defun current-line-string ()
     (line-string-at (current-point)))
  
positive.code:                                     value
                                      (null end)))))
  
  (defun remove-text-property (start-marker end-marker key)
    (assert (eq (point-buffer start-marker)
                (point-buffer end-marker)))
    (%map-region start-marker end-marker
                 (lambda (line start end)
                   (line-remove-property line
                                         start
  
negative.code:                                            end)
                                         key))))
  
  (defun next-single-property-change (point property-name &optional limit-point)
    (let ((first-value (text-property-at point property-name))
          (start-point (copy-point point :temporary)))
      (loop
        (unless (character-offset point 1)
          (move-point point start-point)
          (return nil))
        (unless (eq first-value (text-property-at point property-name))
          (return point))
        (when (and limit-point (point<= limit-point point))
          (move-point point start-point)
          (return nil)))))
  
  (defun previous-single-property-change (point property-name &optional limit-point)
    (let ((first-value (text-property-at point property-name -1))
          (start-point (copy-point point :temporary)))
      (loop
        (unless (eq first-value (text-property-at point property-name -1))
          (return point))
        (unless (character-offset point -1)
          (move-point point start-point)
          (return nil))
        (when (and limit-point (point>= limit-point point))
          (move-point point start-point)
          (return nil)))))
  
  (defun line-string-at (point)
    (buffer-line-string (point-buffer point)
                        (point-linum point)))
  
  (defun point-column (point)
    (string-width (line-string-at point)
                  0
                  (point-charpos point)))
  
  (defun move-to-column (point column &optional force)
    (line-end point)
    (let ((cur-column (point-column point)))
      (cond ((< column cur-column)
             (setf (point-charpos point)
                   (wide-index (line-string-at point) column))
             point)
            (force
             (insert-char-at point #\space (- column cur-column))
             (line-end point))
            (t
             (line-end point)))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  