xemacs-beta: lisp/packages/lazy-lock.el comparison

comparison lisp/packages/lazy-lock.el @ 12:bcdc7deadc19 r19-15b7

Import from CVS: tag r19-15b7

author	cvs
date	Mon, 13 Aug 2007 08:48:16 +0200
parents	ac2d302a0011
children	4103f0995bd7

comparison

equal deleted inserted replaced

-:91ffe8bd52e4
+:bcdc7deadc19
 ;; Copyright (C) 1994, 1995 Free Software Foundation, Inc.
 ;; Author: Simon Marshall <simon@gnu.ai.mit.edu>
 ;; Keywords: faces files
-;; Version: 1.14
+;; Version: 1.15
 ;; LCD Archive Entry:
 ;; lazy-lock|Simon Marshall|simon@gnu.ai.mit.edu|
 ;; Lazy Font Lock mode (with fast demand-driven fontification).|
-;; 13-Oct-95|1.14|~/modes/lazy-lock.el.Z|
+;; 13-Nov-95|1.15|~/modes/lazy-lock.el.Z|
 ;; The archive is archive.cis.ohio-state.edu in /pub/gnu/emacs/elisp-archive.
 ;;; This file is part of GNU Emacs.
 ;; GNU General Public License for more details.
 ;; You should have received a copy of the GNU General Public License
 ;; along with GNU Emacs; see the file COPYING.  If not, write to
 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
-;;; Synched up with: Not in FSF. (This seems very strange to me.)
 ;;; Commentary:
 ;; Purpose:
 ;;
 ;; - Made `font-lock-beginning-of-syntax-function' wrapped for fontification.
 ;; - Added `lazy-lock-stealth-verbose' (after harassment from Ben Wing).
 ;; - XEmacs: Made `font-lock-verbose' wrapped for stealth fontification.
 ;; 1.13--1.14:
 ;; - Wrap `lazy-lock-colour-invisible' for `set-face-foreground' (Jari Aalto).
