lisp/hi-lock.el

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