anchor.diff:            (syntax-test-match-p (syntax-match-test syntax)
                                  str start)
           (when (and start1 end1)
  -          (syntax-matched-word line syntax start1 end1)
  -          (return-from syntax-scan-token-test (1- end1)))))))
  +          (when (syntax-match-matched-symbol syntax)
  +            (push (cons (syntax-match-matched-symbol syntax)
  +                        (syntax-match-symbol-lifetime syntax))
  +                  *syntax-symbol-lifetimes*))
  +          (when (syntax-match-end-symbol syntax)
  +            (setq *syntax-symbol-lifetimes*
  +                  (remove (syntax-match-end-symbol syntax)
  +                          *syntax-symbol-lifetimes*
  +                          :key #'car)))
  +          (cond
  +            ((syntax-match-move-action syntax)
  +             (let* ((start-point (current-point))
  +                    (end-point (funcall (syntax-match-move-action syntax))))
  +               (when (and end-point
  +                          (point< start-point end-point))
  +                 (loop :for i :from 0 :below (- (point-linum end-point)
  +                                                (point-linum start-point))
  +                       :do (progn
  +                             (setf (line-%scan-cached-p line) t)
  +                             (line-clear-property line :attribute)
  +                             (setf (line-%region line) syntax)
  +                             (setf line (line-next line))))
  +                 (setf (line-%region line) nil)
  +                 (put-attribute start-point
  +                                end-point
  +                                (syntax-attribute syntax))
  +                 (cons (point-charpos end-point) line))))
  +            (t
  +             (line-add-property line start1 end1 :attribute (syntax-attribute syntax))
  +             (1- end1))))))))
   
   (defun syntax-scan-token (line start)
     (flet ((f (syn) (syntax-scan-token-test syn line start)))
  
positive.code:       (let ((c (schar str i)))
          (cond ((syntax-escape-char-p c)
                 (incf i))
                ((let ((pos (syntax-scan-token line i)))
                   (when pos (setq i pos))))
                (t
                 (let ((end (syntax-position-word-end (line-str line) i)))
                   (when (<= i (1- end))
                     (setq i (1- end))))))))
      (setf (line-%symbol-lifetimes line) *syntax-symbol-lifetimes*)))
  
  (defun %syntax-pos-property (pos property-name)
    (let ((line (buffer-get-line (current-buffer) (current-linum))))
  
negative.code: 
  (defun syntax-scan-line-region (line region)
    (when region
      (typecase region
        (syntax-region
         (let ((end (syntax-search-region-end region (line-str line) 0)))
           (cond (end
                  (setf (line-%region line) nil)
                  (line-add-property line 0 end :attribute (syntax-attribute region))
                  end)
                 (t
                  (setf (line-%region line) region)
                  (line-add-property line 0
                                     (1+ (length (line-str line)))
                                     :attribute
                                     (syntax-attribute region))
                  (length (line-str line))))))
        (otherwise
         (line-add-property line 0
                            (1+ (length (line-str line)))
                            :attribute
                            (syntax-attribute region))
         (length (line-str line))))))
  
  (defun syntax-scan-line (line)
    (setf (line-%scan-cached-p line) t)
  