lisp/hi-lock.el

   1 ;;; hi-lock.el --- minor mode for interactive automatic highlighting
   2
   3 ;; Copyright (C) 2000-2012 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 init 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 init 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 (defcustom hi-lock-auto-select-face nil
 139   "Non-nil if highlighting commands should not prompt for face names.
 140 When non-nil, each hi-lock command will cycle through faces in
 141 `hi-lock-face-defaults'."
 142   :type 'boolean
 143   :version "24.4")
 144
 145 (defgroup hi-lock-faces nil
 146   "Faces for hi-lock."
 147   :group 'hi-lock
 148   :group 'faces)
 149
 150 (defface hi-yellow
 151   '((((min-colors 88) (background dark))
 152      (:background "yellow1" :foreground "black"))
 153     (((background dark)) (:background "yellow" :foreground "black"))
 154     (((min-colors 88)) (:background "yellow1"))
 155     (t (:background "yellow")))
 156   "Default face for hi-lock mode."
 157   :group 'hi-lock-faces)
 158
 159 (defface hi-pink
 160   '((((background dark)) (:background "pink" :foreground "black"))
 161     (t (:background "pink")))
 162   "Face for hi-lock mode."
 163   :group 'hi-lock-faces)
 164
 165 (defface hi-green
 166   '((((min-colors 88) (background dark))
 167      (:background "green1" :foreground "black"))
 168     (((background dark)) (:background "green" :foreground "black"))
 169     (((min-colors 88)) (:background "green1"))
 170     (t (:background "green")))
 171   "Face for hi-lock mode."
 172   :group 'hi-lock-faces)
 173
 174 (defface hi-blue
 175   '((((background dark)) (:background "light blue" :foreground "black"))
 176     (t (:background "light blue")))
 177   "Face for hi-lock mode."
 178   :group 'hi-lock-faces)
 179
 180 (defface hi-black-b
 181   '((t (:weight bold)))
 182   "Face for hi-lock mode."
 183   :group 'hi-lock-faces)
 184
 185 (defface hi-blue-b
 186   '((((min-colors 88)) (:weight bold :foreground "blue1"))
 187     (t (:weight bold :foreground "blue")))
 188   "Face for hi-lock mode."
 189   :group 'hi-lock-faces)
 190
 191 (defface hi-green-b
 192   '((((min-colors 88)) (:weight bold :foreground "green1"))
 193     (t (:weight bold :foreground "green")))
 194   "Face for hi-lock mode."
 195   :group 'hi-lock-faces)
 196
 197 (defface hi-red-b
 198   '((((min-colors 88)) (:weight bold :foreground "red1"))
 199     (t (:weight bold :foreground "red")))
 200   "Face for hi-lock mode."
 201   :group 'hi-lock-faces)
 202
 203 (defface hi-black-hb
 204   '((t (:weight bold :height 1.67 :inherit variable-pitch)))
 205   "Face for hi-lock mode."
 206   :group 'hi-lock-faces)
 207
 208 (defvar hi-lock-file-patterns nil
 209   "Patterns found in file for hi-lock.  Should not be changed.")
 210
 211 (defvar hi-lock-interactive-patterns nil
 212   "Patterns provided to hi-lock by user.  Should not be changed.")
 213
 214 (define-obsolete-variable-alias 'hi-lock-face-history
 215                                 'hi-lock-face-defaults "23.1")
 216 (defvar hi-lock-face-defaults
 217   '("hi-yellow" "hi-pink" "hi-green" "hi-blue" "hi-black-b"
 218     "hi-blue-b" "hi-red-b" "hi-green-b" "hi-black-hb")
 219   "Default faces for hi-lock interactive functions.")
 220
 221 (defvar-local hi-lock--auto-select-face-defaults
 222   (let ((l (copy-sequence hi-lock-face-defaults)))
 223     (setcdr (last l) l))
 224   "Circular list of faces used for interactive highlighting.
 225 When `hi-lock-auto-select-face' is non-nil, use the face at the
 226 head of this list for next interactive highlighting.  See also
 227 `hi-lock-read-face-name'.")
 228
 229 (define-obsolete-variable-alias 'hi-lock-regexp-history
 230                                 'regexp-history
 231                                 "23.1")
 232
 233 (defvar hi-lock-file-patterns-prefix "Hi-lock"
 234   "Search target for finding hi-lock patterns at top of file.")
 235
 236 (defvar hi-lock-archaic-interface-message-used nil
 237   "True if user alerted that `global-hi-lock-mode' is now the global switch.
 238 Earlier versions of hi-lock used `hi-lock-mode' as the global switch;
 239 the message is issued if it appears that `hi-lock-mode' is used assuming
 240 that older functionality.  This variable avoids multiple reminders.")
 241
 242 (defvar hi-lock-archaic-interface-deduce nil
 243   "If non-nil, sometimes assume that `hi-lock-mode' means `global-hi-lock-mode'.
 244 Assumption is made if `hi-lock-mode' used in the *scratch* buffer while
 245 a library is being loaded.")
 246
 247 (make-variable-buffer-local 'hi-lock-interactive-patterns)
 248 (put 'hi-lock-interactive-patterns 'permanent-local t)
 249 (make-variable-buffer-local 'hi-lock-file-patterns)
 250 (put 'hi-lock-file-patterns 'permanent-local t)
 251
 252 (defvar hi-lock-menu
 253   (let ((map (make-sparse-keymap "Hi Lock")))
 254     (define-key-after map [highlight-regexp]
 255       '(menu-item "Highlight Regexp..." highlight-regexp
 256         :help "Highlight text matching PATTERN (a regexp)."))
 257
 258     (define-key-after map [highlight-phrase]
 259       '(menu-item "Highlight Phrase..." highlight-phrase
 260         :help "Highlight text matching PATTERN (a regexp processed to match phrases)."))
 261
 262     (define-key-after map [highlight-lines-matching-regexp]
 263       '(menu-item "Highlight Lines..." highlight-lines-matching-regexp
 264         :help "Highlight lines containing match of PATTERN (a regexp)."))
 265
 266     (define-key-after map [unhighlight-regexp]
 267       '(menu-item "Remove Highlighting..." unhighlight-regexp
 268         :help "Remove previously entered highlighting pattern."
 269         :enable hi-lock-interactive-patterns))
 270
 271     (define-key-after map [hi-lock-write-interactive-patterns]
 272       '(menu-item "Patterns to Buffer" hi-lock-write-interactive-patterns
 273         :help "Insert interactively added REGEXPs into buffer at point."
 274         :enable hi-lock-interactive-patterns))
 275
 276     (define-key-after map [hi-lock-find-patterns]
 277       '(menu-item "Patterns from Buffer" hi-lock-find-patterns
 278         :help "Use patterns (if any) near top of buffer."))
 279     map)
 280   "Menu for hi-lock mode.")
 281
 282 (defvar hi-lock-map
 283   (let ((map (make-sparse-keymap "Hi Lock")))
 284     (define-key map "\C-xwi" 'hi-lock-find-patterns)
 285     (define-key map "\C-xwl" 'highlight-lines-matching-regexp)
 286     (define-key map "\C-xwp" 'highlight-phrase)
 287     (define-key map "\C-xwh" 'highlight-regexp)
 288     (define-key map "\C-xwr" 'unhighlight-regexp)
 289     (define-key map "\C-xwb" 'hi-lock-write-interactive-patterns)
 290     map)
 291   "Key map for hi-lock.")
 292
 293 ;; Visible Functions
 294
 295 ;;;###autoload
 296 (define-minor-mode hi-lock-mode
 297   "Toggle selective highlighting of patterns (Hi Lock mode).
 298 With a prefix argument ARG, enable Hi Lock mode if ARG is
 299 positive, and disable it otherwise.  If called from Lisp, enable
 300 the mode if ARG is omitted or nil.
 301
 302 Hi Lock mode is automatically enabled when you invoke any of the
 303 highlighting commands listed below, such as \\[highlight-regexp].
 304 To enable Hi Lock mode in all buffers, use `global-hi-lock-mode'
 305 or add (global-hi-lock-mode 1) to your init file.
 306
 307 In buffers where Font Lock mode is enabled, patterns are
 308 highlighted using font lock.  In buffers where Font Lock mode is
 309 disabled, patterns are applied using overlays; in this case, the
 310 highlighting will not be updated as you type.
 311
 312 When Hi Lock mode is enabled, a \"Regexp Highlighting\" submenu
 313 is added to the \"Edit\" menu.  The commands in the submenu,
 314 which can be called interactively, are:
 315
 316 \\[highlight-regexp] REGEXP FACE
 317   Highlight matches of pattern REGEXP in current buffer with FACE.
 318
 319 \\[highlight-phrase] PHRASE FACE
 320   Highlight matches of phrase PHRASE in current buffer with FACE.
 321   (PHRASE can be any REGEXP, but spaces will be replaced by matches
 322   to whitespace and initial lower-case letters will become case insensitive.)
 323
 324 \\[highlight-lines-matching-regexp] REGEXP FACE
 325   Highlight lines containing matches of REGEXP in current buffer with FACE.
 326
 327 \\[unhighlight-regexp] REGEXP
 328   Remove highlighting on matches of REGEXP in current buffer.
 329
 330 \\[hi-lock-write-interactive-patterns]
 331   Write active REGEXPs into buffer as comments (if possible).  They may
 332   be read the next time file is loaded or when the \\[hi-lock-find-patterns] command
 333   is issued.  The inserted regexps are in the form of font lock keywords.
 334   (See `font-lock-keywords'.)  They may be edited and re-loaded with \\[hi-lock-find-patterns],
 335   any valid `font-lock-keywords' form is acceptable.  When a file is
 336   loaded the patterns are read if `hi-lock-file-patterns-policy' is
 337   'ask and the user responds y to the prompt, or if
 338   `hi-lock-file-patterns-policy' is bound to a function and that
 339   function returns t.
 340
 341 \\[hi-lock-find-patterns]
 342   Re-read patterns stored in buffer (in the format produced by \\[hi-lock-write-interactive-patterns]).
 343
 344 When hi-lock is started and if the mode is not excluded or patterns
 345 rejected, the beginning of the buffer is searched for lines of the
 346 form:
 347   Hi-lock: FOO
 348
 349 where FOO is a list of patterns.  The patterns must start before
 350 position \(number of characters into buffer)
 351 `hi-lock-file-patterns-range'.  Patterns will be read until
 352 Hi-lock: end is found.  A mode is excluded if it's in the list
 353 `hi-lock-exclude-modes'."
 354   :group 'hi-lock
 355   :lighter (:eval (if (or hi-lock-interactive-patterns
 356                           hi-lock-file-patterns)
 357                       " Hi" ""))
 358   :global nil
 359   :keymap hi-lock-map
 360   (when (and (equal (buffer-name) "*scratch*")
 361              load-in-progress
 362              (not (called-interactively-p 'interactive))
 363              (not hi-lock-archaic-interface-message-used))
 364     (setq hi-lock-archaic-interface-message-used t)
 365     (if hi-lock-archaic-interface-deduce
 366         (global-hi-lock-mode hi-lock-mode)
 367       (warn
 368        "Possible archaic use of (hi-lock-mode).
 369 Use (global-hi-lock-mode 1) in .emacs to enable hi-lock for all buffers,
 370 use (hi-lock-mode 1) for individual buffers.  For compatibility with Emacs
 371 versions before 22 use the following in your init file:
 372
 373         (if (functionp 'global-hi-lock-mode)
 374             (global-hi-lock-mode 1)
 375           (hi-lock-mode 1))
 376 ")))
 377   (if hi-lock-mode
 378       ;; Turned on.
 379       (progn
 380         (define-key-after menu-bar-edit-menu [hi-lock]
 381           (cons "Regexp Highlighting" hi-lock-menu))
 382         (hi-lock-find-patterns)
 383         (add-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook nil t))
 384     ;; Turned off.
 385     (when (or hi-lock-interactive-patterns
 386               hi-lock-file-patterns)
 387       (when hi-lock-interactive-patterns
 388         (font-lock-remove-keywords nil hi-lock-interactive-patterns)
 389         (setq hi-lock-interactive-patterns nil))
 390       (when hi-lock-file-patterns
 391         (font-lock-remove-keywords nil hi-lock-file-patterns)
 392         (setq hi-lock-file-patterns nil))
 393       (remove-overlays nil nil 'hi-lock-overlay t)
 394       (when font-lock-fontified (font-lock-fontify-buffer)))
 395     (define-key-after menu-bar-edit-menu [hi-lock] nil)
 396     (remove-hook 'font-lock-mode-hook 'hi-lock-font-lock-hook t)))
 397
 398 ;;;###autoload
 399 (define-globalized-minor-mode global-hi-lock-mode
 400   hi-lock-mode turn-on-hi-lock-if-enabled
 401   :group 'hi-lock)
 402
 403 (defun turn-on-hi-lock-if-enabled ()
 404   (setq hi-lock-archaic-interface-message-used t)
 405   (unless (memq major-mode hi-lock-exclude-modes)
 406     (hi-lock-mode 1)))
 407
 408 ;;;###autoload
 409 (defalias 'highlight-lines-matching-regexp 'hi-lock-line-face-buffer)
 410 ;;;###autoload
 411 (defun hi-lock-line-face-buffer (regexp &optional face)
 412   "Set face of all lines containing a match of REGEXP to FACE.
 413 Interactively, prompt for REGEXP then FACE, using a buffer-local
 414 history list for REGEXP and a global history list for FACE.
 415
 416 If Font Lock mode is enabled in the buffer, it is used to
 417 highlight REGEXP.  If Font Lock mode is disabled, overlays are
 418 used for highlighting; in this case, the highlighting will not be
 419 updated as you type."
 420   (interactive
 421    (list
 422     (hi-lock-regexp-okay
 423      (read-regexp "Regexp to highlight line" (car regexp-history)))
 424     (hi-lock-read-face-name)))
 425   (or (facep face) (setq face 'hi-yellow))
 426   (unless hi-lock-mode (hi-lock-mode 1))
 427   (hi-lock-set-pattern
 428    ;; The \\(?:...\\) grouping construct ensures that a leading ^, +, * or ?
 429    ;; or a trailing $ in REGEXP will be interpreted correctly.
 430    (concat "^.*\\(?:" regexp "\\).*$") face))
 431
 432
 433 ;;;###autoload
 434 (defalias 'highlight-regexp 'hi-lock-face-buffer)
 435 ;;;###autoload
 436 (defun hi-lock-face-buffer (regexp &optional face)
 437   "Set face of each match of REGEXP to FACE.
 438 Interactively, prompt for REGEXP then FACE, using a buffer-local
 439 history list for REGEXP and a global history list for FACE.
 440
 441 If Font Lock mode is enabled in the buffer, it is used to
 442 highlight REGEXP.  If Font Lock mode is disabled, overlays are
 443 used for highlighting; in this case, the highlighting will not be
 444 updated as you type."
 445   (interactive
 446    (list
 447     (hi-lock-regexp-okay
 448      (read-regexp "Regexp to highlight" (car regexp-history)))
 449     (hi-lock-read-face-name)))
 450   (or (facep face) (setq face 'hi-yellow))
 451   (unless hi-lock-mode (hi-lock-mode 1))
 452   (hi-lock-set-pattern regexp face))
 453
 454 ;;;###autoload
 455 (defalias 'highlight-phrase 'hi-lock-face-phrase-buffer)
 456 ;;;###autoload
 457 (defun hi-lock-face-phrase-buffer (regexp &optional face)
 458   "Set face of each match of phrase REGEXP to FACE.
 459 If called interactively, replaces whitespace in REGEXP with
 460 arbitrary whitespace and makes initial lower-case letters case-insensitive.
 461
 462 If Font Lock mode is enabled in the buffer, it is used to
 463 highlight REGEXP.  If Font Lock mode is disabled, overlays are
 464 used for highlighting; in this case, the highlighting will not be
 465 updated as you type."
 466   (interactive
 467    (list
 468     (hi-lock-regexp-okay
 469      (hi-lock-process-phrase
 470       (read-regexp "Phrase to highlight" (car regexp-history))))
 471     (hi-lock-read-face-name)))
 472   (or (facep face) (setq face 'hi-yellow))
 473   (unless hi-lock-mode (hi-lock-mode 1))
 474   (hi-lock-set-pattern regexp face))
 475
 476 (declare-function x-popup-menu "menu.c" (position menu))
 477
 478 (defun hi-lock--regexps-at-point ()
 479   (let ((regexps '()))
 480     ;; When using overlays, there is no ambiguity on the best
 481     ;; choice of regexp.
 482     (let ((desired-serial (get-char-property
 483                            (point) 'hi-lock-overlay-regexp)))
 484       (when desired-serial
 485         (catch 'regexp
 486           (maphash
 487            (lambda (regexp serial)
 488              (when (= serial desired-serial)
 489                (push regexp regexps)))
 490            hi-lock-string-serialize-hash))))
 491     ;; With font-locking on, check if the cursor is on an highlighted text.
 492     ;; Checking for hi-lock face is a good heuristic.
 493     (and (string-match "\\`hi-lock-" (face-name (face-at-point)))
 494          (let* ((hi-text
 495                  (buffer-substring-no-properties
 496                   (previous-single-property-change (point) 'face)
 497                   (next-single-property-change (point) 'face))))
 498            ;; Compute hi-lock patterns that match the
 499            ;; highlighted text at point.  Use this later in
 500            ;; during completing-read.
 501            (dolist (hi-lock-pattern hi-lock-interactive-patterns)
 502              (let ((regexp (car hi-lock-pattern)))
 503                (if (string-match regexp hi-text)
 504                    (push regexp regexps))))))))
 505
 506 ;;;###autoload
 507 (defalias 'unhighlight-regexp 'hi-lock-unface-buffer)
 508 ;;;###autoload
 509 (defun hi-lock-unface-buffer (regexp)
 510   "Remove highlighting of each match to REGEXP set by hi-lock.
 511 Interactively, prompt for REGEXP, accepting only regexps
 512 previously inserted by hi-lock interactive functions.
 513 If REGEXP is t (or if \\[universal-argument] was specified interactively),
 514 then remove all hi-lock highlighting."
 515   (interactive
 516    (cond
 517     (current-prefix-arg (list t))
 518     ((and (display-popup-menus-p)
 519           (listp last-nonmenu-event)
 520           use-dialog-box)
 521      (catch 'snafu
 522        (or
 523         (x-popup-menu
 524          t
 525          (cons
 526           `keymap
 527           (cons "Select Pattern to Unhighlight"
 528                 (mapcar (lambda (pattern)
 529                           (list (car pattern)
 530                                 (format
 531                                  "%s (%s)" (car pattern)
 532                                  (symbol-name
 533                                   (car
 534                                    (cdr (car (cdr (car (cdr pattern))))))))
 535                                 (cons nil nil)
 536                                 (car pattern)))
 537                         hi-lock-interactive-patterns))))
 538         ;; If the user clicks outside the menu, meaning that they
 539         ;; change their mind, x-popup-menu returns nil, and
 540         ;; interactive signals a wrong number of arguments error.
 541         ;; To prevent that, we return an empty string, which will
 542         ;; effectively disable the rest of the function.
 543         (throw 'snafu '("")))))
 544     (t
 545      ;; Un-highlighting triggered via keyboard action.
 546      (unless hi-lock-interactive-patterns
 547        (error "No highlighting to remove"))
 548      ;; Infer the regexp to un-highlight based on cursor position.
 549      (let* ((defaults (hi-lock--regexps-at-point)))
 550        (list
 551         (completing-read (if (null defaults)
 552                              "Regexp to unhighlight: "
 553                            (format "Regexp to unhighlight (default %s): "
 554                                    (car defaults)))
 555                          hi-lock-interactive-patterns
 556                          nil t nil nil defaults))))))
 557   (dolist (keyword (if (eq regexp t) hi-lock-interactive-patterns
 558                      (list (assoc regexp hi-lock-interactive-patterns))))
 559     (when keyword
 560       (font-lock-remove-keywords nil (list keyword))
 561       (setq hi-lock-interactive-patterns
 562             (delq keyword hi-lock-interactive-patterns))
 563       (remove-overlays
 564        nil nil 'hi-lock-overlay-regexp (hi-lock-string-serialize regexp))
 565       (when font-lock-fontified (font-lock-fontify-buffer)))))
 566
 567 ;;;###autoload
 568 (defun hi-lock-write-interactive-patterns ()
 569   "Write interactively added patterns, if any, into buffer at point.
 570
 571 Interactively added patterns are those normally specified using
 572 `highlight-regexp' and `highlight-lines-matching-regexp'; they can
 573 be found in variable `hi-lock-interactive-patterns'."
 574   (interactive)
 575   (if (null hi-lock-interactive-patterns)
 576       (error "There are no interactive patterns"))
 577   (let ((beg (point)))
 578     (mapc
 579      (lambda (pattern)
 580        (insert (format "%s: (%s)\n"
 581                        hi-lock-file-patterns-prefix
 582                        (prin1-to-string pattern))))
 583      hi-lock-interactive-patterns)
 584     (comment-region beg (point)))
 585   (when (> (point) hi-lock-file-patterns-range)
 586     (warn "Inserted keywords not close enough to top of file")))
 587
 588 ;; Implementation Functions
 589
 590 (defun hi-lock-process-phrase (phrase)
 591   "Convert regexp PHRASE to a regexp that matches phrases.
 592
 593 Blanks in PHRASE replaced by regexp that matches arbitrary whitespace
 594 and initial lower-case letters made case insensitive."
 595   (let ((mod-phrase nil))
 596     ;; FIXME fragile; better to just bind case-fold-search?  (Bug#7161)
 597     (setq mod-phrase
 598           (replace-regexp-in-string
 599            "\\(^\\|\\s-\\)\\([a-z]\\)"
 600            (lambda (m) (format "%s[%s%s]"
 601                                (match-string 1 m)
 602                                (upcase (match-string 2 m))
 603                                (match-string 2 m))) phrase))
 604     ;; FIXME fragile; better to use search-spaces-regexp?
 605     (setq mod-phrase
 606           (replace-regexp-in-string
 607            "\\s-+" "[ \t\n]+" mod-phrase nil t))))
 608
 609 (defun hi-lock-regexp-okay (regexp)
 610   "Return REGEXP if it appears suitable for a font-lock pattern.
 611
 612 Otherwise signal an error.  A pattern that matches the null string is
 613 not suitable."
 614   (if (string-match regexp "")
 615       (error "Regexp cannot match an empty string")
 616     regexp))
 617
 618 (defun hi-lock-read-face-name ()
 619   "Return face name for interactive highlighting.
 620 When `hi-lock-auto-select-face' is non-nil, just return the next face.
 621 Otherwise, read face name from minibuffer with completion and history."
 622   (if hi-lock-auto-select-face
 623       ;; Return current head and rotate the face list.
 624       (pop hi-lock--auto-select-face-defaults)
 625     (intern (completing-read
 626              "Highlight using face: "
 627              obarray 'facep t
 628              (cons (car hi-lock-face-defaults)
 629                    (let ((prefix
 630                           (try-completion
 631                            (substring (car hi-lock-face-defaults) 0 1)
 632                            hi-lock-face-defaults)))
 633                      (if (and (stringp prefix)
 634                               (not (equal prefix (car hi-lock-face-defaults))))
 635                          (length prefix) 0)))
 636              'face-name-history
 637              (cdr hi-lock-face-defaults)))))
 638
 639 (defun hi-lock-set-pattern (regexp face)
 640   "Highlight REGEXP with face FACE."
 641   (let ((pattern (list regexp (list 0 (list 'quote face) t))))
 642     (unless (member pattern hi-lock-interactive-patterns)
 643       (push pattern hi-lock-interactive-patterns)
 644       (if font-lock-mode
 645           (progn
 646             (font-lock-add-keywords nil (list pattern) t)
 647             (font-lock-fontify-buffer))
 648         (let* ((serial (hi-lock-string-serialize regexp))
 649                (range-min (- (point) (/ hi-lock-highlight-range 2)))
 650                (range-max (+ (point) (/ hi-lock-highlight-range 2)))
 651                (search-start
 652                 (max (point-min)
 653                      (- range-min (max 0 (- range-max (point-max))))))
 654                (search-end
 655                 (min (point-max)
 656                      (+ range-max (max 0 (- (point-min) range-min))))))
 657           (save-excursion
 658             (goto-char search-start)
 659             (while (re-search-forward regexp search-end t)
 660               (let ((overlay (make-overlay (match-beginning 0) (match-end 0))))
 661                 (overlay-put overlay 'hi-lock-overlay t)
 662                 (overlay-put overlay 'hi-lock-overlay-regexp serial)
 663                 (overlay-put overlay 'face face))
 664               (goto-char (match-end 0)))))))))
 665
 666 (defun hi-lock-set-file-patterns (patterns)
 667   "Replace file patterns list with PATTERNS and refontify."
 668   (when (or hi-lock-file-patterns patterns)
 669     (font-lock-remove-keywords nil hi-lock-file-patterns)
 670     (setq hi-lock-file-patterns patterns)
 671     (font-lock-add-keywords nil hi-lock-file-patterns t)
 672     (font-lock-fontify-buffer)))
 673
 674 (defun hi-lock-find-patterns ()
 675   "Find patterns in current buffer for hi-lock."
 676   (interactive)
 677   (unless (memq major-mode hi-lock-exclude-modes)
 678     (let ((all-patterns nil)
 679           (target-regexp (concat "\\<" hi-lock-file-patterns-prefix ":")))
 680       (save-excursion
 681         (save-restriction
 682           (widen)
 683           (goto-char (point-min))
 684           (re-search-forward target-regexp
 685                              (+ (point) hi-lock-file-patterns-range) t)
 686           (beginning-of-line)
 687           (while (and (re-search-forward target-regexp (+ (point) 100) t)
 688                       (not (looking-at "\\s-*end")))
 689             (condition-case nil
 690                 (setq all-patterns (append (read (current-buffer)) all-patterns))
 691               (error (message "Invalid pattern list expression at %d"
 692                               (line-number-at-pos)))))))
 693       (when (and all-patterns
 694                  hi-lock-mode
 695                  (cond
 696                   ((eq this-command 'hi-lock-find-patterns) t)
 697                   ((functionp hi-lock-file-patterns-policy)
 698                    (funcall hi-lock-file-patterns-policy all-patterns))
 699                   ((eq hi-lock-file-patterns-policy 'ask)
 700                    (y-or-n-p "Add patterns from this buffer to hi-lock? "))
 701                   (t nil)))
 702         (hi-lock-set-file-patterns all-patterns)
 703         (if (called-interactively-p 'interactive)
 704             (message "Hi-lock added %d patterns." (length all-patterns)))))))
 705
 706 (defun hi-lock-font-lock-hook ()
 707   "Add hi-lock patterns to font-lock's."
 708   (when font-lock-fontified
 709     (font-lock-add-keywords nil hi-lock-file-patterns t)
 710     (font-lock-add-keywords nil hi-lock-interactive-patterns t)))
 711
 712 (defvar hi-lock-string-serialize-hash
 713   ;; FIXME: don't map strings to numbers but to unique strings via
 714   ;; hash-consing, with a weak hash-table.
 715   (make-hash-table :test 'equal)
 716   "Hash table used to assign unique numbers to strings.")
 717
 718 (defvar hi-lock-string-serialize-serial 1
 719   "Number assigned to last new string in call to `hi-lock-string-serialize'.
 720 A string is considered new if it had not previously been used in a call to
 721 `hi-lock-string-serialize'.")
 722
 723 (defun hi-lock-string-serialize (string)
 724   "Return unique serial number for STRING."
 725   (interactive)
 726   (let ((val (gethash string hi-lock-string-serialize-hash)))
 727     (if val val
 728       (puthash string
 729                (setq hi-lock-string-serialize-serial
 730                      (1+ hi-lock-string-serialize-serial))
 731                hi-lock-string-serialize-hash)
 732       hi-lock-string-serialize-serial)))
 733
 734 (defun hi-lock-unload-function ()
 735   "Unload the Hi-Lock library."
 736   (global-hi-lock-mode -1)
 737   ;; continue standard unloading
 738   nil)
 739
 740 (provide 'hi-lock)
 741
 742 ;;; hi-lock.el ends here