lisp/hi-lock.el

   1 ;;; hi-lock.el --- minor mode for interactive automatic highlighting
   2
   3 ;; Copyright (C) 2000-2011 Free Software Foundation, Inc.
   4
   5 ;; Author: David M. Koppelman <koppel@ece.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 3 of the License, or
  13 ;; (at your option) 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.  If not, see <http://www.gnu.org/licenses/>.
  22
  23 ;;; Commentary:
  24 ;;
  25 ;;  With the hi-lock commands text matching interactively entered
  26 ;;  regexp's can be highlighted.  For example, `M-x highlight-regexp
  27 ;;  RET clearly RET RET' will highlight all occurrences of `clearly'
  28 ;;  using a yellow background face.  New occurrences of `clearly' will
  29 ;;  be highlighted as they are typed.  `M-x unhighlight-regexp RET'
  30 ;;  will remove the highlighting.  Any existing face can be used for
  31 ;;  highlighting and a set of appropriate faces is provided.  The
  32 ;;  regexps can be written into the current buffer in a form that will
  33 ;;  be recognized the next time the corresponding file is read (when
  34 ;;  file patterns is turned on).
  35 ;;
  36 ;;  Applications:
  37 ;;
  38 ;;    In program source code highlight a variable to quickly see all
  39 ;;    places it is modified or referenced:
  40 ;;    M-x highlight-regexp ground_contact_switches_closed RET RET
  41 ;;
  42 ;;    In a shell or other buffer that is showing lots of program
  43 ;;    output, highlight the parts of the output you're interested in:
  44 ;;    M-x highlight-regexp Total execution time [0-9]+ RET hi-blue-b RET
  45 ;;
  46 ;;    In buffers displaying tables, highlight the lines you're interested in:
  47 ;;    M-x highlight-lines-matching-regexp January 2000 RET hi-black-b RET
  48 ;;
  49 ;;    When writing text, highlight personal cliches.  This can be
  50 ;;    amusing.
  51 ;;    M-x highlight-phrase as can be seen RET RET
  52 ;;
  53 ;;  Setup:
  54 ;;
  55 ;;    Put the following code in your .emacs file.  This turns on
  56 ;;    hi-lock mode and adds a "Regexp Highlighting" entry
  57 ;;    to the edit menu.
  58 ;;
  59 ;;    (global-hi-lock-mode 1)
  60 ;;
  61 ;;    To enable the use of patterns found in files (presumably placed
  62 ;;    there by hi-lock) include the following in your .emacs file:
  63 ;;
  64 ;;    (setq hi-lock-file-patterns-policy 'ask)
  65 ;;
  66 ;;    If you get tired of being asked each time a file is loaded replace
  67 ;;    `ask' with a function that returns t if patterns should be read.
  68 ;;
  69 ;;    You might also want to bind the hi-lock commands to more
  70 ;;    finger-friendly sequences:
  71
  72 ;;    (define-key hi-lock-map "\C-z\C-h" 'highlight-lines-matching-regexp)
  73 ;;    (define-key hi-lock-map "\C-zi" 'hi-lock-find-patterns)
  74 ;;    (define-key hi-lock-map "\C-zh" 'highlight-regexp)
  75 ;;    (define-key hi-lock-map "\C-zp" 'highlight-phrase)
  76 ;;    (define-key hi-lock-map "\C-zr" 'unhighlight-regexp)
  77 ;;    (define-key hi-lock-map "\C-zb" 'hi-lock-write-interactive-patterns))
  78
  79 ;;    See the documentation for hi-lock-mode `C-h f hi-lock-mode' for
  80 ;;    additional instructions.
  81
  82 ;; Sample file patterns:
  83
  84 ; Hi-lock: (("^;;; .*" (0 (quote hi-black-hb) t)))
  85 ; Hi-lock: ( ("make-variable-buffer-\\(local\\)" (0 font-lock-keyword-face)(1 'italic append)))))
  86 ; Hi-lock: end
  87
  88 ;;; Code:
  89
  90 (require 'font-lock)
  91
  92 (defgroup hi-lock nil
  93   "Interactively add and remove font-lock patterns for highlighting text."
  94   :link '(custom-manual "(emacs)Highlight Interactively")
  95   :group 'font-lock)
  96
  97 (defcustom hi-lock-file-patterns-range 10000
  98   "Limit of search in a buffer for hi-lock patterns.
  99 When a file is visited and hi-lock mode is on, patterns starting
 100 up to this limit are added to font-lock's patterns.  See documentation
 101 of functions `hi-lock-mode' and `hi-lock-find-patterns'."
 102   :type 'integer
 103   :group 'hi-lock)
 104
 105 (defcustom hi-lock-highlight-range 200000
 106   "Size of area highlighted by hi-lock when font-lock not active.
 107 Font-lock is not active in buffers that do their own highlighting,
 108 such as the buffer created by `list-colors-display'.  In those buffers
 109 hi-lock patterns will only be applied over a range of
 110 `hi-lock-highlight-range' characters.  If font-lock is active then
 111 highlighting will be applied throughout the buffer."
 112   :type 'integer
 113   :group 'hi-lock)
 114
 115 (defcustom hi-lock-exclude-modes
 116   '(rmail-mode mime/viewer-mode gnus-article-mode)
 117   "List of major modes in which hi-lock will not run.
 118 For security reasons since font lock patterns can specify function
 119 calls."
 120   :type '(repeat symbol)
 121   :group 'hi-lock)
 122
 123 (defcustom hi-lock-file-patterns-policy 'ask
 124   "Specify when hi-lock should use patterns found in file.
 125 If `ask', prompt when patterns found in buffer; if bound to a function,
 126 use patterns when function returns t (function is called with patterns
 127 as first argument); if nil or `never' or anything else, don't use file
 128 patterns."
 129   :type '(choice (const :tag "Do not use file patterns" never)
 130                  (const :tag "Ask about file patterns" ask)
 131                  (function :tag "Function to check file patterns"))
 132   :group 'hi-lock
 133   :version "22.1")
 134
 135 ;; It can have a function value.
 136 (put 'hi-lock-file-patterns-policy 'risky-local-variable t)
 137
 138 (defgroup hi-lock-faces nil
 139   "Faces for hi-lock."
 140   :group 'hi-lock
 141   :group 'faces)
 142
 143 (defface hi-yellow
 144   '((((min-colors 88) (background dark))
 145      (:background "yellow1" :foreground "black"))
 146     (((background dark)) (:background "yellow" :foreground "black"))
 147     (((min-colors 88)) (:background "yellow1"))
 148     (t (:background "yellow")))
 149   "Default face for hi-lock mode."
 150   :group 'hi-lock-faces)
 151
 152 (defface hi-pink
 153   '((((background dark)) (:background "pink" :foreground "black"))
 154     (t (:background "pink")))
 155   "Face for hi-lock mode."
 156   :group 'hi-lock-faces)
 157
 158 (defface hi-green
 159   '((((min-colors 88) (background dark))
 160      (:background "green1" :foreground "black"))
 161     (((background dark)) (:background "green" :foreground "black"))
 162     (((min-colors 88)) (:background "green1"))
 163     (t (:background "green")))
 164   "Face for hi-lock mode."
 165   :group 'hi-lock-faces)
 166
 167 (defface hi-blue
 168   '((((background dark)) (:background "light blue" :foreground "black"))
 169     (t (:background "light blue")))
 170   "Face for hi-lock mode."
 171   :group 'hi-lock-faces)
 172
 173 (defface hi-black-b
 174   '((t (:weight bold)))
 175   "Face for hi-lock mode."
 176   :group 'hi-lock-faces)
 177
 178 (defface hi-blue-b
 179   '((((min-colors 88)) (:weight bold :foreground "blue1"))
 180     (t (:weight bold :foreground "blue")))
 181   "Face for hi-lock mode."
 182   :group 'hi-lock-faces)
 183
 184 (defface hi-green-b
 185   '((((min-colors 88)) (:weight bold :foreground "green1"))
 186     (t (:weight bold :foreground "green")))
 187   "Face for hi-lock mode."
 188   :group 'hi-lock-faces)
 189
 190 (defface hi-red-b
 191   '((((min-colors 88)) (:weight bold :foreground "red1"))
 192     (t (:weight bold :foreground "red")))
 193   "Face for hi-lock mode."
 194   :group 'hi-lock-faces)
 195
 196 (defface hi-black-hb
 197   '((t (:weight bold :height 1.67 :inherit variable-pitch)))
 198   "Face for hi-lock mode."
 199   :group 'hi-lock-faces)
 200
 201 (defvar hi-lock-file-patterns nil
 202   "Patterns found in file for hi-lock.  Should not be changed.")
 203
 204 (defvar hi-lock-interactive-patterns nil
 205   "Patterns provided to hi-lock by user.  Should not be changed.")
 206
 207 (defvar hi-lock-face-defaults
 208   '("hi-yellow" "hi-pink" "hi-green" "hi-blue" "hi-black-b"
 209     "hi-blue-b" "hi-red-b" "hi-green-b" "hi-black-hb")
 210   "Default faces for hi-lock interactive functions.")
 211
 212 ;(dolist (f hi-lock-face-defaults) (unless (facep f) (error "%s not a face" f)))
 213
 214 (define-obsolete-variable-alias 'hi-lock-face-history
 215                                 'hi-lock-face-defaults
 216                                 "23.1")
 217
 218 (define-obsolete-variable-alias 'hi-lock-regexp-history
 219                                 'regexp-history
 220                                 "23.1")
 221
 222 (defvar hi-lock-file-patterns-prefix "Hi-lock"
 223   "Search target for finding hi-lock patterns at top of file.")
 224
 225 (defvar hi-lock-archaic-interface-message-used nil
 226   "True if user alerted that `global-hi-lock-mode' is now the global switch.
 227 Earlier versions of hi-lock used `hi-lock-mode' as the global switch;
 228 the message is issued if it appears that `hi-lock-mode' is used assuming
 229 that older functionality.  This variable avoids multiple reminders.")
 230
 231 (defvar hi-lock-archaic-interface-deduce nil
 232   "If non-nil, sometimes assume that `hi-lock-mode' means `global-hi-lock-mode'.
 233 Assumption is made if `hi-lock-mode' used in the *scratch* buffer while
 234 a library is being loaded.")
 235
 236 (make-variable-buffer-local 'hi-lock-interactive-patterns)
 237 (put 'hi-lock-interactive-patterns 'permanent-local t)
 238 (make-variable-buffer-local 'hi-lock-file-patterns)
 239 (put 'hi-lock-file-patterns 'permanent-local t)
 240
 241 (defvar hi-lock-menu
 242   (let ((map (make-sparse-keymap "Hi Lock")))
 243     (define-key-after map [highlight-regexp]
 244       '(menu-item "Highlight Regexp..." highlight-regexp
 245         :help "Highlight text matching PATTERN (a regexp)."))
 246
 247     (define-key-after map [highlight-phrase]
 248       '(menu-item "Highlight Phrase..." highlight-phrase
 249         :help "Highlight text matching PATTERN (a regexp processed to match phrases)."))
 250
 251     (define-key-after map [highlight-lines-matching-regexp]
 252       '(menu-item "Highlight Lines..." highlight-lines-matching-regexp
 253         :help "Highlight lines containing match of PATTERN (a regexp)."))
 254
 255     (define-key-after map [unhighlight-regexp]
 256       '(menu-item "Remove Highlighting..." unhighlight-regexp
 257         :help "Remove previously entered highlighting pattern."
 258         :enable hi-lock-interactive-patterns))
 259
 260     (define-key-after map [hi-lock-write-interactive-patterns]
 261       '(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
 262         :help "Insert interactively added REGEXPs into buffer at point."
 263         :enable hi-lock-interactive-patterns))
 264
 265     (define-key-after map [hi-lock-find-patterns]
 266       '(menu-item "Patterns from Buffer" hi-lock-find-patterns
 267         :help "Use patterns (if any) near top of buffer."))
 268     map)
 269   "Menu for hi-lock mode.")
 270
 271 (defvar hi-lock-map
 272   (let ((map (make-sparse-keymap "Hi Lock")))
 273     (define-key map "\C-xwi" 'hi-lock-find-patterns)
 274     (define-key map "\C-xwl" 'highlight-lines-matching-regexp)
 275     (define-key map "\C-xwp" 'highlight-phrase)
 276     (define-key map "\C-xwh" 'highlight-regexp)
 277     (define-key map "\C-xwr" 'unhighlight-regexp)
 278     (define-key map "\C-xwb" 'hi-lock-write-interactive-patterns)
 279     map)
 280   "Key map for hi-lock.")
 281
 282 ;; Visible Functions
 283
 284 ;;;###autoload
 285 (define-minor-mode hi-lock-mode
 286   "Toggle minor mode for interactively adding font-lock highlighting patterns.
 287
 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:
 294
 295 \\[highlight-regexp] REGEXP FACE
 296   Highlight matches of pattern REGEXP in current buffer with FACE.
 297
 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.)
 302
 303 \\[highlight-lines-matching-regexp] REGEXP FACE
 304   Highlight lines containing matches of REGEXP in current buffer with FACE.
 305
 306 \\[unhighlight-regexp] REGEXP
 307   Remove highlighting on matches of REGEXP in current buffer.
 308
 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.
 319
 320 \\[hi-lock-find-patterns]
 321   Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
 322
 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:
 351
 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)))
 377
 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)
 382
 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)))
 387
 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.
 393
 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))
 410
 411
 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.
 417
 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))
 431
 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.
 437
 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))
 449
 450 (declare-function x-popup-menu "menu.c" (position menu))
 451
 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.
 457
 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
 466          (or
 467           (x-popup-menu
 468            t
 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)))))
 505
 506 ;;;###autoload
 507 (defun hi-lock-write-interactive-patterns ()
 508   "Write interactively added patterns, if any, into buffer at point.
 509
 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")))
 526
 527 ;; Implementation Functions
 528
 529 (defun hi-lock-process-phrase (phrase)
 530   "Convert regexp PHRASE to a regexp that matches phrases.
 531
 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))))
 541
 542 (defun hi-lock-regexp-okay (regexp)
 543   "Return REGEXP if it appears suitable for a font-lock pattern.
 544
 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))
 550
 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))))
 566
 567 (defun hi-lock-set-pattern (regexp face)
 568   "Highlight REGEXP with face FACE."
 569   (let ((pattern (list regexp (list 0 (list 'quote face) t))))
 570     (unless (member pattern hi-lock-interactive-patterns)
 571       (push pattern hi-lock-interactive-patterns)
 572       (if font-lock-fontified
 573           (progn
 574             (font-lock-add-keywords nil (list pattern) t)
 575             (font-lock-fontify-buffer))
 576         (let* ((serial (hi-lock-string-serialize regexp))
 577                (range-min (- (point) (/ hi-lock-highlight-range 2)))
 578                (range-max (+ (point) (/ hi-lock-highlight-range 2)))
 579                (search-start
 580                 (max (point-min)
 581                      (- range-min (max 0 (- range-max (point-max))))))
 582                (search-end
 583                 (min (point-max)
 584                      (+ range-max (max 0 (- (point-min) range-min))))))
 585           (save-excursion
 586             (goto-char search-start)
 587             (while (re-search-forward regexp search-end t)
 588               (let ((overlay (make-overlay (match-beginning 0) (match-end 0))))
 589                 (overlay-put overlay 'hi-lock-overlay t)
 590                 (overlay-put overlay 'hi-lock-overlay-regexp serial)
 591                 (overlay-put overlay 'face face))
 592               (goto-char (match-end 0)))))))))
 593
 594 (defun hi-lock-set-file-patterns (patterns)
 595   "Replace file patterns list with PATTERNS and refontify."
 596   (when (or hi-lock-file-patterns patterns)
 597     (font-lock-remove-keywords nil hi-lock-file-patterns)
 598     (setq hi-lock-file-patterns patterns)
 599     (font-lock-add-keywords nil hi-lock-file-patterns t)
 600     (font-lock-fontify-buffer)))
 601
 602 (defun hi-lock-find-patterns ()
 603   "Find patterns in current buffer for hi-lock."
 604   (interactive)
 605   (unless (memq major-mode hi-lock-exclude-modes)
 606     (let ((all-patterns nil)
 607           (target-regexp (concat "\\<" hi-lock-file-patterns-prefix ":")))
 608       (save-excursion
 609         (save-restriction
 610           (widen)
 611           (goto-char (point-min))
 612           (re-search-forward target-regexp
 613                              (+ (point) hi-lock-file-patterns-range) t)
 614           (beginning-of-line)
 615           (while (and (re-search-forward target-regexp (+ (point) 100) t)
 616                       (not (looking-at "\\s-*end")))
 617             (condition-case nil
 618                 (setq all-patterns (append (read (current-buffer)) all-patterns))
 619               (error (message "Invalid pattern list expression at %d"
 620                               (line-number-at-pos)))))))
 621       (when (and all-patterns
 622                  hi-lock-mode
 623                  (cond
 624                   ((eq this-command 'hi-lock-find-patterns) t)
 625                   ((functionp hi-lock-file-patterns-policy)
 626                    (funcall hi-lock-file-patterns-policy all-patterns))
 627                   ((eq hi-lock-file-patterns-policy 'ask)
 628                    (y-or-n-p "Add patterns from this buffer to hi-lock? "))
 629                   (t nil)))
 630         (hi-lock-set-file-patterns all-patterns)
 631         (if (called-interactively-p 'interactive)
 632             (message "Hi-lock added %d patterns." (length all-patterns)))))))
 633
 634 (defun hi-lock-font-lock-hook ()
 635   "Add hi-lock patterns to font-lock's."
 636   (when font-lock-fontified
 637     (font-lock-add-keywords nil hi-lock-file-patterns t)
 638     (font-lock-add-keywords nil hi-lock-interactive-patterns t)))
 639
 640 (defvar hi-lock-string-serialize-hash
 641   (make-hash-table :test 'equal)
 642   "Hash table used to assign unique numbers to strings.")
 643
 644 (defvar hi-lock-string-serialize-serial 1
 645   "Number assigned to last new string in call to `hi-lock-string-serialize'.
 646 A string is considered new if it had not previously been used in a call to
 647 `hi-lock-string-serialize'.")
 648
 649 (defun hi-lock-string-serialize (string)
 650   "Return unique serial number for STRING."
 651   (interactive)
 652   (let ((val (gethash string hi-lock-string-serialize-hash)))
 653     (if val val
 654       (puthash string
 655                (setq hi-lock-string-serialize-serial
 656                      (1+ hi-lock-string-serialize-serial))
 657                hi-lock-string-serialize-hash)
 658       hi-lock-string-serialize-serial)))
 659
 660 (defun hi-lock-unload-function ()
 661   "Unload the Hi-Lock library."
 662   (global-hi-lock-mode -1)
 663   ;; continue standard unloading
 664   nil)
 665
 666 (provide 'hi-lock)
 667
 668 ;;; hi-lock.el ends here