anchor.diff:      syntax-table))
   
   (defun syntax-add-match (syntax-table test &key test-symbol end-symbol attribute
  -                                      matched-symbol (symbol-lifetime -1))
  +                                      matched-symbol (symbol-lifetime -1) move-action)
     (push (make-instance 'syntax-match
                          :test test
                          :test-symbol test-symbol
                          :end-symbol end-symbol
                          :attribute attribute
                          :matched-symbol matched-symbol
  -                       :symbol-lifetime symbol-lifetime)
  +                       :symbol-lifetime symbol-lifetime
  +                       :move-action move-action)
           (syntax-table-match-list syntax-table))
     t)
   
  
positive.code: 
  (defun syntax-scan-line-region (line region)
    (when 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)))))))
  
  (defun syntax-scan-line (line)
    (setf (line-%scan-cached-p line) t)
  
negative.code:           (syntax-test-match-p (syntax-match-test syntax)
                                 str start)
          (when (and start1 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)))
  