code.delx.au - gnu-emacs/blob - lisp/hi-lock.el

   1 ;;; hi-lock.el --- minor mode for interactive automatic highlighting
   2
   3 ;; Copyright (C) 2000, 2001, 2005  Free Software Foundation, Inc.
   4
   5 ;; Author: David M. Koppelman, koppel@ee.lsu.edu
   6 ;; Keywords: faces, minor-mode, matching, display
   7
   8 ;; This file is part of GNU Emacs.
   9
  10 ;; GNU Emacs is free software; you can redistribute it and/or modify
  11 ;; it under the terms of the GNU General Public License as published by
  12 ;; the Free Software Foundation; either version 2, or (at your option)
  13 ;; any later version.
  14
  15 ;; GNU Emacs is distributed in the hope that it will be useful,
  16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 ;; GNU General Public License for more details.
  19
  20 ;; You should have received a copy of the GNU General Public License
  21 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  22 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  23 ;; Boston, MA 02111-1307, USA.
  24
  25 ;;; Commentary:
  26 ;;
  27 ;;  With the hi-lock commands text matching interactively entered
  28 ;;  regexp's can be highlighted.  For example, `M-x highlight-regexp
  29 ;;  RET clearly RET RET' will highlight all occurrences of `clearly'
  30 ;;  using a yellow background face.  New occurrences of `clearly' will
  31 ;;  be highlighted as they are typed.  `M-x unhighlight-regexp RET'
  32 ;;  will remove the highlighting.  Any existing face can be used for
  33 ;;  highlighting and a set of appropriate faces is provided.  The
  34 ;;  regexps can be written into the current buffer in a form that will
  35 ;;  be recognized the next time the corresponding file is read.
  36 ;;
  37 ;;  Applications:
  38 ;;
  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
  42 ;;
  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
  46 ;;
  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
  49 ;;
  50 ;;    When writing text, highlight personal cliches.  This can be
  51 ;;    amusing.
  52 ;;    M-x highlight-phrase as can be seen RET RET
  53 ;;
  54 ;;  Setup:
  55 ;;
  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.
  59 ;;
  60 ;;    (hi-lock-mode 1)
  61 ;;
  62 ;;    You might also want to bind the hi-lock commands to more
  63 ;;    finger-friendly sequences:
  64
  65 ;;    (define-key hi-lock-map "\C-z\C-h" 'highlight-lines-matching-regexp)
  66 ;;    (define-key hi-lock-map "\C-zi" 'hi-lock-find-patterns)
  67 ;;    (define-key hi-lock-map "\C-zh" 'highlight-regexp)
  68 ;;    (define-key hi-lock-map "\C-zp" 'highlight-phrase)
  69 ;;    (define-key hi-lock-map "\C-zr" 'unhighlight-regexp)
  70 ;;    (define-key hi-lock-map "\C-zb" 'hi-lock-write-interactive-patterns))
  71
  72 ;;    See the documentation for hi-lock-mode `C-h f hi-lock-mode' for
  73 ;;    additional instructions.
  74
  75 ;; Sample file patterns:
  76
  77 ; Hi-lock: (("^;;; .*" (0 (quote hi-black-hb) t)))
  78 ; Hi-lock: ( ("make-variable-buffer-\\(local\\)" (0 font-lock-keyword-face)(1 'italic append)))))
  79 ; Hi-lock: end
  80
  81 ;;; Code:
  82
  83 (eval-and-compile
  84   (require 'font-lock))
  85
  86 (defgroup hi-lock-interactive-text-highlighting nil
  87   "Interactively add and remove font-lock patterns for highlighting text."
  88   :group 'faces)
  89
  90 ;;;###autoload
  91 (defcustom hi-lock-mode nil
  92   "Toggle hi-lock, for interactively adding font-lock text-highlighting patterns."
  93   :set (lambda (symbol value)
  94          (hi-lock-mode (or value 0)))
  95   :initialize 'custom-initialize-default
  96   :type 'boolean
  97   :group 'hi-lock-interactive-text-highlighting
  98   :require 'hi-lock)
  99
 100 (defcustom hi-lock-file-patterns-range 10000
 101   "Limit of search in a buffer for hi-lock patterns.
 102 When a file is visited and hi-lock mode is on patterns starting
 103 up to this limit are added to font-lock's patterns.  See documentation
 104 of functions `hi-lock-mode' and `hi-lock-find-patterns'."
 105   :type 'integer
 106   :group 'hi-lock-interactive-text-highlighting)
 107
 108 (defcustom hi-lock-exclude-modes
 109   '(rmail-mode mime/viewer-mode gnus-article-mode)
 110   "List of major modes in which hi-lock will not run.
 111 For security reasons since font lock patterns can specify function
 112 calls."
 113   :type '(repeat symbol)
 114   :group 'hi-lock-interactive-text-highlighting)
 115
 116
 117 (defgroup hi-lock-faces nil
 118   "Faces for hi-lock."
 119   :group 'hi-lock-interactive-text-highlighting)
 120
 121 (defface hi-yellow
 122   '((((background dark)) (:background "yellow" :foreground "black"))
 123     (t (:background "yellow")))
 124   "Default face for hi-lock mode."
 125   :group 'hi-lock-faces)
 126
 127 (defface hi-pink
 128   '((((background dark)) (:background "pink" :foreground "black"))
 129     (t (:background "pink")))
 130   "Face for hi-lock mode."
 131   :group 'hi-lock-faces)
 132
 133 (defface hi-green
 134   '((((background dark)) (:background "green" :foreground "black"))
 135     (t (:background "green")))
 136   "Face for hi-lock mode."
 137   :group 'hi-lock-faces)
 138
 139 (defface hi-blue
 140   '((((background dark)) (:background "light blue" :foreground "black"))
 141     (t (:background "light blue")))
 142   "Face for hi-lock mode."
 143   :group 'hi-lock-faces)
 144
 145 (defface hi-black-b
 146   '((t (:weight bold)))
 147   "Face for hi-lock mode."
 148   :group 'hi-lock-faces)
 149
 150 (defface hi-blue-b
 151   '((t (:weight bold :foreground "blue")))
 152   "Face for hi-lock mode."
 153   :group 'hi-lock-faces)
 154
 155 (defface hi-green-b
 156   '((t (:weight bold :foreground "green")))
 157   "Face for hi-lock mode."
 158   :group 'hi-lock-faces)
 159
 160 (defface hi-red-b
 161   '((t (:weight bold :foreground "red")))
 162   "Face for hi-lock mode."
 163   :group 'hi-lock-faces)
 164
 165 (defface hi-black-hb
 166   '((t (:weight bold :height 1.67 :inherit variable-pitch)))
 167   "Face for hi-lock mode."
 168   :group 'hi-lock-faces)
 169
 170 (defvar hi-lock-file-patterns nil
 171   "Patterns found in file for hi-lock.  Should not be changed.")
 172
 173 (defvar hi-lock-interactive-patterns nil
 174   "Patterns provided to hi-lock by user.  Should not be changed.")
 175
 176 (defvar hi-lock-face-history
 177   (list "hi-yellow" "hi-pink" "hi-green" "hi-blue" "hi-black-b"
 178         "hi-blue-b" "hi-red-b" "hi-green-b" "hi-black-hb")
 179       "History list of faces for hi-lock interactive functions.")
 180
 181 ;(dolist (f hi-lock-face-history) (unless (facep f) (error "%s not a face" f)))
 182
 183 (defvar hi-lock-regexp-history nil
 184   "History of regexps used for interactive fontification.")
 185
 186 (defvar hi-lock-file-patterns-prefix "Hi-lock"
 187   "Regexp for finding hi-lock patterns at top of file.")
 188
 189 (make-variable-buffer-local 'hi-lock-interactive-patterns)
 190 (put 'hi-lock-interactive-patterns 'permanent-local t)
 191 (make-variable-buffer-local 'hi-lock-regexp-history)
 192 (put 'hi-lock-regexp-history 'permanent-local t)
 193 (make-variable-buffer-local 'hi-lock-file-patterns)
 194 (put 'hi-lock-file-patterns 'permanent-local t)
 195
 196 (defvar hi-lock-menu (make-sparse-keymap "Hi Lock")
 197   "Menu for hi-lock mode.")
 198
 199 (define-key-after hi-lock-menu [highlight-regexp]
 200   '(menu-item "Highlight Regexp..." highlight-regexp
 201               :help "Highlight text matching PATTERN (a regexp)."))
 202
 203 (define-key-after hi-lock-menu [highlight-phrase]
 204   '(menu-item "Highlight Phrase..." highlight-phrase
 205               :help "Highlight text matching PATTERN (a regexp processed to match phrases)."))
 206
 207 (define-key-after hi-lock-menu [highlight-lines-matching-regexp]
 208   '(menu-item "Highlight Lines..." highlight-lines-matching-regexp
 209               :help "Highlight lines containing match of PATTERN (a regexp).."))
 210
 211 (define-key-after hi-lock-menu [unhighlight-regexp]
 212   '(menu-item "Remove Highlighting..." unhighlight-regexp
 213               :help "Remove previously entered highlighting pattern."
 214               :enable hi-lock-interactive-patterns))
 215
 216 (define-key-after hi-lock-menu [hi-lock-write-interactive-patterns]
 217   '(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
 218               :help "Insert interactively added REGEXPs into buffer at point."
 219               :enable hi-lock-interactive-patterns))
 220
 221 (define-key-after hi-lock-menu [hi-lock-find-patterns]
 222   '(menu-item "Patterns from Buffer" hi-lock-find-patterns
 223               :help "Use patterns (if any) near top of buffer."))
 224
 225 (defvar hi-lock-map (make-sparse-keymap "Hi Lock")
 226   "Key map for hi-lock.")
 227
 228 (define-key hi-lock-map "\C-xwi" 'hi-lock-find-patterns)
 229 (define-key hi-lock-map "\C-xwl" 'highlight-lines-matching-regexp)
 230 (define-key hi-lock-map "\C-xwp" 'highlight-phrase)
 231 (define-key hi-lock-map "\C-xwh" 'highlight-regexp)
 232 (define-key hi-lock-map "\C-xwr" 'unhighlight-regexp)
 233 (define-key hi-lock-map "\C-xwb" 'hi-lock-write-interactive-patterns)
 234
 235 (unless (assq 'hi-lock-mode minor-mode-map-alist)
 236   (setq minor-mode-map-alist (cons (cons 'hi-lock-mode hi-lock-map)
 237                                    minor-mode-map-alist)))
 238
 239 (unless (assq 'hi-lock-mode minor-mode-alist)
 240   (setq minor-mode-alist (cons '(hi-lock-mode " H") minor-mode-alist)))
 241
 242
 243 ;; Visible Functions
 244
 245
 246 ;;;###autoload
 247 (defun hi-lock-mode (&optional arg)
 248   "Toggle minor mode for interactively adding font-lock highlighting patterns.
 249
 250 If ARG positive turn hi-lock on.  Issuing a hi-lock command will also
 251 turn hi-lock on.  When hi-lock is turned on, a \"Regexp Highlighting\"
 252 submenu is added to the \"Edit\" menu.  The commands in the submenu,
 253 which can be called interactively, are:
 254
 255 \\[highlight-regexp] REGEXP FACE
 256   Highlight matches of pattern REGEXP in current buffer with FACE.
 257
 258 \\[highlight-phrase] PHRASE FACE
 259   Highlight matches of phrase PHRASE in current buffer with FACE.
 260   (PHRASE can be any REGEXP, but spaces will be replaced by matches
 261   to whitespace and initial lower-case letters will become case insensitive.)
 262
 263 \\[highlight-lines-matching-regexp] REGEXP FACE
 264   Highlight lines containing matches of REGEXP in current buffer with FACE.
 265
 266 \\[unhighlight-regexp] REGEXP
 267   Remove highlighting on matches of REGEXP in current buffer.
 268
 269 \\[hi-lock-write-interactive-patterns]
 270   Write active REGEXPs into buffer as comments (if possible). They will
 271   be read the next time file is loaded or when the \\[hi-lock-find-patterns] command
 272   is issued.  The inserted regexps are in the form of font lock keywords.
 273   (See `font-lock-keywords') They may be edited and re-loaded with \\[hi-lock-find-patterns],
 274   any valid `font-lock-keywords' form is acceptable.
 275
 276 \\[hi-lock-find-patterns]
 277   Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
 278
 279 When hi-lock is started and if the mode is not excluded, the
 280 beginning of the buffer is searched for lines of the form:
 281   Hi-lock: FOO
 282 where FOO is a list of patterns. These are added to the font lock keywords
 283 already present.  The patterns must start before position (number
 284 of characters into buffer) `hi-lock-file-patterns-range'.  Patterns
 285 will be read until
 286  Hi-lock: end
 287 is found. A mode is excluded if it's in the list `hi-lock-exclude-modes'."
 288   (interactive)
 289   (let ((hi-lock-mode-prev hi-lock-mode))
 290     (setq hi-lock-mode
 291           (if (null arg) (not hi-lock-mode)
 292             (> (prefix-numeric-value arg) 0)))
 293     ;; Turned on.
 294     (when (and (not hi-lock-mode-prev) hi-lock-mode)
 295       (add-hook 'find-file-hook 'hi-lock-find-file-hook)
 296       (add-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook)
 297       (when (eq nil font-lock-defaults)
 298         (setq font-lock-defaults '(nil)))
 299       (unless font-lock-mode
 300         (font-lock-mode 1))
 301       (define-key-after menu-bar-edit-menu [hi-lock]
 302         (cons "Regexp Highlighting" hi-lock-menu))
 303       (dolist (buffer (buffer-list))
 304         (with-current-buffer buffer (hi-lock-find-patterns))))
 305     ;; Turned off.
 306     (when (and hi-lock-mode-prev (not hi-lock-mode))
 307       (dolist (buffer (buffer-list))
 308         (with-current-buffer buffer
 309           (when (or hi-lock-interactive-patterns hi-lock-file-patterns)
 310             (font-lock-remove-keywords nil hi-lock-interactive-patterns)
 311             (font-lock-remove-keywords nil hi-lock-file-patterns)
 312             (setq hi-lock-interactive-patterns nil
 313                   hi-lock-file-patterns nil)
 314             (when font-lock-mode (hi-lock-refontify)))))
 315       (define-key-after menu-bar-edit-menu [hi-lock] nil)
 316       (remove-hook 'find-file-hook 'hi-lock-find-file-hook)
 317       (remove-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook))))
 318
 319
 320 ;;;###autoload
 321 (defalias 'highlight-lines-matching-regexp 'hi-lock-line-face-buffer)
 322 ;;;###autoload
 323 (defun hi-lock-line-face-buffer (regexp &optional face)
 324   "Set face of all lines containing a match of REGEXP to FACE.
 325
 326 Interactively, prompt for REGEXP then FACE.  Buffer-local history
 327 list maintained for regexps, global history maintained for faces.
 328 \\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
 329 \(See info node `Minibuffer History')"
 330   (interactive
 331    (list
 332     (hi-lock-regexp-okay
 333      (read-from-minibuffer "Regexp to highlight line: "
 334                            (cons (or (car hi-lock-regexp-history) "") 1 )
 335                            nil nil 'hi-lock-regexp-history))
 336     (hi-lock-read-face-name)))
 337   (unless hi-lock-mode (hi-lock-mode))
 338   (or (facep face) (setq face 'rwl-yellow))
 339   (hi-lock-set-pattern
 340    ;; The \\(?:...\\) grouping construct ensures that a leading ^, +, * or ?
 341    ;; or a trailing $ in REGEXP will be interpreted correctly.
 342    (list (concat "^.*\\(?:" regexp "\\).*$") (list 0 (list 'quote face) t))))
 343
 344
 345 ;;;###autoload
 346 (defalias 'highlight-regexp 'hi-lock-face-buffer)
 347 ;;;###autoload
 348 (defun hi-lock-face-buffer (regexp &optional face)
 349   "Set face of each match of REGEXP to FACE.
 350
 351 Interactively, prompt for REGEXP then FACE.  Buffer-local history
 352 list maintained for regexps, global history maintained for faces.
 353 \\<minibuffer-local-map>Use \\[next-history-element] and \\[previous-history-element] to retrieve next or previous history item.
 354 \(See info node `Minibuffer History')"
 355   (interactive
 356    (list
 357     (hi-lock-regexp-okay
 358      (read-from-minibuffer "Regexp to highlight: "
 359                            (cons (or (car hi-lock-regexp-history) "") 1 )
 360                            nil nil 'hi-lock-regexp-history))
 361     (hi-lock-read-face-name)))
 362   (or (facep face) (setq face 'rwl-yellow))
 363   (unless hi-lock-mode (hi-lock-mode))
 364   (hi-lock-set-pattern (list regexp (list 0 (list 'quote face) t))))
 365
 366 ;;;###autoload
 367 (defalias 'highlight-phrase 'hi-lock-face-phrase-buffer)
 368 ;;;###autoload
 369 (defun hi-lock-face-phrase-buffer (regexp &optional face)
 370   "Set face of each match of phrase REGEXP to FACE.
 371
 372 Whitespace in REGEXP converted to arbitrary whitespace and initial
 373 lower-case letters made case insensitive."
 374   (interactive
 375    (list
 376     (hi-lock-regexp-okay
 377      (hi-lock-process-phrase
 378       (read-from-minibuffer "Phrase to highlight: "
 379                             (cons (or (car hi-lock-regexp-history) "") 1 )
 380                             nil nil 'hi-lock-regexp-history)))
 381     (hi-lock-read-face-name)))
 382   (or (facep face) (setq face 'rwl-yellow))
 383   (unless hi-lock-mode (hi-lock-mode))
 384   (hi-lock-set-pattern (list regexp (list 0 (list 'quote face) t))))
 385
 386 ;;;###autoload
 387 (defalias 'unhighlight-regexp 'hi-lock-unface-buffer)
 388 ;;;###autoload
 389 (defun hi-lock-unface-buffer (regexp)
 390   "Remove highlighting of each match to REGEXP set by hi-lock.
 391
 392 Interactively, prompt for REGEXP.  Buffer-local history of inserted
 393 regexp's maintained.  Will accept only regexps inserted by hi-lock
 394 interactive functions.  \(See `hi-lock-interactive-patterns'.\)
 395 \\<minibuffer-local-must-match-map>Use \\[minibuffer-complete] to complete a partially typed regexp.
 396 \(See info node `Minibuffer History'.\)"
 397   (interactive
 398    (if (and (display-popup-menus-p) (vectorp (this-command-keys)))
 399        (catch 'snafu
 400          (or
 401           (x-popup-menu
 402            t
 403            (cons
 404             `keymap
 405             (cons "Select Pattern to Unhighlight"
 406                   (mapcar (lambda (pattern)
 407                             (list (car pattern)
 408                                   (format
 409                                    "%s (%s)" (car pattern)
 410                                    (symbol-name
 411                                     (car
 412                                      (cdr (car (cdr (car (cdr pattern))))))))
 413                                   (cons nil nil)
 414                                   (car pattern)))
 415                           hi-lock-interactive-patterns))))
 416           ;; If the user clicks outside the menu, meaning that they
 417           ;; change their mind, x-popup-menu returns nil, and
 418           ;; interactive signals a wrong number of arguments error.
 419           ;; To prevent that, we return an empty string, which will
 420           ;; effectively disable the rest of the function.
 421           (throw 'snafu '(""))))
 422      (let ((history-list (mapcar (lambda (p) (car p))
 423                                  hi-lock-interactive-patterns)))
 424        (unless hi-lock-interactive-patterns
 425          (error "No highlighting to remove"))
 426        (list
 427         (completing-read "Regexp to unhighlight: "
 428                          hi-lock-interactive-patterns nil t
 429                          (car (car hi-lock-interactive-patterns))
 430                          (cons 'history-list 1))))))
 431   (let ((keyword (assoc regexp hi-lock-interactive-patterns)))
 432     (when keyword
 433       (font-lock-remove-keywords nil (list keyword))
 434       (setq hi-lock-interactive-patterns
 435             (delq keyword hi-lock-interactive-patterns))
 436       (hi-lock-refontify))))
 437
 438 ;;;###autoload
 439 (defun hi-lock-write-interactive-patterns ()
 440   "Write interactively added patterns, if any, into buffer at point.
 441
 442 Interactively added patterns are those normally specified using
 443 `highlight-regexp' and `highlight-lines-matching-regexp'; they can
 444 be found in variable `hi-lock-interactive-patterns'."
 445   (interactive)
 446   (let ((prefix (format "%s %s:" (or comment-start "") "Hi-lock")))
 447     (when (> (+ (point) (length prefix)) hi-lock-file-patterns-range)
 448       (beep)
 449       (message
 450        "Warning, inserted keywords not close enough to top of file."))
 451     (mapcar
 452      (lambda (pattern)
 453        (insert (format "%s (%s) %s\n"
 454                        prefix (prin1-to-string pattern) (or comment-end ""))))
 455      hi-lock-interactive-patterns)))
 456
 457
 458 ;; Implementation Functions
 459
 460 (defun hi-lock-process-phrase (phrase)
 461   "Convert regexp PHRASE to a regexp that matches phrases.
 462
 463 Blanks in PHRASE replaced by regexp that matches arbitrary whitespace
 464 and initial lower-case letters made case insensitive."
 465   (let ((mod-phrase nil))
 466     (setq mod-phrase
 467           (replace-regexp-in-string
 468            "\\<[a-z]" (lambda (m) (format "[%s%s]" (upcase m) m)) phrase))
 469     (setq mod-phrase
 470           (replace-regexp-in-string
 471            "\\s-+" "[ \t\n]+" mod-phrase nil t))))
 472
 473 (defun hi-lock-regexp-okay (regexp)
 474   "Return REGEXP if it appears suitable for a font-lock pattern.
 475
 476 Otherwise signal an error.  A pattern that matches the null string is
 477 not suitable."
 478   (if (string-match regexp "")
 479       (error "Regexp cannot match an empty string")
 480     regexp))
 481
 482 (defun hi-lock-read-face-name ()
 483   "Read face name from minibuffer with completion and history."
 484   (intern (completing-read
 485            "Highlight using face: "
 486            obarray 'facep t
 487            (cons (car hi-lock-face-history)
 488                  (let ((prefix
 489                         (try-completion
 490                          (substring (car hi-lock-face-history) 0 1)
 491                          (mapcar (lambda (f) (cons f f))
 492                                  hi-lock-face-history))))
 493                    (if (and (stringp prefix)
 494                             (not (equal prefix (car hi-lock-face-history))))
 495                        (length prefix) 0)))
 496            '(hi-lock-face-history . 0))))
 497
 498 (defun hi-lock-find-file-hook ()
 499   "Add hi-lock patterns, if present."
 500   (hi-lock-find-patterns))
 501
 502 (defun hi-lock-current-line (&optional end)
 503   "Return line number of line at point.
 504 Optional argument END is maximum excursion."
 505   (interactive)
 506   (save-excursion
 507     (beginning-of-line)
 508     (1+ (count-lines 1 (or end (point))))))
 509
 510 (defun hi-lock-set-pattern (pattern)
 511   "Add PATTERN to list of interactively highlighted patterns and refontify."
 512   (hi-lock-set-patterns (list pattern)))
 513
 514 (defun hi-lock-set-patterns (patterns)
 515   "Add PATTERNS to list of interactively highlighted patterns and refontify.."
 516   (dolist (pattern patterns)
 517     (unless (member pattern hi-lock-interactive-patterns)
 518       (font-lock-add-keywords nil (list pattern))
 519       (add-to-list 'hi-lock-interactive-patterns pattern)))
 520   (hi-lock-refontify))
 521
 522 (defun hi-lock-set-file-patterns (patterns)
 523   "Replace file patterns list with PATTERNS and refontify."
 524   (when (or hi-lock-file-patterns patterns)
 525     (font-lock-remove-keywords nil hi-lock-file-patterns)
 526     (setq hi-lock-file-patterns patterns)
 527     (font-lock-add-keywords nil hi-lock-file-patterns)
 528     (hi-lock-refontify)))
 529
 530 (defun hi-lock-refontify ()
 531   "Unfontify then refontify buffer.  Used when hi-lock patterns change."
 532   (interactive)
 533   (unless font-lock-mode (font-lock-mode 1))
 534   (font-lock-fontify-buffer))
 535
 536 (defun hi-lock-find-patterns ()
 537   "Find patterns in current buffer for hi-lock."
 538   (interactive)
 539   (unless (memq major-mode hi-lock-exclude-modes)
 540     (let ((all-patterns nil)
 541           (target-regexp (concat "\\<" hi-lock-file-patterns-prefix ":")))
 542       (save-excursion
 543         (save-restriction
 544           (widen)
 545           (goto-char (point-min))
 546           (re-search-forward target-regexp
 547                              (+ (point) hi-lock-file-patterns-range) t)
 548           (beginning-of-line)
 549           (while (and (re-search-forward target-regexp (+ (point) 100) t)
 550                       (not (looking-at "\\s-*end")))
 551             (let ((patterns
 552                    (condition-case nil
 553                        (read (current-buffer))
 554                      (error  (message
 555                               (format "Could not read expression at %d"
 556                                       (hi-lock-current-line))) nil))))
 557               (if patterns
 558                   (setq all-patterns (append patterns all-patterns)))))))
 559       (when hi-lock-mode (hi-lock-set-file-patterns all-patterns))
 560       (if (interactive-p)
 561         (message (format "Hi-lock added %d patterns." (length all-patterns)))))))
 562
 563 (defun hi-lock-font-lock-hook ()
 564   "Add hi lock patterns to font-lock's."
 565   (when hi-lock-mode
 566     (font-lock-add-keywords nil hi-lock-file-patterns)
 567     (font-lock-add-keywords nil hi-lock-interactive-patterns)))
 568
 569 (provide 'hi-lock)
 570
 571 ;; arch-tag: d2e8fd07-4cc9-4c6f-a200-1e729bc54066
 572 ;;; hi-lock.el ends here