Close bug#5755.
[emacs.git] / lisp / hi-lock.el
blobde4e2ff0dfd29be3720ab2048c1541223cd29366
1 ;;; hi-lock.el --- minor mode for interactive automatic highlighting
3 ;; Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 ;; 2008, 2009, 2010 Free Software Foundation, Inc.
6 ;; Author: David M. Koppelman <koppel@ece.lsu.edu>
7 ;; Keywords: faces, minor-mode, matching, display
9 ;; This file is part of GNU Emacs.
11 ;; GNU Emacs is free software: you can redistribute it and/or modify
12 ;; it under the terms of the GNU General Public License as published by
13 ;; the Free Software Foundation, either version 3 of the License, or
14 ;; (at your option) any later version.
16 ;; GNU Emacs is distributed in the hope that it will be useful,
17 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
18 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 ;; GNU General Public License for more details.
21 ;; You should have received a copy of the GNU General Public License
22 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
24 ;;; Commentary:
26 ;; With the hi-lock commands text matching interactively entered
27 ;; regexp's can be highlighted. For example, `M-x highlight-regexp
28 ;; RET clearly RET RET' will highlight all occurrences of `clearly'
29 ;; using a yellow background face. New occurrences of `clearly' will
30 ;; be highlighted as they are typed. `M-x unhighlight-regexp RET'
31 ;; will remove the highlighting. Any existing face can be used for
32 ;; highlighting and a set of appropriate faces is provided. The
33 ;; regexps can be written into the current buffer in a form that will
34 ;; be recognized the next time the corresponding file is read (when
35 ;; file patterns is turned on).
37 ;; Applications:
39 ;; In program source code highlight a variable to quickly see all
40 ;; places it is modified or referenced:
41 ;; M-x highlight-regexp ground_contact_switches_closed RET RET
43 ;; In a shell or other buffer that is showing lots of program
44 ;; output, highlight the parts of the output you're interested in:
45 ;; M-x highlight-regexp Total execution time [0-9]+ RET hi-blue-b RET
47 ;; In buffers displaying tables, highlight the lines you're interested in:
48 ;; M-x highlight-lines-matching-regexp January 2000 RET hi-black-b RET
50 ;; When writing text, highlight personal cliches. This can be
51 ;; amusing.
52 ;; M-x highlight-phrase as can be seen RET RET
54 ;; Setup:
56 ;; Put the following code in your .emacs file. This turns on
57 ;; hi-lock mode and adds a "Regexp Highlighting" entry
58 ;; to the edit menu.
60 ;; (global-hi-lock-mode 1)
62 ;; To enable the use of patterns found in files (presumably placed
63 ;; there by hi-lock) include the following in your .emacs file:
65 ;; (setq hi-lock-file-patterns-policy 'ask)
67 ;; If you get tired of being asked each time a file is loaded replace
68 ;; `ask' with a function that returns t if patterns should be read.
70 ;; You might also want to bind the hi-lock commands to more
71 ;; finger-friendly sequences:
73 ;; (define-key hi-lock-map "\C-z\C-h" 'highlight-lines-matching-regexp)
74 ;; (define-key hi-lock-map "\C-zi" 'hi-lock-find-patterns)
75 ;; (define-key hi-lock-map "\C-zh" 'highlight-regexp)
76 ;; (define-key hi-lock-map "\C-zp" 'highlight-phrase)
77 ;; (define-key hi-lock-map "\C-zr" 'unhighlight-regexp)
78 ;; (define-key hi-lock-map "\C-zb" 'hi-lock-write-interactive-patterns))
80 ;; See the documentation for hi-lock-mode `C-h f hi-lock-mode' for
81 ;; additional instructions.
83 ;; Sample file patterns:
85 ; Hi-lock: (("^;;; .*" (0 (quote hi-black-hb) t)))
86 ; Hi-lock: ( ("make-variable-buffer-\\(local\\)" (0 font-lock-keyword-face)(1 'italic append)))))
87 ; Hi-lock: end
89 ;;; Code:
91 (eval-and-compile
92 (require 'font-lock))
94 (defgroup hi-lock nil
95 "Interactively add and remove font-lock patterns for highlighting text."
96 :link '(custom-manual "(emacs)Highlight Interactively")
97 :group 'font-lock)
99 (defcustom hi-lock-file-patterns-range 10000
100 "Limit of search in a buffer for hi-lock patterns.
101 When a file is visited and hi-lock mode is on, patterns starting
102 up to this limit are added to font-lock's patterns. See documentation
103 of functions `hi-lock-mode' and `hi-lock-find-patterns'."
104 :type 'integer
105 :group 'hi-lock)
107 (defcustom hi-lock-highlight-range 200000
108 "Size of area highlighted by hi-lock when font-lock not active.
109 Font-lock is not active in buffers that do their own highlighting,
110 such as the buffer created by `list-colors-display'. In those buffers
111 hi-lock patterns will only be applied over a range of
112 `hi-lock-highlight-range' characters. If font-lock is active then
113 highlighting will be applied throughout the buffer."
114 :type 'integer
115 :group 'hi-lock)
117 (defcustom hi-lock-exclude-modes
118 '(rmail-mode mime/viewer-mode gnus-article-mode)
119 "List of major modes in which hi-lock will not run.
120 For security reasons since font lock patterns can specify function
121 calls."
122 :type '(repeat symbol)
123 :group 'hi-lock)
125 (defcustom hi-lock-file-patterns-policy 'ask
126 "Specify when hi-lock should use patterns found in file.
127 If `ask', prompt when patterns found in buffer; if bound to a function,
128 use patterns when function returns t (function is called with patterns
129 as first argument); if nil or `never' or anything else, don't use file
130 patterns."
131 :type '(choice (const :tag "Do not use file patterns" never)
132 (const :tag "Ask about file patterns" ask)
133 (function :tag "Function to check file patterns"))
134 :group 'hi-lock
135 :version "22.1")
137 ;; It can have a function value.
138 (put 'hi-lock-file-patterns-policy 'risky-local-variable t)
140 (defgroup hi-lock-faces nil
141 "Faces for hi-lock."
142 :group 'hi-lock
143 :group 'faces)
145 (defface hi-yellow
146 '((((min-colors 88) (background dark))
147 (:background "yellow1" :foreground "black"))
148 (((background dark)) (:background "yellow" :foreground "black"))
149 (((min-colors 88)) (:background "yellow1"))
150 (t (:background "yellow")))
151 "Default face for hi-lock mode."
152 :group 'hi-lock-faces)
154 (defface hi-pink
155 '((((background dark)) (:background "pink" :foreground "black"))
156 (t (:background "pink")))
157 "Face for hi-lock mode."
158 :group 'hi-lock-faces)
160 (defface hi-green
161 '((((min-colors 88) (background dark))
162 (:background "green1" :foreground "black"))
163 (((background dark)) (:background "green" :foreground "black"))
164 (((min-colors 88)) (:background "green1"))
165 (t (:background "green")))
166 "Face for hi-lock mode."
167 :group 'hi-lock-faces)
169 (defface hi-blue
170 '((((background dark)) (:background "light blue" :foreground "black"))
171 (t (:background "light blue")))
172 "Face for hi-lock mode."
173 :group 'hi-lock-faces)
175 (defface hi-black-b
176 '((t (:weight bold)))
177 "Face for hi-lock mode."
178 :group 'hi-lock-faces)
180 (defface hi-blue-b
181 '((((min-colors 88)) (:weight bold :foreground "blue1"))
182 (t (:weight bold :foreground "blue")))
183 "Face for hi-lock mode."
184 :group 'hi-lock-faces)
186 (defface hi-green-b
187 '((((min-colors 88)) (:weight bold :foreground "green1"))
188 (t (:weight bold :foreground "green")))
189 "Face for hi-lock mode."
190 :group 'hi-lock-faces)
192 (defface hi-red-b
193 '((((min-colors 88)) (:weight bold :foreground "red1"))
194 (t (:weight bold :foreground "red")))
195 "Face for hi-lock mode."
196 :group 'hi-lock-faces)
198 (defface hi-black-hb
199 '((t (:weight bold :height 1.67 :inherit variable-pitch)))
200 "Face for hi-lock mode."
201 :group 'hi-lock-faces)
203 (defvar hi-lock-file-patterns nil
204 "Patterns found in file for hi-lock. Should not be changed.")
206 (defvar hi-lock-interactive-patterns nil
207 "Patterns provided to hi-lock by user. Should not be changed.")
209 (defvar hi-lock-face-defaults
210 '("hi-yellow" "hi-pink" "hi-green" "hi-blue" "hi-black-b"
211 "hi-blue-b" "hi-red-b" "hi-green-b" "hi-black-hb")
212 "Default faces for hi-lock interactive functions.")
214 ;(dolist (f hi-lock-face-defaults) (unless (facep f) (error "%s not a face" f)))
216 (define-obsolete-variable-alias 'hi-lock-face-history
217 'hi-lock-face-defaults
218 "23.1")
220 (define-obsolete-variable-alias 'hi-lock-regexp-history
221 'regexp-history
222 "23.1")
224 (defvar hi-lock-file-patterns-prefix "Hi-lock"
225 "Search target for finding hi-lock patterns at top of file.")
227 (defvar hi-lock-archaic-interface-message-used nil
228 "True if user alerted that `global-hi-lock-mode' is now the global switch.
229 Earlier versions of hi-lock used `hi-lock-mode' as the global switch;
230 the message is issued if it appears that `hi-lock-mode' is used assuming
231 that older functionality. This variable avoids multiple reminders.")
233 (defvar hi-lock-archaic-interface-deduce nil
234 "If non-nil, sometimes assume that `hi-lock-mode' means `global-hi-lock-mode'.
235 Assumption is made if `hi-lock-mode' used in the *scratch* buffer while
236 a library is being loaded.")
238 (make-variable-buffer-local 'hi-lock-interactive-patterns)
239 (put 'hi-lock-interactive-patterns 'permanent-local t)
240 (make-variable-buffer-local 'hi-lock-file-patterns)
241 (put 'hi-lock-file-patterns 'permanent-local t)
243 (defvar hi-lock-menu (make-sparse-keymap "Hi Lock")
244 "Menu for hi-lock mode.")
246 (define-key-after hi-lock-menu [highlight-regexp]
247 '(menu-item "Highlight Regexp..." highlight-regexp
248 :help "Highlight text matching PATTERN (a regexp)."))
250 (define-key-after hi-lock-menu [highlight-phrase]
251 '(menu-item "Highlight Phrase..." highlight-phrase
252 :help "Highlight text matching PATTERN (a regexp processed to match phrases)."))
254 (define-key-after hi-lock-menu [highlight-lines-matching-regexp]
255 '(menu-item "Highlight Lines..." highlight-lines-matching-regexp
256 :help "Highlight lines containing match of PATTERN (a regexp)."))
258 (define-key-after hi-lock-menu [unhighlight-regexp]
259 '(menu-item "Remove Highlighting..." unhighlight-regexp
260 :help "Remove previously entered highlighting pattern."
261 :enable hi-lock-interactive-patterns))
263 (define-key-after hi-lock-menu [hi-lock-write-interactive-patterns]
264 '(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
265 :help "Insert interactively added REGEXPs into buffer at point."
266 :enable hi-lock-interactive-patterns))
268 (define-key-after hi-lock-menu [hi-lock-find-patterns]
269 '(menu-item "Patterns from Buffer" hi-lock-find-patterns
270 :help "Use patterns (if any) near top of buffer."))
272 (defvar hi-lock-map (make-sparse-keymap "Hi Lock")
273 "Key map for hi-lock.")
275 (define-key hi-lock-map "\C-xwi" 'hi-lock-find-patterns)
276 (define-key hi-lock-map "\C-xwl" 'highlight-lines-matching-regexp)
277 (define-key hi-lock-map "\C-xwp" 'highlight-phrase)
278 (define-key hi-lock-map "\C-xwh" 'highlight-regexp)
279 (define-key hi-lock-map "\C-xwr" 'unhighlight-regexp)
280 (define-key hi-lock-map "\C-xwb" 'hi-lock-write-interactive-patterns)
282 ;; Visible Functions
284 ;;;###autoload
285 (define-minor-mode hi-lock-mode
286 "Toggle minor mode for interactively adding font-lock highlighting patterns.
288 If ARG positive, turn hi-lock on. Issuing a hi-lock command will also
289 turn hi-lock on. To turn hi-lock on in all buffers use
290 `global-hi-lock-mode' or in your .emacs file (global-hi-lock-mode 1).
291 When hi-lock is turned on, a \"Regexp Highlighting\" submenu is added
292 to the \"Edit\" menu. The commands in the submenu, which can be
293 called interactively, are:
295 \\[highlight-regexp] REGEXP FACE
296 Highlight matches of pattern REGEXP in current buffer with FACE.
298 \\[highlight-phrase] PHRASE FACE
299 Highlight matches of phrase PHRASE in current buffer with FACE.
300 (PHRASE can be any REGEXP, but spaces will be replaced by matches
301 to whitespace and initial lower-case letters will become case insensitive.)
303 \\[highlight-lines-matching-regexp] REGEXP FACE
304 Highlight lines containing matches of REGEXP in current buffer with FACE.
306 \\[unhighlight-regexp] REGEXP
307 Remove highlighting on matches of REGEXP in current buffer.
309 \\[hi-lock-write-interactive-patterns]
310 Write active REGEXPs into buffer as comments (if possible). They may
311 be read the next time file is loaded or when the \\[hi-lock-find-patterns] command
312 is issued. The inserted regexps are in the form of font lock keywords.
313 (See `font-lock-keywords'.) They may be edited and re-loaded with \\[hi-lock-find-patterns],
314 any valid `font-lock-keywords' form is acceptable. When a file is
315 loaded the patterns are read if `hi-lock-file-patterns-policy' is
316 'ask and the user responds y to the prompt, or if
317 `hi-lock-file-patterns-policy' is bound to a function and that
318 function returns t.
320 \\[hi-lock-find-patterns]
321 Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
323 When hi-lock is started and if the mode is not excluded or patterns
324 rejected, the beginning of the buffer is searched for lines of the
325 form:
326 Hi-lock: FOO
327 where FOO is a list of patterns. These are added to the font lock
328 keywords already present. The patterns must start before position
329 \(number of characters into buffer) `hi-lock-file-patterns-range'.
330 Patterns will be read until
331 Hi-lock: end
332 is found. A mode is excluded if it's in the list `hi-lock-exclude-modes'."
333 :group 'hi-lock
334 :lighter (:eval (if (or hi-lock-interactive-patterns
335 hi-lock-file-patterns)
336 " Hi" ""))
337 :global nil
338 :keymap hi-lock-map
339 (when (and (equal (buffer-name) "*scratch*")
340 load-in-progress
341 (not (called-interactively-p 'interactive))
342 (not hi-lock-archaic-interface-message-used))
343 (setq hi-lock-archaic-interface-message-used t)
344 (if hi-lock-archaic-interface-deduce
345 (global-hi-lock-mode hi-lock-mode)
346 (warn
347 "Possible archaic use of (hi-lock-mode).
348 Use (global-hi-lock-mode 1) in .emacs to enable hi-lock for all buffers,
349 use (hi-lock-mode 1) for individual buffers. For compatibility with Emacs
350 versions before 22 use the following in your .emacs file:
352 (if (functionp 'global-hi-lock-mode)
353 (global-hi-lock-mode 1)
354 (hi-lock-mode 1))
355 ")))
356 (if hi-lock-mode
357 ;; Turned on.
358 (progn
359 (unless font-lock-mode (font-lock-mode 1))
360 (define-key-after menu-bar-edit-menu [hi-lock]
361 (cons "Regexp Highlighting" hi-lock-menu))
362 (hi-lock-find-patterns)
363 (add-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook nil t))
364 ;; Turned off.
365 (when (or hi-lock-interactive-patterns
366 hi-lock-file-patterns)
367 (when hi-lock-interactive-patterns
368 (font-lock-remove-keywords nil hi-lock-interactive-patterns)
369 (setq hi-lock-interactive-patterns nil))
370 (when hi-lock-file-patterns
371 (font-lock-remove-keywords nil hi-lock-file-patterns)
372 (setq hi-lock-file-patterns nil))
373 (remove-overlays nil nil 'hi-lock-overlay t)
374 (when font-lock-fontified (font-lock-fontify-buffer)))
375 (define-key-after menu-bar-edit-menu [hi-lock] nil)
376 (remove-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook t)))
378 ;;;###autoload
379 (define-globalized-minor-mode global-hi-lock-mode
380 hi-lock-mode turn-on-hi-lock-if-enabled
381 :group 'hi-lock)
383 (defun turn-on-hi-lock-if-enabled ()
384 (setq hi-lock-archaic-interface-message-used t)
385 (unless (memq major-mode hi-lock-exclude-modes)
386 (hi-lock-mode 1)))
388 ;;;###autoload
389 (defalias 'highlight-lines-matching-regexp 'hi-lock-line-face-buffer)
390 ;;;###autoload
391 (defun hi-lock-line-face-buffer (regexp &optional face)
392 "Set face of all lines containing a match of REGEXP to FACE.
394 Interactively, prompt for REGEXP then FACE. Buffer-local history
395 list maintained for regexps, global history maintained for faces.
396 \\<minibuffer-local-map>Use \\[previous-history-element] to retrieve previous history items,
397 and \\[next-history-element] to retrieve default values.
398 \(See info node `Minibuffer History'.)"
399 (interactive
400 (list
401 (hi-lock-regexp-okay
402 (read-regexp "Regexp to highlight line" (car regexp-history)))
403 (hi-lock-read-face-name)))
404 (or (facep face) (setq face 'hi-yellow))
405 (unless hi-lock-mode (hi-lock-mode 1))
406 (hi-lock-set-pattern
407 ;; The \\(?:...\\) grouping construct ensures that a leading ^, +, * or ?
408 ;; or a trailing $ in REGEXP will be interpreted correctly.
409 (concat "^.*\\(?:" regexp "\\).*$") face))
412 ;;;###autoload
413 (defalias 'highlight-regexp 'hi-lock-face-buffer)
414 ;;;###autoload
415 (defun hi-lock-face-buffer (regexp &optional face)
416 "Set face of each match of REGEXP to FACE.
418 Interactively, prompt for REGEXP then FACE. Buffer-local history
419 list maintained for regexps, global history maintained for faces.
420 \\<minibuffer-local-map>Use \\[previous-history-element] to retrieve previous history items,
421 and \\[next-history-element] to retrieve default values.
422 \(See info node `Minibuffer History'.)"
423 (interactive
424 (list
425 (hi-lock-regexp-okay
426 (read-regexp "Regexp to highlight" (car regexp-history)))
427 (hi-lock-read-face-name)))
428 (or (facep face) (setq face 'hi-yellow))
429 (unless hi-lock-mode (hi-lock-mode 1))
430 (hi-lock-set-pattern regexp face))
432 ;;;###autoload
433 (defalias 'highlight-phrase 'hi-lock-face-phrase-buffer)
434 ;;;###autoload
435 (defun hi-lock-face-phrase-buffer (regexp &optional face)
436 "Set face of each match of phrase REGEXP to FACE.
438 Whitespace in REGEXP converted to arbitrary whitespace and initial
439 lower-case letters made case insensitive."
440 (interactive
441 (list
442 (hi-lock-regexp-okay
443 (hi-lock-process-phrase
444 (read-regexp "Phrase to highlight" (car regexp-history))))
445 (hi-lock-read-face-name)))
446 (or (facep face) (setq face 'hi-yellow))
447 (unless hi-lock-mode (hi-lock-mode 1))
448 (hi-lock-set-pattern regexp face))
450 (declare-function x-popup-menu "menu.c" (position menu))
452 ;;;###autoload
453 (defalias 'unhighlight-regexp 'hi-lock-unface-buffer)
454 ;;;###autoload
455 (defun hi-lock-unface-buffer (regexp)
456 "Remove highlighting of each match to REGEXP set by hi-lock.
458 Interactively, prompt for REGEXP. Buffer-local history of inserted
459 regexp's maintained. Will accept only regexps inserted by hi-lock
460 interactive functions. \(See `hi-lock-interactive-patterns'.\)
461 \\<minibuffer-local-must-match-map>Use \\[minibuffer-complete] to complete a partially typed regexp.
462 \(See info node `Minibuffer History'.\)"
463 (interactive
464 (if (and (display-popup-menus-p) (not last-nonmenu-event))
465 (catch 'snafu
467 (x-popup-menu
469 (cons
470 `keymap
471 (cons "Select Pattern to Unhighlight"
472 (mapcar (lambda (pattern)
473 (list (car pattern)
474 (format
475 "%s (%s)" (car pattern)
476 (symbol-name
477 (car
478 (cdr (car (cdr (car (cdr pattern))))))))
479 (cons nil nil)
480 (car pattern)))
481 hi-lock-interactive-patterns))))
482 ;; If the user clicks outside the menu, meaning that they
483 ;; change their mind, x-popup-menu returns nil, and
484 ;; interactive signals a wrong number of arguments error.
485 ;; To prevent that, we return an empty string, which will
486 ;; effectively disable the rest of the function.
487 (throw 'snafu '(""))))
488 (let ((history-list (mapcar (lambda (p) (car p))
489 hi-lock-interactive-patterns)))
490 (unless hi-lock-interactive-patterns
491 (error "No highlighting to remove"))
492 (list
493 (completing-read "Regexp to unhighlight: "
494 hi-lock-interactive-patterns nil t
495 (car (car hi-lock-interactive-patterns))
496 (cons 'history-list 1))))))
497 (let ((keyword (assoc regexp hi-lock-interactive-patterns)))
498 (when keyword
499 (font-lock-remove-keywords nil (list keyword))
500 (setq hi-lock-interactive-patterns
501 (delq keyword hi-lock-interactive-patterns))
502 (remove-overlays
503 nil nil 'hi-lock-overlay-regexp (hi-lock-string-serialize regexp))
504 (when font-lock-fontified (font-lock-fontify-buffer)))))
506 ;;;###autoload
507 (defun hi-lock-write-interactive-patterns ()
508 "Write interactively added patterns, if any, into buffer at point.
510 Interactively added patterns are those normally specified using
511 `highlight-regexp' and `highlight-lines-matching-regexp'; they can
512 be found in variable `hi-lock-interactive-patterns'."
513 (interactive)
514 (if (null hi-lock-interactive-patterns)
515 (error "There are no interactive patterns"))
516 (let ((beg (point)))
517 (mapc
518 (lambda (pattern)
519 (insert (format "%s: (%s)\n"
520 hi-lock-file-patterns-prefix
521 (prin1-to-string pattern))))
522 hi-lock-interactive-patterns)
523 (comment-region beg (point)))
524 (when (> (point) hi-lock-file-patterns-range)
525 (warn "Inserted keywords not close enough to top of file")))
527 ;; Implementation Functions
529 (defun hi-lock-process-phrase (phrase)
530 "Convert regexp PHRASE to a regexp that matches phrases.
532 Blanks in PHRASE replaced by regexp that matches arbitrary whitespace
533 and initial lower-case letters made case insensitive."
534 (let ((mod-phrase nil))
535 (setq mod-phrase
536 (replace-regexp-in-string
537 "\\<[a-z]" (lambda (m) (format "[%s%s]" (upcase m) m)) phrase))
538 (setq mod-phrase
539 (replace-regexp-in-string
540 "\\s-+" "[ \t\n]+" mod-phrase nil t))))
542 (defun hi-lock-regexp-okay (regexp)
543 "Return REGEXP if it appears suitable for a font-lock pattern.
545 Otherwise signal an error. A pattern that matches the null string is
546 not suitable."
547 (if (string-match regexp "")
548 (error "Regexp cannot match an empty string")
549 regexp))
551 (defun hi-lock-read-face-name ()
552 "Read face name from minibuffer with completion and history."
553 (intern (completing-read
554 "Highlight using face: "
555 obarray 'facep t
556 (cons (car hi-lock-face-defaults)
557 (let ((prefix
558 (try-completion
559 (substring (car hi-lock-face-defaults) 0 1)
560 hi-lock-face-defaults)))
561 (if (and (stringp prefix)
562 (not (equal prefix (car hi-lock-face-defaults))))
563 (length prefix) 0)))
564 'face-name-history
565 (cdr hi-lock-face-defaults))))
567 (defvar hi-lock--inhibit-font-lock-hook nil
568 "Inhibit the action of `hi-lock-font-lock-hook'.
569 This is used by `hi-lock-set-pattern'.")
571 (defun hi-lock-set-pattern (regexp face)
572 "Highlight REGEXP with face FACE."
573 (let ((pattern (list regexp (list 0 (list 'quote face) t)))
574 ;; The call to `font-lock-add-keywords' below might disable
575 ;; and re-enable font-lock mode. If so, we don't want
576 ;; `hi-lock-font-lock-hook' to run. This can be removed once
577 ;; Bug#635 is fixed. -- cyd
578 (hi-lock--inhibit-font-lock-hook t))
579 (unless (member pattern hi-lock-interactive-patterns)
580 (font-lock-add-keywords nil (list pattern) t)
581 (push pattern hi-lock-interactive-patterns)
582 (if font-lock-fontified
583 (font-lock-fontify-buffer)
584 (let* ((serial (hi-lock-string-serialize regexp))
585 (range-min (- (point) (/ hi-lock-highlight-range 2)))
586 (range-max (+ (point) (/ hi-lock-highlight-range 2)))
587 (search-start
588 (max (point-min)
589 (- range-min (max 0 (- range-max (point-max))))))
590 (search-end
591 (min (point-max)
592 (+ range-max (max 0 (- (point-min) range-min))))))
593 (save-excursion
594 (goto-char search-start)
595 (while (re-search-forward regexp search-end t)
596 (let ((overlay (make-overlay (match-beginning 0) (match-end 0))))
597 (overlay-put overlay 'hi-lock-overlay t)
598 (overlay-put overlay 'hi-lock-overlay-regexp serial)
599 (overlay-put overlay 'face face))
600 (goto-char (match-end 0)))))))))
602 (defun hi-lock-set-file-patterns (patterns)
603 "Replace file patterns list with PATTERNS and refontify."
604 (when (or hi-lock-file-patterns patterns)
605 (font-lock-remove-keywords nil hi-lock-file-patterns)
606 (setq hi-lock-file-patterns patterns)
607 (font-lock-add-keywords nil hi-lock-file-patterns t)
608 (font-lock-fontify-buffer)))
610 (defun hi-lock-find-patterns ()
611 "Find patterns in current buffer for hi-lock."
612 (interactive)
613 (unless (memq major-mode hi-lock-exclude-modes)
614 (let ((all-patterns nil)
615 (target-regexp (concat "\\<" hi-lock-file-patterns-prefix ":")))
616 (save-excursion
617 (save-restriction
618 (widen)
619 (goto-char (point-min))
620 (re-search-forward target-regexp
621 (+ (point) hi-lock-file-patterns-range) t)
622 (beginning-of-line)
623 (while (and (re-search-forward target-regexp (+ (point) 100) t)
624 (not (looking-at "\\s-*end")))
625 (condition-case nil
626 (setq all-patterns (append (read (current-buffer)) all-patterns))
627 (error (message "Invalid pattern list expression at %d"
628 (line-number-at-pos)))))))
629 (when (and all-patterns
630 hi-lock-mode
631 (cond
632 ((eq this-command 'hi-lock-find-patterns) t)
633 ((functionp hi-lock-file-patterns-policy)
634 (funcall hi-lock-file-patterns-policy all-patterns))
635 ((eq hi-lock-file-patterns-policy 'ask)
636 (y-or-n-p "Add patterns from this buffer to hi-lock? "))
637 (t nil)))
638 (hi-lock-set-file-patterns all-patterns)
639 (if (called-interactively-p 'interactive)
640 (message "Hi-lock added %d patterns." (length all-patterns)))))))
642 (defun hi-lock-font-lock-hook ()
643 "Add hi-lock patterns to font-lock's."
644 (unless hi-lock--inhibit-font-lock-hook
645 (if font-lock-mode
646 (progn
647 (font-lock-add-keywords nil hi-lock-file-patterns t)
648 (font-lock-add-keywords nil hi-lock-interactive-patterns t))
649 (hi-lock-mode -1))))
651 (defvar hi-lock-string-serialize-hash
652 (make-hash-table :test 'equal)
653 "Hash table used to assign unique numbers to strings.")
655 (defvar hi-lock-string-serialize-serial 1
656 "Number assigned to last new string in call to `hi-lock-string-serialize'.
657 A string is considered new if it had not previously been used in a call to
658 `hi-lock-string-serialize'.")
660 (defun hi-lock-string-serialize (string)
661 "Return unique serial number for STRING."
662 (interactive)
663 (let ((val (gethash string hi-lock-string-serialize-hash)))
664 (if val val
665 (puthash string
666 (setq hi-lock-string-serialize-serial
667 (1+ hi-lock-string-serialize-serial))
668 hi-lock-string-serialize-hash)
669 hi-lock-string-serialize-serial)))
671 (defun hi-lock-unload-function ()
672 "Unload the Hi-Lock library."
673 (global-hi-lock-mode -1)
674 ;; continue standard unloading
675 nil)
677 (provide 'hi-lock)
679 ;; arch-tag: d2e8fd07-4cc9-4c6f-a200-1e729bc54066
680 ;;; hi-lock.el ends here