lisp/hi-lock.el

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