+;; 1.14--1.15:
+;; - Made `lazy-lock-post-command-setup'; may add to `post-command-idle-hook'.
 (require 'font-lock)
 (eval-when-compile
 ;; Only `require' so `ediff-multiframe-setup-p' is expanded at compile time.
 (defun lazy-lock-submit-bug-report ()
 "Submit via mail a bug report on lazy-lock.el."
 (interactive)
 (require 'reporter)
 (let ((reporter-prompt-for-summary-p t))
-(reporter-submit-bug-report "simon@gnu.ai.mit.edu" "lazy-lock 1.14"
+(reporter-submit-bug-report "simon@gnu.ai.mit.edu" "lazy-lock 1.15"
 '(lazy-lock-walk-windows lazy-lock-continuity-time
 lazy-lock-stealth-time lazy-lock-stealth-nice
 lazy-lock-stealth-lines lazy-lock-stealth-verbose
 lazy-lock-hide-invisible lazy-lock-invisible-foreground
 lazy-lock-minimum-size lazy-lock-ignore-commands)
 know how to make a clear and unambiguous report.  To reproduce the bug:
 Start a fresh Emacs via `" invocation-name " -no-init-file -no-site-file'.
 In the `*scratch*' buffer, evaluate:"))))
-;; Let's define `emacs-major-version', `emacs-minor-version', and
+;; Let's define `emacs-minor-version' if no-one else has.
-;; `emacs-version>=' if no-one else has.
-(if (not (boundp 'emacs-major-version))
-(eval-and-compile
-(defconst emacs-major-version
-	(progn (or (string-match "^[0-9]+" emacs-version)
-		   (error "emacs-version unparsable"))
-	       (string-to-int (match-string 0 emacs-version)))
-	"Major version number of this version of Emacs, as an integer.
-Warning, this variable did not exist in Emacs versions earlier than:
-FSF Emacs:   19.23
-XEmacs:      19.10")))
 (if (not (boundp 'emacs-minor-version))
 (eval-and-compile
 (defconst emacs-minor-version
-	(progn (or (string-match "^[0-9]+\\.\\([0-9]+\\)" emacs-version)
+	(save-match-data
-		   (error "emacs-version unparsable"))
+	  (string-match "^[0-9]+\\.\\([0-9]+\\)" emacs-version)
-	       (string-to-int (match-string 1 emacs-version)))
+	  (string-to-int
-	"Minor version number of this version of Emacs, as an integer.
+	   (substring emacs-version (match-beginning 1) (match-end 1)))))))
-Warning, this variable did not exist in Emacs versions earlier than:
-FSF Emacs:   19.23
-XEmacs:      19.10")))
-(if (not (fboundp 'emacs-version>=))
-(eval-and-compile
-(defun emacs-version>= (major &optional minor)
-	"Return true if the Emacs version is >= to the given MAJOR and MINOR numbers.
-The MAJOR version number argument is required, but the MINOR version number
-argument is optional.  If the minor version number is not specified (or is the
-symbol `nil') then only the major version numbers are considered in the test."
-	(if (null minor)
-	    (>= emacs-major-version major)
-	  (or (> emacs-major-version major)
-	      (and (=  emacs-major-version major)
-		   (>= emacs-minor-version minor))
-	      )
-	  ))))
 ;; Yuck, but we make so much use of this variable it's probably worth it.
 (eval-and-compile
 (defconst lazy-lock-running-xemacs-p
 (not (null (save-match-data (string-match "Lucid" emacs-version))))))
 (defvar lazy-lock-cache-start nil)	; for window fontifiction
 (defvar lazy-lock-cache-end nil)	; for window fontifiction
 (defvar lazy-lock-cache-continue nil)	; for stealth fontifiction
+;; XEmacs change
 ;;;###autoload
 (defvar lazy-lock-mode nil)		; for modeline
 ;; User Variables:
 If `all-frames', fontify windows even on other frames.
 A non-nil value slows down redisplay.")
 ;; XEmacs 19.11 and below exercise a bug in the Xt event loop.
 (defvar lazy-lock-continuity-time
-(if (or (not lazy-lock-running-xemacs-p) (emacs-version>= 19 12))
+(if (or (not lazy-lock-running-xemacs-p) (> emacs-minor-version 11))
 0
 (if (featurep 'lisp-float-type) 0.001 1))
 "*Time in seconds to delay before normal window fontification.
 Window fontification occurs if there is no input within this time.")
 ;; `previous-single-property-change' at `point-min' up to Emacs 19.25 is fatal.
 ;; `text-property-any', `text-property-not-all' and
 ;; `next-single-property-change' up to XEmacs 19.11 are too broke.
 (defvar lazy-lock-stealth-time
-(if (emacs-version>= 19 (if lazy-lock-running-xemacs-p 12 26)) 30)
+(if (> emacs-minor-version (if lazy-lock-running-xemacs-p 11 25)) 30)
 "*Time in seconds to delay before beginning stealth fontification.
 Stealth fontification occurs if there is no input within this time.
 If nil, means no fontification by stealth.")
 (defvar lazy-lock-stealth-lines
 (if (and lazy-lock-mode (not font-lock-mode))
 ;; Turned on `lazy-lock-mode' rather than using `font-lock-mode-hook'.
 (progn
 	(add-hook 'font-lock-mode-hook 'turn-on-lazy-lock)
 	(font-lock-mode 1))
-(lazy-lock-fixup-hooks)
 ;; Let's get down to business.
+(lazy-lock-post-command-setup)
 (if (not lazy-lock-mode)
 	(let ((modified (buffer-modified-p)) (inhibit-read-only t)
 	      (buffer-undo-list t)
 	      deactivate-mark buffer-file-name buffer-file-truename)
 	  (remove-text-properties (point-min) (point-max) '(fontified nil))
 ;;;###autoload
 (defun turn-on-lazy-lock ()
 "Unconditionally turn on Lazy Lock mode."
 (lazy-lock-mode 1))
-(if (not (emacs-version>= 19 (if lazy-lock-running-xemacs-p 12 29)))
+(if (< emacs-minor-version (if lazy-lock-running-xemacs-p 12 29))
 ;; We don't need this in Emacs 19.29 or XEmacs 19.12.
 (defun lazy-lock-fontify-buffer ()
 "Fontify the current buffer where necessary."
 (interactive)
 (lazy-lock-fontify-region (point-min) (point-max))))
 ;; API Functions:
-(defun lazy-lock-fixup-hooks ()
-;; Make sure our hooks are correct.
-(remove-hook 'pre-idle-hook 'lazy-lock-pre-idle-fontify-windows)
-(remove-hook 'post-command-hook 'lazy-lock-post-command-fontify-stealthily)
-;; Make sure our hooks are at the end.  Font-lock in XEmacs installs
-;; its own pre-idle-hook to implement deferral (#### something that
-;; should really be merged with this file; or more likely, lazy-lock
-;; in its entirety should be merged into font-lock).
-(add-hook 'pre-idle-hook 'lazy-lock-pre-idle-fontify-windows t)
-(add-hook 'post-command-hook 'lazy-lock-post-command-fontify-stealthily t)
-;; Fascistically remove font-lock's after-change-function and install
-;; our own.  We know better than font-lock what to do.  Otherwise,
-;; revert-buffer, insert-file, etc. cause full refontification of the
-;; entire changed area.
-(if lazy-lock-mode
-(progn
-	(remove-hook 'after-change-functions 'font-lock-after-change-function
-		     t)
-	(make-local-hook 'after-change-functions)
-	(add-hook 'after-change-functions 'lazy-lock-after-change-function
-		  nil t))
-(remove-hook 'after-change-functions 'lazy-lock-after-change-function t)
-(if font-lock-mode
-	(add-hook 'after-change-functions 'font-lock-after-change-function
-		  nil t)))
-)
-;; use put-nonduplicable-text-property to avoid unfriendly behavior
-;; when doing undo, etc.  We really don't want syntax-highlighting text
-;; properties copied into strings or tracked by undo.
-;;
-;; #### If start-open and end-open really behaved like they are supposed to,
-;; we wouldn't really need this.  I kind of fixed them up, but there's still
-;; a bug -- inserting text into the middle of a region of
-;; (start-open t end-open t) text should cause it not to inherit, but it
-;; does.
-(if lazy-lock-running-xemacs-p
-(defalias 'lazy-lock-put-text-property 'put-nonduplicable-text-property)
-(defalias 'lazy-lock-put-text-property 'put-text-property))
 (defun lazy-lock-fontify-region (start end &optional buffer)
 "Fontify between START and END in BUFFER where necessary."
 (save-excursion
 (and buffer (set-buffer buffer))
 (defun lazy-lock-after-fontify-buffer ()
 ;; Mark the buffer as `fontified'.
 (let ((modified (buffer-modified-p)) (inhibit-read-only t)
 	(buffer-undo-list t)
 	deactivate-mark buffer-file-name buffer-file-truename)
-(lazy-lock-put-text-property (point-min) (point-max) 'fontified t)
+(put-text-property (point-min) (point-max) 'fontified t)
 (or modified (set-buffer-modified-p nil))))
 ;; Just a cleaner-looking way of coping with Emacs' and XEmacs' `sit-for'.
 (defmacro lazy-lock-sit-for (seconds &optional nodisp)
 (if lazy-lock-running-xemacs-p
 	     (select-window original-window))))))
 (put 'save-selected-window 'lisp-indent-function 0))
 ;; Functions for hooks:
-;; lazy-lock optimization:
+(defun lazy-lock-post-command-fontify-windows ()
-;;
+;; We might not be where we think we are, since `post-command-hook' is run
-;; pre-idle-hook is called an awful lot -- pretty much every time the
+;; before `command_loop_1' makes sure we have the correct buffer selected.
-;; mouse moves or a timeout expires, for example.  On Linux (sometimes),
+(set-buffer (window-buffer))
-;; IRIX 5.x, and Solaris 2.something, it happens every 1/4 of a second
+;; Do groovy things if (a) not in a macro, (b) no input pending, (c) got a
-;; due to the 1/4-second timers installed to compensate for various
+;; real command, (d) not in the minibuffer, and (e) no input after waiting
-;; operating system deficiencies in the handling of SIGIO and SIGCHLD.
+;; for `lazy-lock-continuity-time'.
-;; (Those timers cause a cycle of the event loop.  They don't necessarily
+(if (or executing-kbd-macro
-;; have to, but rewriting to avoid this is fairly tricky and requires
+	  (input-pending-p)
-;; having significant amounts of code called from signal handlers, which
+	  (memq this-command lazy-lock-ignore-commands)
-;; (despite that fact that FSF Emacs reads its X input during a signal
+	  (window-minibuffer-p (selected-window)))
-;; handler ?!), is almost always a bad idea -- it's extremely easy to
-;; introduce race conditions, which are very hard to track down.
-;;
-;; So to improve things, I added `frame-modified-tick'.  This is an
-;; internal counter that gets ticked any time that any internal
-;; redisplay variable gets ticked.  If `frame-modified-tick' is
-;; the same as the last time we checked, it means that redisplay will
-;; do absolutely nothing when encountering this frame, and thus we
-;; can skip out immediately.  This happens when the 1/4-second timer
-;; fires while we're idle, or if we just move the mouse. (Moving
-;; around in a buffer changes `frame-modified-tick' because the
-;; internal redisplay variable "point_changed" gets ticked.  We could
-;; easily improve things further by adding more tick counters, mirroring
-;; more closely the internal redisplay counters -- e.g. if we had
-;; another counter that didn't get ticked when point moved, we could
-;; tell if anything was going to happen by seeing if point is within
-;; window-start and window-end, since we know that redisplay will
-;; only do a window-scroll if it's not. (If window-start or window-end
-;; or window-buffer or anything else changed, windows_changed or
-;; some other variable will get ticked.))
-;;
-;; Also, it's wise to try and avoid things that cons.  Avoiding
-;; `save-window-excursion', as we do, is definitely a major win
-;; because that's a heavy-duty function as regards consing and such.
-(defvar lazy-lock-pre-idle-frame-modified-tick nil)
-(defvar lazy-lock-pre-idle-selected-frame nil)
-(defun lazy-lock-pre-idle-fontify-windows ()
-;; Do groovy things always unless we're in one of the ignored commands.
-;; The old version did the following five checks:
-;;
-;; (a) not in a macro,
-;; (b) no input pending,
-;; (c) got a real command (i.e. not an ignored command)
-;; (d) not in the minibuffer
-;; (e) no input after waiting for `lazy-lock-continuity-time'.
-;;
-;; (a), (b), and (e) are automatically taken care of by `pre-idle-hook'.
-;; I removed (d) because there doesn't seem to be any reason for it.
-;;
-;; Also, we do not have to `set-buffer' and in fact it would be
-;; incorrect to do so, since we may be being called from
-;; `accept-process-output' or whatever.
-;;
-(if (memq this-command lazy-lock-ignore-commands)
 (setq lazy-lock-cache-continue nil)
 (setq lazy-lock-cache-continue t)
-;; #### we don't yet handle frame-modified-tick on multiple frames.
+(if (lazy-lock-sit-for lazy-lock-continuity-time lazy-lock-hide-invisible)
-;; handling this shouldn't be hard but I just haven't done it yet.
+	;; Do the visible parts of the buffer(s), i.e., the window(s).
-(if (or (eq 'all-frames lazy-lock-walk-windows)
+	(if (or (not lazy-lock-walk-windows)
-	    (not (eq lazy-lock-pre-idle-selected-frame (selected-frame)))
+		(and (eq lazy-lock-walk-windows t) (one-window-p t)))
-	    (not (eq lazy-lock-pre-idle-frame-modified-tick
+	    (if lazy-lock-mode (condition-case nil (lazy-lock-fontify-window)))
-		     (frame-modified-tick (selected-frame)))))
+	  (lazy-lock-fontify-walk-windows)))))
-	(progn
-	  ;; Do the visible parts of the buffer(s), i.e., the window(s).
-	  (if (or (not lazy-lock-walk-windows)
-		  (and (eq lazy-lock-walk-windows t) (one-window-p t)))
-	      (if lazy-lock-mode (condition-case nil
-				     (lazy-lock-fontify-window)))
-	    (lazy-lock-fontify-walk-windows))
-	  (setq lazy-lock-pre-idle-selected-frame (selected-frame))
-	  (setq lazy-lock-pre-idle-frame-modified-tick
-		(frame-modified-tick (selected-frame)))))))
-(defun lazy-lock-after-change-function (beg end old-len)
-(and lazy-lock-mode
-(if (= beg end)
-	   (font-lock-after-change-function beg end old-len)
-	 (lazy-lock-put-text-property beg end 'fontified nil))))
-;; DO NOT put this as a pre-idle hook!  The sit-for messes up
-;; mouse dragging.
 (defun lazy-lock-post-command-fontify-stealthily ()
 ;; Do groovy things if (a-d) above, (e) not moving the mouse, and (f) no
-;; input after waiting for `lazy-lock-stealth-time'.
+;; input after after waiting for `lazy-lock-stealth-time'.
 (if (and lazy-lock-cache-continue lazy-lock-stealth-time)
 (condition-case data
 	  (if (lazy-lock-sit-for lazy-lock-stealth-time)
 	      ;; Do the invisible parts of buffers.
 	      (lazy-lock-fontify-walk-stealthily))
 	(error (message "Fontifying stealthily... %s" data)))))
-;; In XEmacs 19.14 with pre-idle-hook we do not have to call this.
 (defun lazy-lock-post-resize-fontify-windows (frame)
 ;; Fontify all windows in FRAME.
 (let ((lazy-lock-walk-windows t) executing-kbd-macro this-command)
 (save-excursion
 (save-selected-window
 	(select-frame frame)
-	(lazy-lock-pre-idle-fontify-windows)))))
+	(lazy-lock-post-command-fontify-windows)))))
 (defun lazy-lock-post-setup-emacs-fontify-windows ()
 ;; Fontify all windows in all frames.
 (let ((lazy-lock-walk-windows 'all-frames) executing-kbd-macro this-command)
-(lazy-lock-pre-idle-fontify-windows)))
+(lazy-lock-post-command-fontify-windows)))
 (defun lazy-lock-post-setup-ediff-control-frame ()
 ;; Fontify all windows in all frames when using the Ediff control frame.
 (make-local-variable 'lazy-lock-walk-windows)
 (setq lazy-lock-walk-windows (if (ediff-multiframe-setup-p) 'all-frames t))
-(lazy-lock-fixup-hooks))
+(lazy-lock-post-command-setup))
+(defun lazy-lock-post-command-setup ()
+;; Make sure that we're in the correct positions to avoid hassle.
+(remove-hook 'post-command-hook 'lazy-lock-post-command-fontify-windows)
+(remove-hook 'post-command-hook 'lazy-lock-post-command-fontify-stealthily)
+(add-hook 'post-command-hook 'lazy-lock-post-command-fontify-windows)
+(add-hook (if (boundp 'post-command-idle-hook)
+		'post-command-idle-hook
+	      'post-command-hook)
+	    'lazy-lock-post-command-fontify-stealthily t))
 ;; Functions for fontification:
 (defun lazy-lock-fontify-window ()
 ;; Fontify the visible part of the buffer where necessary.
 	       font-lock-beginning-of-syntax-function
 	       ;; Prevent XEmacs 19.13 during fontification from messages.
 	       font-lock-verbose)
 	  (while (< start end)
 	    ;; Fontify and flag the region as `fontified'.
-	    ;; XEmacs: need to bind `font-lock-always-fontify-immediately'
+	    (font-lock-after-change-function start end 0)
-	    ;; or we'll mess up in the presence of deferred font-locking.
+	    (put-text-property start end 'fontified t)
-	    (let ((font-lock-always-fontify-immediately t))
-	      (font-lock-after-change-function start end 0))
-	    (lazy-lock-put-text-property start end 'fontified t)
 	    ;; Find the next region.
 	    (setq start (or (text-property-not-all ws we 'fontified t) ws)
 		  end (or (text-property-any start we 'fontified t) we)))
 	  (setq lazy-lock-cache-start ws lazy-lock-cache-end we)
 	  (or modified (set-buffer-modified-p nil))))))
 	     ;; Maybe the region is already partially `fontified'.
 	     (setq start
 	      (or (previous-single-property-change prev 'fontified nil (point))
 		  (point)))))
 ;; Fontify and flag the region as `fontified'.
-;; XEmacs: need to bind `font-lock-always-fontify-immediately'
+(font-lock-after-change-function start end 0)
-;; or we'll mess up in the presence of deferred font-locking.
+(put-text-property start end 'fontified t)
-(let ((font-lock-always-fontify-immediately t))
-	(font-lock-after-change-function start end 0))
-(lazy-lock-put-text-property start end 'fontified t)
 (or modified (set-buffer-modified-p nil)))))
 (defun lazy-lock-fontify-walk-stealthily ()
 ;; Fontify regions in all required buffers while there is no input.
 (let ((buffers (buffer-list)) (continue t) fontified message-log-max)
 (make-face face)
 (if (not (equal (face-foreground face) fore))
 	  (condition-case nil
 	      (set-face-foreground face fore)
 	    (error (message "Unable to use foreground \"%s\"" fore))))
-(lazy-lock-put-text-property (point-min) (point-max) 'face face)
+(put-text-property (point-min) (point-max) 'face face)
-(lazy-lock-put-text-property (point-min) (point-max) 'fontified nil)
+(put-text-property (point-min) (point-max) 'fontified nil)
 (or modified (set-buffer-modified-p nil)))))
 ;; Functions for Emacs:
 ;; This fix is for a number of bugs in the function in Emacs 19.28.
-(if (and (not lazy-lock-running-xemacs-p)
+(if (and (not lazy-lock-running-xemacs-p) (< emacs-minor-version 29))
-	 (not (emacs-version>= 19 29)))
 (defun font-lock-fontify-region (start end &optional loudly)
 "Put proper face on each string and comment between START and END."
 (save-excursion
 	(save-restriction
 	  (widen)
 		  (if (nth 3 state)
 		      (let ((beg (point)))
 			(while (and (re-search-forward "\\s\"" end 'move)
 				    (nth 3 (parse-partial-sexp beg (point) nil nil
 							       state))))
-			(lazy-lock-put-text-property
+			(put-text-property beg (point) 'face font-lock-string-face)
-			 beg (point) 'face font-lock-string-face)
 			(setq state (parse-partial-sexp beg (point)
 							nil nil state))))
 		  ;; Likewise for a comment.
 		  (if (or (nth 4 state) (nth 7 state))
 		      (let ((beg (point)))
 				(forward-comment 1)
 				;; forward-comment skips all whitespace,
 				;; so go back to the real end of the comment.
 				(skip-chars-backward " \t"))
 			    (error (goto-char end))))
-			(lazy-lock-put-text-property beg (point) 'face
+			(put-text-property beg (point) 'face
-						     font-lock-comment-face)
+					   font-lock-comment-face)
 			(setq state (parse-partial-sexp beg (point)
 							nil nil state))))
 		  ;; Find each interesting place between here and END.
 		  (while (and (< (point) end)
 			      (setq prev (point) prevstate state)
 				    (forward-comment 1)
 				    ;; forward-comment skips all whitespace,
 				    ;; so go back to the real end of the comment.
 				    (skip-chars-backward " \t"))
 				(error (goto-char end))))
-			    (lazy-lock-put-text-property
+			    (put-text-property beg (point) 'face
-			     beg (point) 'face font-lock-comment-face)
+					       font-lock-comment-face)
 			    (setq state (parse-partial-sexp here (point)
 							    nil nil state)))
 			(if (nth 3 state)
 			    (let ((beg (match-beginning 0)))
 			      (while (and (re-search-forward "\\s\"" end 'move)
 					  (nth 3 (parse-partial-sexp
 						  here (point) nil nil state))))
-			      (lazy-lock-put-text-property
+			      (put-text-property beg (point) 'face
-			       beg (point) 'face font-lock-string-face)
+						 font-lock-string-face)
 			      (setq state (parse-partial-sexp here (point)
 							      nil nil state))))))
 		    ;; Make sure PREV is non-nil after the loop
 		    ;; only if it was set on the very last iteration.
 		    (setq prev nil)))
 ;; Functions for XEmacs:
 ;; These fix bugs in `text-property-any' and `text-property-not-all'.  They may
 ;; not work perfectly in 19.11 and below because `next-single-property-change'
 ;; is also broke and not easily fixable in Lisp.
-(if (and lazy-lock-running-xemacs-p
+(if (and lazy-lock-running-xemacs-p (< emacs-minor-version 12))
-	 (not (emacs-version>= 19 12)))
 (progn
 ;; Loop through property changes until found.  This fix includes a work
 ;; around which prevents a bug in `window-start' causing a barf here.
 (defun text-property-any (start end prop value &optional buffer)
 	"Check text from START to END to see if PROP is ever `eq' to VALUE.
 ;; XEmacs 19.11 function `font-lock-any-extents-p' looks for `text-prop' rather
 ;; than `face'.  Since `font-lock-unfontify-region' only removes `face', and we
 ;; have non-font-lock properties hanging about, `text-prop' never gets removed.
 ;; Unfortunately `font-lock-any-extents-p' is inlined so we can't redefine it.
-(if (and lazy-lock-running-xemacs-p
+(if (and lazy-lock-running-xemacs-p (< emacs-minor-version 12))
-	 (not (emacs-version>= 19 12)))
 (add-hook 'font-lock-mode-hook
 (function (lambda ()
 	(remove-hook 'after-change-functions 'font-lock-after-change-function)
 	(add-hook 'after-change-functions
 	 (function (lambda (beg end old-len)
 	    (let ((a-c-beg beg) (a-c-end end))
 	      (save-excursion
 		;; First set `text-prop' to nil for `font-lock-any-extents-p'.
 		(goto-char end) (forward-line 1) (setq end (point))
 		(goto-char beg) (beginning-of-line) (setq beg (point))
-		(lazy-lock-put-text-property beg end 'text-prop nil)
+		(put-text-property beg end 'text-prop nil)
 		;; Then do the real `font-lock-after-change-function'.
 		(font-lock-after-change-function a-c-beg a-c-end old-len)
 		;; Now set `fontified' to t to stop `lazy-lock-fontify-window'.
-		(lazy-lock-put-text-property beg end 'fontified t))))))))))
+		(put-text-property beg end 'fontified t))))))))))
-(if (and lazy-lock-running-xemacs-p (emacs-version>= 19 12))
+(if (and lazy-lock-running-xemacs-p (>= emacs-minor-version 12))
 ;; XEmacs 19.12 font-lock.el's `font-lock-fontify-buffer' runs a hook.
 (add-hook 'font-lock-after-fontify-buffer-hook
 	      'lazy-lock-after-fontify-buffer))
 ;; Cope with the differences between Emacs and [LX]Emacs.
 ;; Install ourselves:
 ;; We don't install ourselves on `font-lock-mode-hook' as other packages can be
 ;; used with font-lock.el, and lazy-lock.el should be dumpable without forcing
 ;; people to get lazy or making it difficult for people to use alternatives.
-;; make sure we add after font-lock's own pre-idle-hook.
+;; After a command is run.
+(lazy-lock-post-command-setup)
+;; After some relevant event.
 (add-hook 'window-setup-hook 'lazy-lock-post-setup-emacs-fontify-windows)
-;Not needed in XEmacs 19.14:
+;Not needed in XEmacs 19.15:
 ;(add-hook 'window-size-change-functions 'lazy-lock-post-resize-fontify-windows)
 ;; Package-specific.
 (add-hook 'ediff-after-setup-control-frame-hooks
 	  'lazy-lock-post-setup-ediff-control-frame)

Mercurial > hg > xemacs-beta

comparison lisp/packages/lazy-lock.el @ 12:bcdc7deadc19 r19-15b7