anchor.diff:         (get-bvar :enable-syntax-highlight :buffer buffer)))
   
   (defun syntax-scan-window (window)
  +  (check-type window window)
     (when (enable-syntax-highlight-p (window-buffer window))
       (with-window-range (start-linum end-linum) window
         (syntax-scan-lines (window-buffer window) start-linum end-linum))))
   
  -(defun syntax-scan-lines (buffer start-linum end-linum)
  +(defun syntax-scan-buffer (buffer)
  +  (check-type buffer buffer)
     (when (enable-syntax-highlight-p buffer)
  -    (let* ((line (buffer-get-line buffer start-linum))
  -           (prev (line-prev line))
  -           (*syntax-symbol-lifetimes* (and prev (line-%symbol-lifetimes prev))))
  -      (do ((line line (line-next line))
  -           (linum start-linum (1+ linum)))
  -          ((or (null line)
  -               (= linum end-linum)))
  -        (syntax-scan-line line)))))
  -
  -(defun syntax-scan-buffer (buffer)
  -  (when (enable-syntax-highlight-p buffer)
  -    (map-buffer #'(lambda (line linum)
  -                    (declare (ignore linum))
  -                    (syntax-scan-line line))
  -                buffer)))
  +    (syntax-scan-lines buffer 1 (point-linum (point-max buffer)))))
   
   (defun syntax-update-symbol-lifetimes ()
     (setq *syntax-symbol-lifetimes*
           (loop :for (symbol . lifetime) :in *syntax-symbol-lifetimes*
             :when (/= 0 lifetime)
             :collect (cons symbol (1- lifetime)))))
  -
  -(defun syntax-matched-word (line syntax start end)
  -  (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)))
  -  (line-add-property line start end :attribute (syntax-attribute syntax))
  -  t)
   
   (defun syntax-position-word-end (str start)
     (or (position-if-not #'syntax-symbol-char-p str
  
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-table))
  
  (defun syntax-add-match (syntax-table test &key test-symbol end-symbol attribute
                                        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
                         :move-action move-action)
          (syntax-table-match-list syntax-table))
    t)
  
  