lisp/font-lock.el

   1 ;;; font-lock.el --- Electric font lock mode
   2
   3 ;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   4 ;;   2000, 2001, 2002, 2003, 2004 2005 Free Software Foundation, Inc.
   5
   6 ;; Author: jwz, then rms, then sm
   7 ;; Maintainer: FSF
   8 ;; Keywords: languages, faces
   9
  10 ;; This file is part of GNU Emacs.
  11
  12 ;; GNU Emacs is free software; you can redistribute it and/or modify
  13 ;; it under the terms of the GNU General Public License as published by
  14 ;; the Free Software Foundation; either version 2, or (at your option)
  15 ;; any later version.
  16
  17 ;; GNU Emacs is distributed in the hope that it will be useful,
  18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 ;; GNU General Public License for more details.
  21
  22 ;; You should have received a copy of the GNU General Public License
  23 ;; along with GNU Emacs; see the file COPYING.  If not, write to the
  24 ;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  25 ;; Boston, MA 02110-1301, USA.
  26
  27 ;;; Commentary:
  28
  29 ;; Font Lock mode is a minor mode that causes your comments to be displayed in
  30 ;; one face, strings in another, reserved words in another, and so on.
  31 ;;
  32 ;; Comments will be displayed in `font-lock-comment-face'.
  33 ;; Strings will be displayed in `font-lock-string-face'.
  34 ;; Regexps are used to display selected patterns in other faces.
  35 ;;
  36 ;; To make the text you type be fontified, use M-x font-lock-mode RET.
  37 ;; When this minor mode is on, the faces of the current line are updated with
  38 ;; every insertion or deletion.
  39 ;;
  40 ;; To turn Font Lock mode on automatically, add this to your ~/.emacs file:
  41 ;;
  42 ;;  (add-hook 'emacs-lisp-mode-hook 'turn-on-font-lock)
  43 ;;
  44 ;; Or if you want to turn Font Lock mode on in many modes:
  45 ;;
  46 ;;  (global-font-lock-mode t)
  47 ;;
  48 ;; Fontification for a particular mode may be available in a number of levels
  49 ;; of decoration.  The higher the level, the more decoration, but the more time
  50 ;; it takes to fontify.  See the variable `font-lock-maximum-decoration', and
  51 ;; also the variable `font-lock-maximum-size'.  Support modes for Font Lock
  52 ;; mode can be used to speed up Font Lock mode.  See `font-lock-support-mode'.
  53 \f
  54 ;;; How Font Lock mode fontifies:
  55
  56 ;; When Font Lock mode is turned on in a buffer, it (a) fontifies the entire
  57 ;; buffer and (b) installs one of its fontification functions on one of the
  58 ;; hook variables that are run by Emacs after every buffer change (i.e., an
  59 ;; insertion or deletion).  Fontification means the replacement of `face' text
  60 ;; properties in a given region; Emacs displays text with these `face' text
  61 ;; properties appropriately.
  62 ;;
  63 ;; Fontification normally involves syntactic (i.e., strings and comments) and
  64 ;; regexp (i.e., keywords and everything else) passes.  There are actually
  65 ;; three passes; (a) the syntactic keyword pass, (b) the syntactic pass and (c)
  66 ;; the keyword pass.  Confused?
  67 ;;
  68 ;; The syntactic keyword pass places `syntax-table' text properties in the
  69 ;; buffer according to the variable `font-lock-syntactic-keywords'.  It is
  70 ;; necessary because Emacs' syntax table is not powerful enough to describe all
  71 ;; the different syntactic constructs required by the sort of people who decide
  72 ;; that a single quote can be syntactic or not depending on the time of day.
  73 ;; (What sort of person could decide to overload the meaning of a quote?)
  74 ;; Obviously the syntactic keyword pass must occur before the syntactic pass.
  75 ;;
  76 ;; The syntactic pass places `face' text properties in the buffer according to
  77 ;; syntactic context, i.e., according to the buffer's syntax table and buffer
  78 ;; text's `syntax-table' text properties.  It involves using a syntax parsing
  79 ;; function to determine the context of different parts of a region of text.  A
  80 ;; syntax parsing function is necessary because generally strings and/or
  81 ;; comments can span lines, and so the context of a given region is not
  82 ;; necessarily apparent from the content of that region.  Because the keyword
  83 ;; pass only works within a given region, it is not generally appropriate for
  84 ;; syntactic fontification.  This is the first fontification pass that makes
  85 ;; changes visible to the user; it fontifies strings and comments.
  86 ;;
  87 ;; The keyword pass places `face' text properties in the buffer according to
  88 ;; the variable `font-lock-keywords'.  It involves searching for given regexps
  89 ;; (or calling given search functions) within the given region.  This is the
  90 ;; second fontification pass that makes changes visible to the user; it
  91 ;; fontifies language reserved words, etc.
  92 ;;
  93 ;; Oh, and the answer is, "Yes, obviously just about everything should be done
  94 ;; in a single syntactic pass, but the only syntactic parser available
  95 ;; understands only strings and comments."  Perhaps one day someone will write
  96 ;; some syntactic parsers for common languages and a son-of-font-lock.el could
  97 ;; use them rather then relying so heavily on the keyword (regexp) pass.
  98
  99 ;;; How Font Lock mode supports modes or is supported by modes:
 100
 101 ;; Modes that support Font Lock mode do so by defining one or more variables
 102 ;; whose values specify the fontification.  Font Lock mode knows of these
 103 ;; variable names from (a) the buffer local variable `font-lock-defaults', if
 104 ;; non-nil, or (b) the global variable `font-lock-defaults-alist', if the major
 105 ;; mode has an entry.  (Font Lock mode is set up via (a) where a mode's
 106 ;; patterns are distributed with the mode's package library, and (b) where a
 107 ;; mode's patterns are distributed with font-lock.el itself.  An example of (a)
 108 ;; is Pascal mode, an example of (b) is Lisp mode.  Normally, the mechanism is
 109 ;; (a); (b) is used where it is not clear which package library should contain
 110 ;; the pattern definitions.)  Font Lock mode chooses which variable to use for
 111 ;; fontification based on `font-lock-maximum-decoration'.
 112 ;;
 113 ;; Font Lock mode fontification behaviour can be modified in a number of ways.
 114 ;; See the below comments and the comments distributed throughout this file.
 115
 116 ;;; Constructing patterns:
 117
 118 ;; See the documentation for the variable `font-lock-keywords'.
 119 ;;
 120 ;; Efficient regexps for use as MATCHERs for `font-lock-keywords' and
 121 ;; `font-lock-syntactic-keywords' can be generated via the function
 122 ;; `regexp-opt'.
 123
 124 ;;; Adding patterns for modes that already support Font Lock:
 125
 126 ;; Though Font Lock highlighting patterns already exist for many modes, it's
 127 ;; likely there's something that you want fontified that currently isn't, even
 128 ;; at the maximum fontification level.  You can add highlighting patterns via
 129 ;; `font-lock-add-keywords'.  For example, say in some C
 130 ;; header file you #define the token `and' to expand to `&&', etc., to make
 131 ;; your C code almost readable.  In your ~/.emacs there could be:
 132 ;;
 133 ;;  (font-lock-add-keywords 'c-mode '("\\<\\(and\\|or\\|not\\)\\>"))
 134 ;;
 135 ;; Some modes provide specific ways to modify patterns based on the values of
 136 ;; other variables.  For example, additional C types can be specified via the
 137 ;; variable `c-font-lock-extra-types'.
 138
 139 ;;; Adding patterns for modes that do not support Font Lock:
 140
 141 ;; Not all modes support Font Lock mode.  If you (as a user of the mode) add
 142 ;; patterns for a new mode, you must define in your ~/.emacs a variable or
 143 ;; variables that specify regexp fontification.  Then, you should indicate to
 144 ;; Font Lock mode, via the mode hook setting `font-lock-defaults', exactly what
 145 ;; support is required.  For example, say Foo mode should have the following
 146 ;; regexps fontified case-sensitively, and comments and strings should not be
 147 ;; fontified automagically.  In your ~/.emacs there could be:
 148 ;;
 149 ;;  (defvar foo-font-lock-keywords
 150 ;;    '(("\\<\\(one\\|two\\|three\\)\\>" . font-lock-keyword-face)
 151 ;;      ("\\<\\(four\\|five\\|six\\)\\>" . font-lock-type-face))
 152 ;;    "Default expressions to highlight in Foo mode.")
 153 ;;
 154 ;;  (add-hook 'foo-mode-hook
 155 ;;   (lambda ()
 156 ;;     (make-local-variable 'font-lock-defaults)
 157 ;;     (setq font-lock-defaults '(foo-font-lock-keywords t))))
 158
 159 ;;; Adding Font Lock support for modes:
 160
 161 ;; Of course, it would be better that the mode already supports Font Lock mode.
 162 ;; The package author would do something similar to above.  The mode must
 163 ;; define at the top-level a variable or variables that specify regexp
 164 ;; fontification.  Then, the mode command should indicate to Font Lock mode,
 165 ;; via `font-lock-defaults', exactly what support is required.  For example,
 166 ;; say Bar mode should have the following regexps fontified case-insensitively,
 167 ;; and comments and strings should be fontified automagically.  In bar.el there
 168 ;; could be:
 169 ;;
 170 ;;  (defvar bar-font-lock-keywords
 171 ;;    '(("\\<\\(uno\\|due\\|tre\\)\\>" . font-lock-keyword-face)
 172 ;;      ("\\<\\(quattro\\|cinque\\|sei\\)\\>" . font-lock-type-face))
 173 ;;    "Default expressions to highlight in Bar mode.")
 174 ;;
 175 ;; and within `bar-mode' there could be:
 176 ;;
 177 ;;  (make-local-variable 'font-lock-defaults)
 178 ;;  (setq font-lock-defaults '(bar-font-lock-keywords nil t))
 179 \f
 180 ;; What is fontification for?  You might say, "It's to make my code look nice."
 181 ;; I think it should be for adding information in the form of cues.  These cues
 182 ;; should provide you with enough information to both (a) distinguish between
 183 ;; different items, and (b) identify the item meanings, without having to read
 184 ;; the items and think about it.  Therefore, fontification allows you to think
 185 ;; less about, say, the structure of code, and more about, say, why the code
 186 ;; doesn't work.  Or maybe it allows you to think less and drift off to sleep.
 187 ;;
 188 ;; So, here are my opinions/advice/guidelines:
 189 ;;
 190 ;; - Highlight conceptual objects, such as function and variable names, and
 191 ;;   different objects types differently, i.e., (a) and (b) above, highlight
 192 ;;   function names differently to variable names.
 193 ;; - Keep the faces distinct from each other as far as possible.
 194 ;;   i.e., (a) above.
 195 ;; - Use the same face for the same conceptual object, across all modes.
 196 ;;   i.e., (b) above, all modes that have items that can be thought of as, say,
 197 ;;   keywords, should be highlighted with the same face, etc.
 198 ;; - Make the face attributes fit the concept as far as possible.
 199 ;;   i.e., function names might be a bold colour such as blue, comments might
 200 ;;   be a bright colour such as red, character strings might be brown, because,
 201 ;;   err, strings are brown (that was not the reason, please believe me).
 202 ;; - Don't use a non-nil OVERRIDE unless you have a good reason.
 203 ;;   Only use OVERRIDE for special things that are easy to define, such as the
 204 ;;   way `...' quotes are treated in strings and comments in Emacs Lisp mode.
 205 ;;   Don't use it to, say, highlight keywords in commented out code or strings.
 206 ;; - Err, that's it.
 207 \f
 208 ;;; Code:
 209
 210 (require 'syntax)
 211
 212 ;; Define core `font-lock' group.
 213 (defgroup font-lock '((jit-lock custom-group))
 214   "Font Lock mode text highlighting package."
 215   :link '(custom-manual "(emacs)Font Lock")
 216   :link '(custom-manual "(elisp)Font Lock Mode")
 217   :group 'faces)
 218
 219 (defgroup font-lock-highlighting-faces nil
 220   "Faces for highlighting text."
 221   :prefix "font-lock-"
 222   :group 'font-lock)
 223
 224 (defgroup font-lock-extra-types nil
 225   "Extra mode-specific type names for highlighting declarations."
 226   :group 'font-lock)
 227 \f
 228 ;; User variables.
 229
 230 (defcustom font-lock-maximum-size 256000
 231   "*Maximum size of a buffer for buffer fontification.
 232 Only buffers less than this can be fontified when Font Lock mode is turned on.
 233 If nil, means size is irrelevant.
 234 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
 235 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
 236  ((c-mode . 256000) (c++-mode . 256000) (rmail-mode . 1048576))
 237 means that the maximum size is 250K for buffers in C or C++ modes, one megabyte
 238 for buffers in Rmail mode, and size is irrelevant otherwise."
 239   :type '(choice (const :tag "none" nil)
 240                  (integer :tag "size")
 241                  (repeat :menu-tag "mode specific" :tag "mode specific"
 242                          :value ((t . nil))
 243                          (cons :tag "Instance"
 244                                (radio :tag "Mode"
 245                                       (const :tag "all" t)
 246                                       (symbol :tag "name"))
 247                                (radio :tag "Size"
 248                                       (const :tag "none" nil)
 249                                       (integer :tag "size")))))
 250   :group 'font-lock)
 251
 252 (defcustom font-lock-maximum-decoration t
 253   "*Maximum decoration level for fontification.
 254 If nil, use the default decoration (typically the minimum available).
 255 If t, use the maximum decoration available.
 256 If a number, use that level of decoration (or if not available the maximum).
 257 If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),
 258 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
 259  ((c-mode . t) (c++-mode . 2) (t . 1))
 260 means use the maximum decoration available for buffers in C mode, level 2
 261 decoration for buffers in C++ mode, and level 1 decoration otherwise."
 262   :type '(choice (const :tag "default" nil)
 263                  (const :tag "maximum" t)
 264                  (integer :tag "level" 1)
 265                  (repeat :menu-tag "mode specific" :tag "mode specific"
 266                          :value ((t . t))
 267                          (cons :tag "Instance"
 268                                (radio :tag "Mode"
 269                                       (const :tag "all" t)
 270                                       (symbol :tag "name"))
 271                                (radio :tag "Decoration"
 272                                       (const :tag "default" nil)
 273                                       (const :tag "maximum" t)
 274                                       (integer :tag "level" 1)))))
 275   :group 'font-lock)
 276
 277 (defcustom font-lock-verbose 0
 278   "*If non-nil, means show status messages for buffer fontification.
 279 If a number, only buffers greater than this size have fontification messages."
 280   :type '(choice (const :tag "never" nil)
 281                  (other :tag "always" t)
 282                  (integer :tag "size"))
 283   :group 'font-lock)
 284
 285 (defcustom font-lock-lines-before 0
 286   "*Number of lines before the changed text to include in refontification."
 287   :type 'integer
 288   :group 'font-lock
 289   :version "22.1")
 290 \f
 291
 292 ;; Originally these variable values were face names such as `bold' etc.
 293 ;; Now we create our own faces, but we keep these variables for compatibility
 294 ;; and they give users another mechanism for changing face appearance.
 295 ;; We now allow a FACENAME in `font-lock-keywords' to be any expression that
 296 ;; returns a face.  So the easiest thing is to continue using these variables,
 297 ;; rather than sometimes evaling FACENAME and sometimes not.  sm.
 298 (defvar font-lock-comment-face          'font-lock-comment-face
 299   "Face name to use for comments.")
 300
 301 (defvar font-lock-comment-delimiter-face 'font-lock-comment-delimiter-face
 302   "Face name to use for comment delimiters.")
 303
 304 (defvar font-lock-string-face           'font-lock-string-face
 305   "Face name to use for strings.")
 306
 307 (defvar font-lock-doc-face              'font-lock-doc-face
 308   "Face name to use for documentation.")
 309
 310 (defvar font-lock-keyword-face          'font-lock-keyword-face
 311   "Face name to use for keywords.")
 312
 313 (defvar font-lock-builtin-face          'font-lock-builtin-face
 314   "Face name to use for builtins.")
 315
 316 (defvar font-lock-function-name-face    'font-lock-function-name-face
 317   "Face name to use for function names.")
 318
 319 (defvar font-lock-variable-name-face    'font-lock-variable-name-face
 320   "Face name to use for variable names.")
 321
 322 (defvar font-lock-type-face             'font-lock-type-face
 323   "Face name to use for type and class names.")
 324
 325 (defvar font-lock-constant-face         'font-lock-constant-face
 326   "Face name to use for constant and label names.")
 327
 328 (defvar font-lock-warning-face          'font-lock-warning-face
 329   "Face name to use for things that should stand out.")
 330
 331 (defvar font-lock-negation-char-face    'font-lock-negation-char-face
 332   "Face name to use for easy to overlook negation.
 333 This can be an \"!\" or the \"n\" in \"ifndef\".")
 334
 335 (defvar font-lock-preprocessor-face     'font-lock-preprocessor-face
 336   "Face name to use for preprocessor directives.")
 337
 338 (defvar font-lock-reference-face        'font-lock-constant-face)
 339 (make-obsolete-variable 'font-lock-reference-face 'font-lock-constant-face)
 340
 341 ;; Fontification variables:
 342
 343 ;;;###autoload
 344 (defvar font-lock-keywords nil
 345   "A list of the keywords to highlight.
 346 There are two kinds of values: user-level, and compiled.
 347
 348 A user-level keywords list is what a major mode or the user would
 349 set up.  Normally the list would come from `font-lock-defaults'.
 350 through selection of a fontification level and evaluation of any
 351 contained expressions.  You can also alter it by calling
 352 `font-lock-add-keywords' or `font-lock-remove-keywords' with MODE = nil.
 353
 354 Each element in a user-level keywords list should have one of these forms:
 355
 356  MATCHER
 357  (MATCHER . SUBEXP)
 358  (MATCHER . FACENAME)
 359  (MATCHER . HIGHLIGHT)
 360  (MATCHER HIGHLIGHT ...)
 361  (eval . FORM)
 362
 363 where MATCHER can be either the regexp to search for, or the function name to
 364 call to make the search (called with one argument, the limit of the search;
 365 it should return non-nil, move point, and set `match-data' appropriately iff
 366 it succeeds; like `re-search-forward' would).
 367 MATCHER regexps can be generated via the function `regexp-opt'.
 368
 369 FORM is an expression, whose value should be a keyword element, evaluated when
 370 the keyword is (first) used in a buffer.  This feature can be used to provide a
 371 keyword that can only be generated when Font Lock mode is actually turned on.
 372
 373 HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED.
 374
 375 For highlighting single items, for example each instance of the word \"foo\",
 376 typically only MATCH-HIGHLIGHT is required.
 377 However, if an item or (typically) items are to be highlighted following the
 378 instance of another item (the anchor), for example each instance of the
 379 word \"bar\" following the word \"anchor\" then MATCH-ANCHORED may be required.
 380
 381 MATCH-HIGHLIGHT should be of the form:
 382
 383  (SUBEXP FACENAME [OVERRIDE [LAXMATCH]])
 384
 385 SUBEXP is the number of the subexpression of MATCHER to be highlighted.
 386
 387 FACENAME is an expression whose value is the face name to use.
 388 Instead of a face, FACENAME can evaluate to a property list
 389 of the form (face FACE PROP1 VAL1 PROP2 VAL2 ...)
 390 in which case all the listed text-properties will be set rather than
 391 just FACE.  In such a case, you will most likely want to put those
 392 properties in `font-lock-extra-managed-props' or to override
 393 `font-lock-unfontify-region-function'.
 394
 395 OVERRIDE and LAXMATCH are flags.  If OVERRIDE is t, existing fontification can
 396 be overwritten.  If `keep', only parts not already fontified are highlighted.
 397 If `prepend' or `append', existing fontification is merged with the new, in
 398 which the new or existing fontification, respectively, takes precedence.
 399 If LAXMATCH is non-nil, that means don't signal an error if there is
 400 no match for SUBEXP in MATCHER.
 401
 402 For example, an element of the form highlights (if not already highlighted):
 403
 404  \"\\\\\\=<foo\\\\\\=>\"                discrete occurrences of \"foo\" in the value of the
 405                         variable `font-lock-keyword-face'.
 406  (\"fu\\\\(bar\\\\)\" . 1)      substring \"bar\" within all occurrences of \"fubar\" in
 407                         the value of `font-lock-keyword-face'.
 408  (\"fubar\" . fubar-face)       Occurrences of \"fubar\" in the value of `fubar-face'.
 409  (\"foo\\\\|bar\" 0 foo-bar-face t)
 410                         occurrences of either \"foo\" or \"bar\" in the value
 411                         of `foo-bar-face', even if already highlighted.
 412  (fubar-match 1 fubar-face)
 413                         the first subexpression within all occurrences of
 414                         whatever the function `fubar-match' finds and matches
 415                         in the value of `fubar-face'.
 416
 417 MATCH-ANCHORED should be of the form:
 418
 419  (MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...)
 420
 421 where MATCHER is a regexp to search for or the function name to call to make
 422 the search, as for MATCH-HIGHLIGHT above, but with one exception; see below.
 423 PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after
 424 the last, instance MATCH-ANCHORED's MATCHER is used.  Therefore they can be
 425 used to initialize before, and cleanup after, MATCHER is used.  Typically,
 426 PRE-MATCH-FORM is used to move to some position relative to the original
 427 MATCHER, before starting with MATCH-ANCHORED's MATCHER.  POST-MATCH-FORM might
 428 be used to move back, before resuming with MATCH-ANCHORED's parent's MATCHER.
 429
 430 For example, an element of the form highlights (if not already highlighted):
 431
 432  (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
 433
 434  discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent
 435  discrete occurrences of \"item\" (on the same line) in the value of `item-face'.
 436  (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil.  Therefore \"item\" is
 437  initially searched for starting from the end of the match of \"anchor\", and
 438  searching for subsequent instances of \"anchor\" resumes from where searching
 439  for \"item\" concluded.)
 440
 441 The above-mentioned exception is as follows.  The limit of the MATCHER search
 442 defaults to the end of the line after PRE-MATCH-FORM is evaluated.
 443 However, if PRE-MATCH-FORM returns a position greater than the position after
 444 PRE-MATCH-FORM is evaluated, that position is used as the limit of the search.
 445 It is generally a bad idea to return a position greater than the end of the
 446 line, i.e., cause the MATCHER search to span lines.
 447
 448 These regular expressions can match text which spans lines, although
 449 it is better to avoid it if possible since updating them while editing
 450 text is slower, and it is not guaranteed to be always correct when using
 451 support modes like jit-lock or lazy-lock.
 452
 453 This variable is set by major modes via the variable `font-lock-defaults'.
 454 Be careful when composing regexps for this list; a poorly written pattern can
 455 dramatically slow things down!
 456
 457 A compiled keywords list starts with t.  It is produced internal
 458 by `font-lock-compile-keywords' from a user-level keywords list.
 459 Its second element is the user-level keywords list that was
 460 compiled.  The remaining elements have the same form as
 461 user-level keywords, but normally their values have been
 462 optimized.")
 463
 464 (defvar font-lock-keywords-alist nil
 465   "Alist of additional `font-lock-keywords' elements for major modes.
 466
 467 Each element has the form (MODE KEYWORDS . APPEND).
 468 `font-lock-set-defaults' adds the elements in the list KEYWORDS to
 469 `font-lock-keywords' when Font Lock is turned on in major mode MODE.
 470
 471 If APPEND is nil, KEYWORDS are added at the beginning of
 472 `font-lock-keywords'.  If it is `set', they are used to replace the
 473 value of `font-lock-keywords'.  If APPEND is any other non-nil value,
 474 they are added at the end.
 475
 476 This is normally set via `font-lock-add-keywords' and
 477 `font-lock-remove-keywords'.")
 478
 479 (defvar font-lock-removed-keywords-alist nil
 480   "Alist of `font-lock-keywords' elements to be removed for major modes.
 481
 482 Each element has the form (MODE . KEYWORDS).  `font-lock-set-defaults'
 483 removes the elements in the list KEYWORDS from `font-lock-keywords'
 484 when Font Lock is turned on in major mode MODE.
 485
 486 This is normally set via `font-lock-add-keywords' and
 487 `font-lock-remove-keywords'.")
 488
 489 (defvar font-lock-keywords-only nil
 490   "*Non-nil means Font Lock should not fontify comments or strings.
 491 This is normally set via `font-lock-defaults'.")
 492
 493 (defvar font-lock-keywords-case-fold-search nil
 494   "*Non-nil means the patterns in `font-lock-keywords' are case-insensitive.
 495 This is normally set via `font-lock-defaults'.")
 496 (make-variable-buffer-local 'font-lock-keywords-case-fold-search)
 497
 498 (defvar font-lock-syntactically-fontified 0
 499   "Point up to which `font-lock-syntactic-keywords' has been applied.
 500 If nil, this is ignored, in which case the syntactic fontification may
 501 sometimes be slightly incorrect.")
 502 (make-variable-buffer-local 'font-lock-syntactically-fontified)
 503
 504 (defvar font-lock-syntactic-face-function
 505   (lambda (state)
 506     (if (nth 3 state) font-lock-string-face font-lock-comment-face))
 507   "Function to determine which face to use when fontifying syntactically.
 508 The function is called with a single parameter (the state as returned by
 509 `parse-partial-sexp' at the beginning of the region to highlight) and
 510 should return a face.  This is normally set via `font-lock-defaults'.")
 511
 512 (defvar font-lock-syntactic-keywords nil
 513   "A list of the syntactic keywords to put syntax properties on.
 514 The value can be the list itself, or the name of a function or variable
 515 whose value is the list.
 516
 517 See `font-lock-keywords' for a description of the form of this list;
 518 only the differences are stated here.  MATCH-HIGHLIGHT should be of the form:
 519
 520  (SUBEXP SYNTAX OVERRIDE LAXMATCH)
 521
 522 where SYNTAX can be a string (as taken by `modify-syntax-entry'), a syntax
 523 table, a cons cell (as returned by `string-to-syntax') or an expression whose
 524 value is such a form.  OVERRIDE cannot be `prepend' or `append'.
 525
 526 Here are two examples of elements of `font-lock-syntactic-keywords'
 527 and what they do:
 528
 529  (\"\\\\$\\\\(#\\\\)\" 1 \".\")
 530
 531  gives a hash character punctuation syntax (\".\") when following a
 532  dollar-sign character.  Hash characters in other contexts will still
 533  follow whatever the syntax table says about the hash character.
 534
 535  (\"\\\\('\\\\).\\\\('\\\\)\"
 536   (1 \"\\\"\")
 537   (2 \"\\\"\"))
 538
 539  gives a pair single-quotes, which surround a single character, a SYNTAX of
 540  \"\\\"\" (meaning string quote syntax).  Single-quote characters in other
 541  contexts will not be affected.
 542
 543 This is normally set via `font-lock-defaults'.")
 544
 545 (defvar font-lock-syntax-table nil
 546   "Non-nil means use this syntax table for fontifying.
 547 If this is nil, the major mode's syntax table is used.
 548 This is normally set via `font-lock-defaults'.")
 549
 550 (defvar font-lock-beginning-of-syntax-function nil
 551   "*Non-nil means use this function to move back outside all constructs.
 552 When called with no args it should move point backward to a place which
 553 is not in a string or comment and not within any bracket-pairs (or else,
 554 a place such that any bracket-pairs outside it can be ignored for Emacs
 555 syntax analysis and fontification).
 556
 557 If this is nil, Font Lock uses `syntax-begin-function' to move back
 558 outside of any comment, string, or sexp.  This variable is semi-obsolete;
 559 we recommend setting `syntax-begin-function' instead.
 560
 561 This is normally set via `font-lock-defaults'.")
 562
 563 (defvar font-lock-mark-block-function nil
 564   "*Non-nil means use this function to mark a block of text.
 565 When called with no args it should leave point at the beginning of any
 566 enclosing textual block and mark at the end.
 567 This is normally set via `font-lock-defaults'.")
 568
 569 (defvar font-lock-fontify-buffer-function 'font-lock-default-fontify-buffer
 570   "Function to use for fontifying the buffer.
 571 This is normally set via `font-lock-defaults'.")
 572
 573 (defvar font-lock-unfontify-buffer-function 'font-lock-default-unfontify-buffer
 574   "Function to use for unfontifying the buffer.
 575 This is used when turning off Font Lock mode.
 576 This is normally set via `font-lock-defaults'.")
 577
 578 (defvar font-lock-fontify-region-function 'font-lock-default-fontify-region
 579   "Function to use for fontifying a region.
 580 It should take two args, the beginning and end of the region, and an optional
 581 third arg VERBOSE.  If VERBOSE is non-nil, the function should print status
 582 messages.  This is normally set via `font-lock-defaults'.")
 583
 584 (defvar font-lock-unfontify-region-function 'font-lock-default-unfontify-region
 585   "Function to use for unfontifying a region.
 586 It should take two args, the beginning and end of the region.
 587 This is normally set via `font-lock-defaults'.")
 588
 589 (defvar font-lock-inhibit-thing-lock nil
 590   "List of Font Lock mode related modes that should not be turned on.
 591 Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and
 592 `lazy-lock-mode'.  This is normally set via `font-lock-defaults'.")
 593
 594 (defvar font-lock-multiline nil
 595   "Whether font-lock should cater to multiline keywords.
 596 If nil, don't try to handle multiline patterns.
 597 If t, always handle multiline patterns.
 598 If `undecided', don't try to handle multiline patterns until you see one.
 599 Major/minor modes can set this variable if they know which option applies.")
 600
 601 (defvar font-lock-fontified nil)        ; Whether we have fontified the buffer.
 602 \f
 603 ;; Font Lock mode.
 604
 605 (eval-when-compile
 606   ;;
 607   ;; We don't do this at the top-level as we only use non-autoloaded macros.
 608   (require 'cl)
 609   ;;
 610   ;; Borrowed from lazy-lock.el.
 611   ;; We use this to preserve or protect things when modifying text properties.
 612   (defmacro save-buffer-state (varlist &rest body)
 613     "Bind variables according to VARLIST and eval BODY restoring buffer state."
 614     (declare (indent 1) (debug let))
 615     (let ((modified (make-symbol "modified")))
 616       `(let* ,(append varlist
 617                       `((,modified (buffer-modified-p))
 618                         (buffer-undo-list t)
 619                         (inhibit-read-only t)
 620                         (inhibit-point-motion-hooks t)
 621                         (inhibit-modification-hooks t)
 622                         deactivate-mark
 623                         buffer-file-name
 624                         buffer-file-truename))
 625          (progn
 626            ,@body)
 627          (unless ,modified
 628            (restore-buffer-modified-p nil)))))
 629   ;;
 630   ;; Shut up the byte compiler.
 631   (defvar font-lock-face-attributes))   ; Obsolete but respected if set.
 632
 633 ;;;###autoload
 634 (defun font-lock-mode-internal (arg)
 635   ;; Turn on Font Lock mode.
 636   (when arg
 637     (add-hook 'after-change-functions 'font-lock-after-change-function t t)
 638     (font-lock-set-defaults)
 639     (font-lock-turn-on-thing-lock)
 640     ;; Fontify the buffer if we have to.
 641     (let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size)))
 642       (cond (font-lock-fontified
 643              nil)
 644             ((or (null max-size) (> max-size (buffer-size)))
 645              (font-lock-fontify-buffer))
 646             (font-lock-verbose
 647              (message "Fontifying %s...buffer size greater than font-lock-maximum-size"
 648                       (buffer-name))))))
 649   ;; Turn off Font Lock mode.
 650   (unless font-lock-mode
 651     (remove-hook 'after-change-functions 'font-lock-after-change-function t)
 652     (font-lock-unfontify-buffer)
 653     (font-lock-turn-off-thing-lock)))
 654
 655 ;;;###autoload
 656 (defun font-lock-add-keywords (mode keywords &optional append)
 657   "Add highlighting KEYWORDS for MODE.
 658
 659 MODE should be a symbol, the major mode command name, such as `c-mode'
 660 or nil.  If nil, highlighting keywords are added for the current buffer.
 661 KEYWORDS should be a list; see the variable `font-lock-keywords'.
 662 By default they are added at the beginning of the current highlighting list.
 663 If optional argument APPEND is `set', they are used to replace the current
 664 highlighting list.  If APPEND is any other non-nil value, they are added at the
 665 end of the current highlighting list.
 666
 667 For example:
 668
 669  (font-lock-add-keywords 'c-mode
 670   '((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 font-lock-warning-face prepend)
 671     (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . font-lock-keyword-face)))
 672
 673 adds two fontification patterns for C mode, to fontify `FIXME:' words, even in
 674 comments, and to fontify `and', `or' and `not' words as keywords.
 675
 676 The above procedure will only add the keywords for C mode, not
 677 for modes derived from C mode.  To add them for derived modes too,
 678 pass nil for MODE and add the call to c-mode-hook.
 679
 680 For example:
 681
 682  (add-hook 'c-mode-hook
 683   (lambda ()
 684    (font-lock-add-keywords nil
 685     '((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 font-lock-warning-face prepend)
 686       (\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" .
 687        font-lock-keyword-face)))))
 688
 689 The above procedure may fail to add keywords to derived modes if
 690 some involved major mode does not follow the standard conventions.
 691 File a bug report if this happens, so the major mode can be corrected.
 692
 693 Note that some modes have specialized support for additional patterns, e.g.,
 694 see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types',
 695 `objc-font-lock-extra-types' and `java-font-lock-extra-types'."
 696   (cond (mode
 697          ;; If MODE is non-nil, add the KEYWORDS and APPEND spec to
 698          ;; `font-lock-keywords-alist' so `font-lock-set-defaults' uses them.
 699          (let ((spec (cons keywords append)) cell)
 700            (if (setq cell (assq mode font-lock-keywords-alist))
 701                (if (eq append 'set)
 702                    (setcdr cell (list spec))
 703                  (setcdr cell (append (cdr cell) (list spec))))
 704              (push (list mode spec) font-lock-keywords-alist)))
 705          ;; Make sure that `font-lock-removed-keywords-alist' does not
 706          ;; contain the new keywords.
 707          (font-lock-update-removed-keyword-alist mode keywords append))
 708         (t
 709          ;; Otherwise set or add the keywords now.
 710          ;; This is a no-op if it has been done already in this buffer
 711          ;; for the correct major mode.
 712          (font-lock-set-defaults)
 713          (let ((was-compiled (eq (car font-lock-keywords) t)))
 714            ;; Bring back the user-level (uncompiled) keywords.
 715            (if was-compiled
 716                (setq font-lock-keywords (cadr font-lock-keywords)))
 717            ;; Now modify or replace them.
 718            (if (eq append 'set)
 719                (setq font-lock-keywords keywords)
 720              (font-lock-remove-keywords nil keywords) ;to avoid duplicates
 721              (let ((old (if (eq (car-safe font-lock-keywords) t)
 722                             (cdr font-lock-keywords)
 723                           font-lock-keywords)))
 724                (setq font-lock-keywords (if append
 725                                             (append old keywords)
 726                                           (append keywords old)))))
 727            ;; If the keywords were compiled before, compile them again.
 728            (if was-compiled
 729                (set (make-local-variable 'font-lock-keywords)
 730                     (font-lock-compile-keywords font-lock-keywords t)))))))
 731
 732 (defun font-lock-update-removed-keyword-alist (mode keywords append)
 733   "Update `font-lock-removed-keywords-alist' when adding new KEYWORDS to MODE."
 734   ;; When font-lock is enabled first all keywords in the list
 735   ;; `font-lock-keywords-alist' are added, then all keywords in the
 736   ;; list `font-lock-removed-keywords-alist' are removed.  If a
 737   ;; keyword was once added, removed, and then added again it must be
 738   ;; removed from the removed-keywords list.  Otherwise the second add
 739   ;; will not take effect.
 740   (let ((cell (assq mode font-lock-removed-keywords-alist)))
 741     (if cell
 742         (if (eq append 'set)
 743             ;; A new set of keywords is defined.  Forget all about
 744             ;; our old keywords that should be removed.
 745             (setq font-lock-removed-keywords-alist
 746                   (delq cell font-lock-removed-keywords-alist))
 747           ;; Delete all previously removed keywords.
 748           (dolist (kword keywords)
 749             (setcdr cell (delete kword (cdr cell))))
 750           ;; Delete the mode cell if empty.
 751           (if (null (cdr cell))
 752               (setq font-lock-removed-keywords-alist
 753                     (delq cell font-lock-removed-keywords-alist)))))))
 754
 755 ;; Written by Anders Lindgren <andersl@andersl.com>.
 756 ;;
 757 ;; Case study:
 758 ;; (I)  The keywords are removed from a major mode.
 759 ;;      In this case the keyword could be local (i.e. added earlier by
 760 ;;      `font-lock-add-keywords'), global, or both.
 761 ;;
 762 ;;      (a) In the local case we remove the keywords from the variable
 763 ;;          `font-lock-keywords-alist'.
 764 ;;
 765 ;;      (b) The actual global keywords are not known at this time.
 766 ;;          All keywords are added to `font-lock-removed-keywords-alist',
 767 ;;          when font-lock is enabled those keywords are removed.
 768 ;;
 769 ;;      Note that added keywords are taken out of the list of removed
 770 ;;      keywords.  This ensure correct operation when the same keyword
 771 ;;      is added and removed several times.
 772 ;;
 773 ;; (II) The keywords are removed from the current buffer.
 774 ;;;###autoload
 775 (defun font-lock-remove-keywords (mode keywords)
 776   "Remove highlighting KEYWORDS for MODE.
 777
 778 MODE should be a symbol, the major mode command name, such as `c-mode'
 779 or nil.  If nil, highlighting keywords are removed for the current buffer.
 780
 781 To make the removal apply to modes derived from MODE as well,
 782 pass nil for MODE and add the call to MODE-hook.  This may fail
 783 for some derived modes if some involved major mode does not
 784 follow the standard conventions.  File a bug report if this
 785 happens, so the major mode can be corrected."
 786   (cond (mode
 787          ;; Remove one keyword at the time.
 788          (dolist (keyword keywords)
 789            (let ((top-cell (assq mode font-lock-keywords-alist)))
 790              ;; If MODE is non-nil, remove the KEYWORD from
 791              ;; `font-lock-keywords-alist'.
 792              (when top-cell
 793                (dolist (keyword-list-append-pair (cdr top-cell))
 794                  ;; `keywords-list-append-pair' is a cons with a list of
 795                  ;; keywords in the car top-cell and the original append
 796                  ;; argument in the cdr top-cell.
 797                  (setcar keyword-list-append-pair
 798                          (delete keyword (car keyword-list-append-pair))))
 799                ;; Remove keyword list/append pair when the keyword list
 800                ;; is empty and append doesn't specify `set'.  (If it
 801                ;; should be deleted then previously deleted keywords
 802                ;; would appear again.)
 803                (let ((cell top-cell))
 804                  (while (cdr cell)
 805                    (if (and (null (car (car (cdr cell))))
 806                             (not (eq (cdr (car (cdr cell))) 'set)))
 807                        (setcdr cell (cdr (cdr cell)))
 808                      (setq cell (cdr cell)))))
 809                ;; Final cleanup, remove major mode cell if last keyword
 810                ;; was deleted.
 811                (if (null (cdr top-cell))
 812                    (setq font-lock-keywords-alist
 813                          (delq top-cell font-lock-keywords-alist))))
 814              ;; Remember the keyword in case it is not local.
 815              (let ((cell (assq mode font-lock-removed-keywords-alist)))
 816                (if cell
 817                    (unless (member keyword (cdr cell))
 818                      (nconc cell (list keyword)))
 819                  (push (cons mode (list keyword))
 820                        font-lock-removed-keywords-alist))))))
 821         (t
 822          ;; Otherwise remove it immediately.
 823          (font-lock-set-defaults)
 824          (let ((was-compiled (eq (car font-lock-keywords) t)))
 825            ;; Bring back the user-level (uncompiled) keywords.
 826            (if was-compiled
 827                (setq font-lock-keywords (cadr font-lock-keywords)))
 828
 829            ;; Edit them.
 830            (setq font-lock-keywords (copy-sequence font-lock-keywords))
 831            (dolist (keyword keywords)
 832              (setq font-lock-keywords
 833                    (delete keyword font-lock-keywords)))
 834
 835            ;; If the keywords were compiled before, compile them again.
 836            (if was-compiled
 837                (set (make-local-variable 'font-lock-keywords)
 838                     (font-lock-compile-keywords font-lock-keywords t)))))))
 839 \f
 840 ;;; Font Lock Support mode.
 841
 842 ;; This is the code used to interface font-lock.el with any of its add-on
 843 ;; packages, and provide the user interface.  Packages that have their own
 844 ;; local buffer fontification functions (see below) may have to call
 845 ;; `font-lock-after-fontify-buffer' and/or `font-lock-after-unfontify-buffer'
 846 ;; themselves.
 847
 848 (defcustom font-lock-support-mode 'jit-lock-mode
 849   "*Support mode for Font Lock mode.
 850 Support modes speed up Font Lock mode by being choosy about when fontification
 851 occurs.  The default support mode, Just-in-time Lock mode (symbol
 852 `jit-lock-mode'), is recommended.
 853
 854 Other, older support modes are Fast Lock mode (symbol `fast-lock-mode') and
 855 Lazy Lock mode (symbol `lazy-lock-mode').  See those modes for more info.
 856 However, they are no longer recommended, as Just-in-time Lock mode is better.
 857
 858 If nil, means support for Font Lock mode is never performed.
 859 If a symbol, use that support mode.
 860 If a list, each element should be of the form (MAJOR-MODE . SUPPORT-MODE),
 861 where MAJOR-MODE is a symbol or t (meaning the default).  For example:
 862  ((c-mode . fast-lock-mode) (c++-mode . fast-lock-mode) (t . lazy-lock-mode))
 863 means that Fast Lock mode is used to support Font Lock mode for buffers in C or
 864 C++ modes, and Lazy Lock mode is used to support Font Lock mode otherwise.
 865
 866 The value of this variable is used when Font Lock mode is turned on."
 867   :type '(choice (const :tag "none" nil)
 868                  (const :tag "fast lock" fast-lock-mode)
 869                  (const :tag "lazy lock" lazy-lock-mode)
 870                  (const :tag "jit lock" jit-lock-mode)
 871                  (repeat :menu-tag "mode specific" :tag "mode specific"
 872                          :value ((t . jit-lock-mode))
 873                          (cons :tag "Instance"
 874                                (radio :tag "Mode"
 875                                       (const :tag "all" t)
 876                                       (symbol :tag "name"))
 877                                (radio :tag "Support"
 878                                       (const :tag "none" nil)
 879                                       (const :tag "fast lock" fast-lock-mode)
 880                                       (const :tag "lazy lock" lazy-lock-mode)
 881                                       (const :tag "JIT lock" jit-lock-mode)))
 882                          ))
 883   :version "21.1"
 884   :group 'font-lock)
 885
 886 (defvar fast-lock-mode)
 887 (defvar lazy-lock-mode)
 888 (defvar jit-lock-mode)
 889
 890 (defun font-lock-turn-on-thing-lock ()
 891   (let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode)))
 892     (cond ((eq thing-mode 'fast-lock-mode)
 893            (fast-lock-mode t))
 894           ((eq thing-mode 'lazy-lock-mode)
 895            (lazy-lock-mode t))
 896           ((eq thing-mode 'jit-lock-mode)
 897            ;; Prepare for jit-lock
 898            (remove-hook 'after-change-functions
 899                         'font-lock-after-change-function t)
 900            (set (make-local-variable 'font-lock-fontify-buffer-function)
 901                 'jit-lock-refontify)
 902            ;; Don't fontify eagerly (and don't abort if the buffer is large).
 903            (set (make-local-variable 'font-lock-fontified) t)
 904            ;; Use jit-lock.
 905            (jit-lock-register 'font-lock-fontify-region
 906                               (not font-lock-keywords-only))))))
 907
 908 (defun font-lock-turn-off-thing-lock ()
 909   (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
 910          (fast-lock-mode -1))
 911         ((and (boundp 'jit-lock-mode) jit-lock-mode)
 912          (jit-lock-unregister 'font-lock-fontify-region)
 913          ;; Reset local vars to the non-jit-lock case.
 914          (kill-local-variable 'font-lock-fontify-buffer-function))
 915         ((and (boundp 'lazy-lock-mode) lazy-lock-mode)
 916          (lazy-lock-mode -1))))
 917
 918 (defun font-lock-after-fontify-buffer ()
 919   (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
 920          (fast-lock-after-fontify-buffer))
 921         ;; Useless now that jit-lock intercepts font-lock-fontify-buffer.  -sm
 922         ;; (jit-lock-mode
 923         ;;  (jit-lock-after-fontify-buffer))
 924         ((and (boundp 'lazy-lock-mode) lazy-lock-mode)
 925          (lazy-lock-after-fontify-buffer))))
 926
 927 (defun font-lock-after-unfontify-buffer ()
 928   (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
 929          (fast-lock-after-unfontify-buffer))
 930         ;; Useless as well.  It's only called when:
 931         ;; - turning off font-lock: it does not matter if we leave spurious
 932         ;;   `fontified' text props around since jit-lock-mode is also off.
 933         ;; - font-lock-default-fontify-buffer fails: this is not run
 934         ;;   any more anyway.   -sm
 935         ;;
 936         ;; (jit-lock-mode
 937         ;;  (jit-lock-after-unfontify-buffer))
 938         ((and (boundp 'lazy-lock-mode) lazy-lock-mode)
 939          (lazy-lock-after-unfontify-buffer))))
 940
 941 ;;; End of Font Lock Support mode.
 942 \f
 943 ;;; Fontification functions.
 944
 945 ;; Rather than the function, e.g., `font-lock-fontify-region' containing the
 946 ;; code to fontify a region, the function runs the function whose name is the
 947 ;; value of the variable, e.g., `font-lock-fontify-region-function'.  Normally,
 948 ;; the value of this variable is, e.g., `font-lock-default-fontify-region'
 949 ;; which does contain the code to fontify a region.  However, the value of the
 950 ;; variable could be anything and thus, e.g., `font-lock-fontify-region' could
 951 ;; do anything.  The indirection of the fontification functions gives major
 952 ;; modes the capability of modifying the way font-lock.el fontifies.  Major
 953 ;; modes can modify the values of, e.g., `font-lock-fontify-region-function',
 954 ;; via the variable `font-lock-defaults'.
 955 ;;
 956 ;; For example, Rmail mode sets the variable `font-lock-defaults' so that
 957 ;; font-lock.el uses its own function for buffer fontification.  This function
 958 ;; makes fontification be on a message-by-message basis and so visiting an
 959 ;; RMAIL file is much faster.  A clever implementation of the function might
 960 ;; fontify the headers differently than the message body.  (It should, and
 961 ;; correspondingly for Mail mode, but I can't be bothered to do the work.  Can
 962 ;; you?)  This hints at a more interesting use...
 963 ;;
 964 ;; Languages that contain text normally contained in different major modes
 965 ;; could define their own fontification functions that treat text differently
 966 ;; depending on its context.  For example, Perl mode could arrange that here
 967 ;; docs are fontified differently than Perl code.  Or Yacc mode could fontify
 968 ;; rules one way and C code another.  Neat!
 969 ;;
 970 ;; A further reason to use the fontification indirection feature is when the
 971 ;; default syntactual fontification, or the default fontification in general,
 972 ;; is not flexible enough for a particular major mode.  For example, perhaps
 973 ;; comments are just too hairy for `font-lock-fontify-syntactically-region' to
 974 ;; cope with.  You need to write your own version of that function, e.g.,
 975 ;; `hairy-fontify-syntactically-region', and make your own version of
 976 ;; `hairy-fontify-region' call that function before calling
 977 ;; `font-lock-fontify-keywords-region' for the normal regexp fontification
 978 ;; pass.  And Hairy mode would set `font-lock-defaults' so that font-lock.el
 979 ;; would call your region fontification function instead of its own.  For
 980 ;; example, TeX modes could fontify {\foo ...} and \bar{...}  etc. multi-line
 981 ;; directives correctly and cleanly.  (It is the same problem as fontifying
 982 ;; multi-line strings and comments; regexps are not appropriate for the job.)
 983
 984 ;;;###autoload
 985 (defun font-lock-fontify-buffer ()
 986   "Fontify the current buffer the way the function `font-lock-mode' would."
 987   (interactive)
 988   (let ((font-lock-verbose (or font-lock-verbose (interactive-p))))
 989     (funcall font-lock-fontify-buffer-function)))
 990
 991 (defun font-lock-unfontify-buffer ()
 992   (funcall font-lock-unfontify-buffer-function))
 993
 994 (defun font-lock-fontify-region (beg end &optional loudly)
 995   (funcall font-lock-fontify-region-function beg end loudly))
 996
 997 (defun font-lock-unfontify-region (beg end)
 998   (save-buffer-state nil
 999     (funcall font-lock-unfontify-region-function beg end)))
1000
1001 (defun font-lock-default-fontify-buffer ()
1002   (let ((verbose (if (numberp font-lock-verbose)
1003                      (> (buffer-size) font-lock-verbose)
1004                    font-lock-verbose)))
1005     (with-temp-message
1006         (when verbose
1007           (format "Fontifying %s..." (buffer-name)))
1008       ;; Make sure we have the right `font-lock-keywords' etc.
1009       (unless font-lock-mode
1010         (font-lock-set-defaults))
1011       ;; Make sure we fontify etc. in the whole buffer.
1012       (save-restriction
1013         (widen)
1014         (condition-case nil
1015             (save-excursion
1016               (save-match-data
1017                 (font-lock-fontify-region (point-min) (point-max) verbose)
1018                 (font-lock-after-fontify-buffer)
1019                 (setq font-lock-fontified t)))
1020           ;; We don't restore the old fontification, so it's best to unfontify.
1021           (quit (font-lock-unfontify-buffer)))))))
1022
1023 (defun font-lock-default-unfontify-buffer ()
1024   ;; Make sure we unfontify etc. in the whole buffer.
1025   (save-restriction
1026     (widen)
1027     (font-lock-unfontify-region (point-min) (point-max))
1028     (font-lock-after-unfontify-buffer)
1029     (setq font-lock-fontified nil)))
1030
1031 (defvar font-lock-dont-widen nil
1032   "If non-nil, font-lock will work on the non-widened buffer.
1033 Useful for things like RMAIL and Info where the whole buffer is not
1034 a very meaningful entity to highlight.")
1035
1036 (defun font-lock-default-fontify-region (beg end loudly)
1037   (save-buffer-state
1038       ((parse-sexp-lookup-properties
1039         (or parse-sexp-lookup-properties font-lock-syntactic-keywords))
1040        (old-syntax-table (syntax-table)))
1041     (unwind-protect
1042         (save-restriction
1043           (unless font-lock-dont-widen (widen))
1044           ;; Use the fontification syntax table, if any.
1045           (when font-lock-syntax-table
1046             (set-syntax-table font-lock-syntax-table))
1047           (goto-char beg)
1048           (setq beg (line-beginning-position (- 1 font-lock-lines-before)))
1049           ;; check to see if we should expand the beg/end area for
1050           ;; proper multiline matches
1051           (when (and (> beg (point-min))
1052                      (get-text-property (1- beg) 'font-lock-multiline))
1053             ;; We are just after or in a multiline match.
1054             (setq beg (or (previous-single-property-change
1055                            beg 'font-lock-multiline)
1056                           (point-min)))
1057             (goto-char beg)
1058             (setq beg (line-beginning-position)))
1059           (setq end (or (text-property-any end (point-max)
1060                                            'font-lock-multiline nil)
1061                         (point-max)))
1062           (goto-char end)
1063           ;; Round up to a whole line.
1064           (unless (bolp) (setq end (line-beginning-position 2)))
1065           ;; Now do the fontification.
1066           (font-lock-unfontify-region beg end)
1067           (when font-lock-syntactic-keywords
1068             (font-lock-fontify-syntactic-keywords-region beg end))
1069           (unless font-lock-keywords-only
1070             (font-lock-fontify-syntactically-region beg end loudly))
1071           (font-lock-fontify-keywords-region beg end loudly))
1072       ;; Clean up.
1073       (set-syntax-table old-syntax-table))))
1074
1075 ;; The following must be rethought, since keywords can override fontification.
1076 ;;    ;; Now scan for keywords, but not if we are inside a comment now.
1077 ;;    (or (and (not font-lock-keywords-only)
1078 ;;             (let ((state (parse-partial-sexp beg end nil nil
1079 ;;                                              font-lock-cache-state)))
1080 ;;               (or (nth 4 state) (nth 7 state))))
1081 ;;        (font-lock-fontify-keywords-region beg end))
1082
1083 (defvar font-lock-extra-managed-props nil
1084   "Additional text properties managed by font-lock.
1085 This is used by `font-lock-default-unfontify-region' to decide
1086 what properties to clear before refontifying a region.")
1087
1088 (defun font-lock-default-unfontify-region (beg end)
1089   (remove-list-of-text-properties
1090    beg end (append
1091             font-lock-extra-managed-props
1092             (if font-lock-syntactic-keywords
1093                 '(syntax-table face font-lock-multiline)
1094               '(face font-lock-multiline)))))
1095
1096 ;; Called when any modification is made to buffer text.
1097 (defun font-lock-after-change-function (beg end old-len)
1098   (let ((inhibit-point-motion-hooks t)
1099         (inhibit-quit t))
1100     (save-excursion
1101       (save-match-data
1102         ;; Rescan between start of lines enclosing the region.
1103         (font-lock-fontify-region
1104          (progn (goto-char beg) (forward-line 0) (point))
1105          (progn (goto-char end) (forward-line 1) (point)))))))
1106
1107 (defun font-lock-fontify-block (&optional arg)
1108   "Fontify some lines the way `font-lock-fontify-buffer' would.
1109 The lines could be a function or paragraph, or a specified number of lines.
1110 If ARG is given, fontify that many lines before and after point, or 16 lines if
1111 no ARG is given and `font-lock-mark-block-function' is nil.
1112 If `font-lock-mark-block-function' non-nil and no ARG is given, it is used to
1113 delimit the region to fontify."
1114   (interactive "P")
1115   (let ((inhibit-point-motion-hooks t) font-lock-beginning-of-syntax-function
1116         deactivate-mark)
1117     ;; Make sure we have the right `font-lock-keywords' etc.
1118     (if (not font-lock-mode) (font-lock-set-defaults))
1119     (save-excursion
1120       (save-match-data
1121         (condition-case error-data
1122             (if (or arg (not font-lock-mark-block-function))
1123                 (let ((lines (if arg (prefix-numeric-value arg) 16)))
1124                   (font-lock-fontify-region
1125                    (save-excursion (forward-line (- lines)) (point))
1126                    (save-excursion (forward-line lines) (point))))
1127               (funcall font-lock-mark-block-function)
1128               (font-lock-fontify-region (point) (mark)))
1129           ((error quit) (message "Fontifying block...%s" error-data)))))))
1130
1131 (if (boundp 'facemenu-keymap)
1132     (define-key facemenu-keymap "\M-o" 'font-lock-fontify-block))
1133
1134 ;;; End of Fontification functions.
1135 \f
1136 ;;; Additional text property functions.
1137
1138 ;; The following text property functions should be builtins.  This means they
1139 ;; should be written in C and put with all the other text property functions.
1140 ;; In the meantime, those that are used by font-lock.el are defined in Lisp
1141 ;; below and given a `font-lock-' prefix.  Those that are not used are defined
1142 ;; in Lisp below and commented out.  sm.
1143
1144 (defun font-lock-prepend-text-property (start end prop value &optional object)
1145   "Prepend to one property of the text from START to END.
1146 Arguments PROP and VALUE specify the property and value to prepend to the value
1147 already in place.  The resulting property values are always lists.
1148 Optional argument OBJECT is the string or buffer containing the text."
1149   (let ((val (if (listp value) value (list value))) next prev)
1150     (while (/= start end)
1151       (setq next (next-single-property-change start prop object end)
1152             prev (get-text-property start prop object))
1153       (put-text-property start next prop
1154                          (append val (if (listp prev) prev (list prev)))
1155                          object)
1156       (setq start next))))
1157
1158 (defun font-lock-append-text-property (start end prop value &optional object)
1159   "Append to one property of the text from START to END.
1160 Arguments PROP and VALUE specify the property and value to append to the value
1161 already in place.  The resulting property values are always lists.
1162 Optional argument OBJECT is the string or buffer containing the text."
1163   (let ((val (if (listp value) value (list value))) next prev)
1164     (while (/= start end)
1165       (setq next (next-single-property-change start prop object end)
1166             prev (get-text-property start prop object))
1167       (put-text-property start next prop
1168                          (append (if (listp prev) prev (list prev)) val)
1169                          object)
1170       (setq start next))))
1171
1172 (defun font-lock-fillin-text-property (start end prop value &optional object)
1173   "Fill in one property of the text from START to END.
1174 Arguments PROP and VALUE specify the property and value to put where none are
1175 already in place.  Therefore existing property values are not overwritten.
1176 Optional argument OBJECT is the string or buffer containing the text."
1177   (let ((start (text-property-any start end prop nil object)) next)
1178     (while start
1179       (setq next (next-single-property-change start prop object end))
1180       (put-text-property start next prop value object)
1181       (setq start (text-property-any next end prop nil object)))))
1182
1183 ;; For completeness: this is to `remove-text-properties' as `put-text-property'
1184 ;; is to `add-text-properties', etc.
1185 ;;(defun remove-text-property (start end property &optional object)
1186 ;;  "Remove a property from text from START to END.
1187 ;;Argument PROPERTY is the property to remove.
1188 ;;Optional argument OBJECT is the string or buffer containing the text.
1189 ;;Return t if the property was actually removed, nil otherwise."
1190 ;;  (remove-text-properties start end (list property) object))
1191
1192 ;; For consistency: maybe this should be called `remove-single-property' like
1193 ;; `next-single-property-change' (not `next-single-text-property-change'), etc.
1194 ;;(defun remove-single-text-property (start end prop value &optional object)
1195 ;;  "Remove a specific property value from text from START to END.
1196 ;;Arguments PROP and VALUE specify the property and value to remove.  The
1197 ;;resulting property values are not equal to VALUE nor lists containing VALUE.
1198 ;;Optional argument OBJECT is the string or buffer containing the text."
1199 ;;  (let ((start (text-property-not-all start end prop nil object)) next prev)
1200 ;;    (while start
1201 ;;      (setq next (next-single-property-change start prop object end)
1202 ;;          prev (get-text-property start prop object))
1203 ;;      (cond ((and (symbolp prev) (eq value prev))
1204 ;;           (remove-text-property start next prop object))
1205 ;;          ((and (listp prev) (memq value prev))
1206 ;;           (let ((new (delq value prev)))
1207 ;;             (cond ((null new)
1208 ;;                    (remove-text-property start next prop object))
1209 ;;                   ((= (length new) 1)
1210 ;;                    (put-text-property start next prop (car new) object))
1211 ;;                   (t
1212 ;;                    (put-text-property start next prop new object))))))
1213 ;;      (setq start (text-property-not-all next end prop nil object)))))
1214
1215 ;;; End of Additional text property functions.
1216 \f
1217 ;;; Syntactic regexp fontification functions.
1218
1219 ;; These syntactic keyword pass functions are identical to those keyword pass
1220 ;; functions below, with the following exceptions; (a) they operate on
1221 ;; `font-lock-syntactic-keywords' of course, (b) they are all `defun' as speed
1222 ;; is less of an issue, (c) eval of property value does not occur JIT as speed
1223 ;; is less of an issue, (d) OVERRIDE cannot be `prepend' or `append' as it
1224 ;; makes no sense for `syntax-table' property values, (e) they do not do it
1225 ;; LOUDLY as it is not likely to be intensive.
1226
1227 (defun font-lock-apply-syntactic-highlight (highlight)
1228   "Apply HIGHLIGHT following a match.
1229 HIGHLIGHT should be of the form MATCH-HIGHLIGHT,
1230 see `font-lock-syntactic-keywords'."
1231   (let* ((match (nth 0 highlight))
1232          (start (match-beginning match)) (end (match-end match))
1233          (value (nth 1 highlight))
1234          (override (nth 2 highlight)))
1235     (if (not start)
1236         ;; No match but we might not signal an error.
1237         (or (nth 3 highlight)
1238             (error "No match %d in highlight %S" match highlight))
1239       (when (and (consp value) (not (numberp (car value))))
1240         (setq value (eval value)))
1241       (when (stringp value) (setq value (string-to-syntax value)))
1242       ;; Flush the syntax-cache.  I believe this is not necessary for
1243       ;; font-lock's use of syntax-ppss, but I'm not 100% sure and it can
1244       ;; still be necessary for other users of syntax-ppss anyway.
1245       (syntax-ppss-after-change-function start)
1246       (cond
1247        ((not override)
1248         ;; Cannot override existing fontification.
1249         (or (text-property-not-all start end 'syntax-table nil)
1250             (put-text-property start end 'syntax-table value)))
1251        ((eq override t)
1252         ;; Override existing fontification.
1253         (put-text-property start end 'syntax-table value))
1254        ((eq override 'keep)
1255         ;; Keep existing fontification.
1256         (font-lock-fillin-text-property start end 'syntax-table value))))))
1257
1258 (defun font-lock-fontify-syntactic-anchored-keywords (keywords limit)
1259   "Fontify according to KEYWORDS until LIMIT.
1260 KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords',
1261 LIMIT can be modified by the value of its PRE-MATCH-FORM."
1262   (let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights
1263         ;; Evaluate PRE-MATCH-FORM.
1264         (pre-match-value (eval (nth 1 keywords))))
1265     ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line.
1266     (if (and (numberp pre-match-value) (> pre-match-value (point)))
1267         (setq limit pre-match-value)
1268       (setq limit (line-end-position)))
1269     (save-match-data
1270       ;; Find an occurrence of `matcher' before `limit'.
1271       (while (if (stringp matcher)
1272                  (re-search-forward matcher limit t)
1273                (funcall matcher limit))
1274         ;; Apply each highlight to this instance of `matcher'.
1275         (setq highlights lowdarks)
1276         (while highlights
1277           (font-lock-apply-syntactic-highlight (car highlights))
1278           (setq highlights (cdr highlights)))))
1279     ;; Evaluate POST-MATCH-FORM.
1280     (eval (nth 2 keywords))))
1281
1282 (defun font-lock-fontify-syntactic-keywords-region (start end)
1283   "Fontify according to `font-lock-syntactic-keywords' between START and END.
1284 START should be at the beginning of a line."
1285   ;; Ensure the beginning of the file is properly syntactic-fontified.
1286   (when (and font-lock-syntactically-fontified
1287              (< font-lock-syntactically-fontified start))
1288     (setq start (max font-lock-syntactically-fontified (point-min)))
1289     (setq font-lock-syntactically-fontified end))
1290   ;; If `font-lock-syntactic-keywords' is a symbol, get the real keywords.
1291   (when (symbolp font-lock-syntactic-keywords)
1292     (setq font-lock-syntactic-keywords (font-lock-eval-keywords
1293                                         font-lock-syntactic-keywords)))
1294   ;; If `font-lock-syntactic-keywords' is not compiled, compile it.
1295   (unless (eq (car font-lock-syntactic-keywords) t)
1296     (setq font-lock-syntactic-keywords (font-lock-compile-keywords
1297                                         font-lock-syntactic-keywords)))
1298   ;; Get down to business.
1299   (let ((case-fold-search font-lock-keywords-case-fold-search)
1300         (keywords (cddr font-lock-syntactic-keywords))
1301         keyword matcher highlights)
1302     (while keywords
1303       ;; Find an occurrence of `matcher' from `start' to `end'.
1304       (setq keyword (car keywords) matcher (car keyword))
1305       (goto-char start)
1306       (while (if (stringp matcher)
1307                  (re-search-forward matcher end t)
1308                (funcall matcher end))
1309         ;; Apply each highlight to this instance of `matcher', which may be
1310         ;; specific highlights or more keywords anchored to `matcher'.
1311         (setq highlights (cdr keyword))
1312         (while highlights
1313           (if (numberp (car (car highlights)))
1314               (font-lock-apply-syntactic-highlight (car highlights))
1315             (font-lock-fontify-syntactic-anchored-keywords (car highlights)
1316                                                            end))
1317           (setq highlights (cdr highlights))))
1318       (setq keywords (cdr keywords)))))
1319
1320 ;;; End of Syntactic regexp fontification functions.
1321 \f
1322 ;;; Syntactic fontification functions.
1323
1324 (defvar font-lock-comment-start-skip nil
1325   "If non-nil, Font Lock mode uses this instead of `comment-start-skip'.")
1326
1327 (defvar font-lock-comment-end-skip nil
1328   "If non-nil, Font Lock mode uses this instead of `comment-end'.")
1329
1330 (defun font-lock-fontify-syntactically-region (start end &optional loudly ppss)
1331   "Put proper face on each string and comment between START and END.
1332 START should be at the beginning of a line."
1333   (let ((comment-end-regexp
1334          (or font-lock-comment-end-skip
1335              (regexp-quote
1336               (replace-regexp-in-string "^ *" "" comment-end))))
1337         state face beg)
1338     (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name)))
1339     (goto-char start)
1340     ;;
1341     ;; Find the `start' state.
1342     (setq state (or ppss (syntax-ppss start)))
1343     ;;
1344     ;; Find each interesting place between here and `end'.
1345     (while
1346         (progn
1347           (when (or (nth 3 state) (nth 4 state))
1348             (setq face (funcall font-lock-syntactic-face-function state))
1349             (setq beg (max (nth 8 state) start))
1350             (setq state (parse-partial-sexp (point) end nil nil state
1351                                             'syntax-table))
1352             (when face (put-text-property beg (point) 'face face))
1353             (when (and (eq face 'font-lock-comment-face)
1354                        (or font-lock-comment-start-skip
1355                            comment-start-skip))
1356               ;; Find the comment delimiters
1357               ;; and use font-lock-comment-delimiter-face for them.
1358               (save-excursion
1359                 (goto-char beg)
1360                 (if (looking-at (or font-lock-comment-start-skip
1361                                     comment-start-skip))
1362                     (put-text-property beg (match-end 0) 'face
1363                                        font-lock-comment-delimiter-face)))
1364               (if (looking-back comment-end-regexp (point-at-bol) t)
1365                   (put-text-property (match-beginning 0) (point) 'face
1366                                      font-lock-comment-delimiter-face))))
1367           (< (point) end))
1368       (setq state (parse-partial-sexp (point) end nil nil state
1369                                       'syntax-table)))))
1370
1371 ;;; End of Syntactic fontification functions.
1372 \f
1373 ;;; Keyword regexp fontification functions.
1374
1375 (defsubst font-lock-apply-highlight (highlight)
1376   "Apply HIGHLIGHT following a match.
1377 HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'."
1378   (let* ((match (nth 0 highlight))
1379          (start (match-beginning match)) (end (match-end match))
1380          (override (nth 2 highlight)))
1381     (if (not start)
1382         ;; No match but we might not signal an error.
1383         (or (nth 3 highlight)
1384             (error "No match %d in highlight %S" match highlight))
1385       (let ((val (eval (nth 1 highlight))))
1386         (when (eq (car-safe val) 'face)
1387           (add-text-properties start end (cddr val))
1388           (setq val (cadr val)))
1389         (cond
1390          ((not (or val (eq override t)))
1391           ;; If `val' is nil, don't do anything.  It is important to do it
1392           ;; explicitly, because when adding nil via things like
1393           ;; font-lock-append-text-property, the property is actually
1394           ;; changed from <face> to (<face>) which is undesirable.  --Stef
1395           nil)
1396          ((not override)
1397           ;; Cannot override existing fontification.
1398           (or (text-property-not-all start end 'face nil)
1399               (put-text-property start end 'face val)))
1400          ((eq override t)
1401           ;; Override existing fontification.
1402           (put-text-property start end 'face val))
1403          ((eq override 'prepend)
1404           ;; Prepend to existing fontification.
1405           (font-lock-prepend-text-property start end 'face val))
1406          ((eq override 'append)
1407           ;; Append to existing fontification.
1408           (font-lock-append-text-property start end 'face val))
1409          ((eq override 'keep)
1410           ;; Keep existing fontification.
1411           (font-lock-fillin-text-property start end 'face val)))))))
1412
1413 (defsubst font-lock-fontify-anchored-keywords (keywords limit)
1414   "Fontify according to KEYWORDS until LIMIT.
1415 KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords',
1416 LIMIT can be modified by the value of its PRE-MATCH-FORM."
1417   (let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights
1418         (lead-start (match-beginning 0))
1419         ;; Evaluate PRE-MATCH-FORM.
1420         (pre-match-value (eval (nth 1 keywords))))
1421     ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line.
1422     (if (not (and (numberp pre-match-value) (> pre-match-value (point))))
1423         (setq limit (line-end-position))
1424       (setq limit pre-match-value)
1425       (when (and font-lock-multiline (>= limit (line-beginning-position 2)))
1426         ;; this is a multiline anchored match
1427         ;; (setq font-lock-multiline t)
1428         (put-text-property (if (= limit (line-beginning-position 2))
1429                                (1- limit)
1430                              (min lead-start (point)))
1431                            limit
1432                            'font-lock-multiline t)))
1433     (save-match-data
1434       ;; Find an occurrence of `matcher' before `limit'.
1435       (while (and (< (point) limit)
1436                   (if (stringp matcher)
1437                       (re-search-forward matcher limit t)
1438                     (funcall matcher limit)))
1439         ;; Apply each highlight to this instance of `matcher'.
1440         (setq highlights lowdarks)
1441         (while highlights
1442           (font-lock-apply-highlight (car highlights))
1443           (setq highlights (cdr highlights)))))
1444     ;; Evaluate POST-MATCH-FORM.
1445     (eval (nth 2 keywords))))
1446
1447 (defun font-lock-fontify-keywords-region (start end &optional loudly)
1448   "Fontify according to `font-lock-keywords' between START and END.
1449 START should be at the beginning of a line.
1450 LOUDLY, if non-nil, allows progress-meter bar."
1451   (unless (eq (car font-lock-keywords) t)
1452     (setq font-lock-keywords
1453           (font-lock-compile-keywords font-lock-keywords t)))
1454   (let ((case-fold-search font-lock-keywords-case-fold-search)
1455         (keywords (cddr font-lock-keywords))
1456         (bufname (buffer-name)) (count 0)
1457         (pos (make-marker))
1458         keyword matcher highlights)
1459     ;;
1460     ;; Fontify each item in `font-lock-keywords' from `start' to `end'.
1461     (while keywords
1462       (if loudly (message "Fontifying %s... (regexps..%s)" bufname
1463                           (make-string (incf count) ?.)))
1464       ;;
1465       ;; Find an occurrence of `matcher' from `start' to `end'.
1466       (setq keyword (car keywords) matcher (car keyword))
1467       (goto-char start)
1468       (while (and (< (point) end)
1469                   (if (stringp matcher)
1470                       (re-search-forward matcher end t)
1471                     (funcall matcher end))
1472                   ;; Beware empty string matches since they will
1473                   ;; loop indefinitely.
1474                   (or (> (point) (match-beginning 0))
1475                       (progn (forward-char 1) t)))
1476         (when (and font-lock-multiline
1477                    (>= (point)
1478                        (save-excursion (goto-char (match-beginning 0))
1479                                        (forward-line 1) (point))))
1480           ;; this is a multiline regexp match
1481           ;; (setq font-lock-multiline t)
1482           (put-text-property (if (= (point)
1483                                     (save-excursion
1484                                       (goto-char (match-beginning 0))
1485                                       (forward-line 1) (point)))
1486                                  (1- (point))
1487                                (match-beginning 0))
1488                              (point)
1489                              'font-lock-multiline t))
1490         ;; Apply each highlight to this instance of `matcher', which may be
1491         ;; specific highlights or more keywords anchored to `matcher'.
1492         (setq highlights (cdr keyword))
1493         (while highlights
1494           (if (numberp (car (car highlights)))
1495               (font-lock-apply-highlight (car highlights))
1496             (set-marker pos (point))
1497             (font-lock-fontify-anchored-keywords (car highlights) end)
1498             ;; Ensure forward progress.  `pos' is a marker because anchored
1499             ;; keyword may add/delete text (this happens e.g. in grep.el).
1500             (if (< (point) pos) (goto-char pos)))
1501           (setq highlights (cdr highlights))))
1502       (setq keywords (cdr keywords)))
1503     (set-marker pos nil)))
1504
1505 ;;; End of Keyword regexp fontification functions.
1506 \f
1507 ;; Various functions.
1508
1509 (defun font-lock-compile-keywords (keywords &optional regexp)
1510   "Compile KEYWORDS into the form (t KEYWORDS COMPILED...)
1511 Here each COMPILED is of the form (MATCHER HIGHLIGHT ...) as shown in the
1512 `font-lock-keywords' doc string.
1513 If REGEXP is non-nil, it means these keywords are used for
1514 `font-lock-keywords' rather than for `font-lock-syntactic-keywords'."
1515   (if (eq (car-safe keywords) t)
1516       keywords
1517     (setq keywords
1518           (cons t (cons keywords
1519                         (mapcar 'font-lock-compile-keyword keywords))))
1520     (if (and regexp
1521              (eq (or syntax-begin-function
1522                      font-lock-beginning-of-syntax-function)
1523                  'beginning-of-defun)
1524              (not beginning-of-defun-function))
1525         ;; Try to detect when a string or comment contains something that
1526         ;; looks like a defun and would thus confuse font-lock.
1527         (nconc keywords
1528                `((,(if defun-prompt-regexp
1529                        (concat "^\\(?:" defun-prompt-regexp "\\)?\\s(")
1530                      "^\\s(")
1531                   (0
1532                    (if (memq (get-text-property (match-beginning 0) 'face)
1533                              '(font-lock-string-face font-lock-doc-face
1534                                font-lock-comment-face))
1535                        (list 'face font-lock-warning-face
1536                              'help-echo "Looks like a toplevel defun: escape the parenthesis"))
1537                    prepend)))))
1538     keywords))
1539
1540 (defun font-lock-compile-keyword (keyword)
1541   (cond ((nlistp keyword)                       ; MATCHER
1542          (list keyword '(0 font-lock-keyword-face)))
1543         ((eq (car keyword) 'eval)               ; (eval . FORM)
1544          (font-lock-compile-keyword (eval (cdr keyword))))
1545         ((eq (car-safe (cdr keyword)) 'quote)   ; (MATCHER . 'FORM)
1546          ;; If FORM is a FACENAME then quote it.  Otherwise ignore the quote.
1547          (if (symbolp (nth 2 keyword))
1548              (list (car keyword) (list 0 (cdr keyword)))
1549            (font-lock-compile-keyword (cons (car keyword) (nth 2 keyword)))))
1550         ((numberp (cdr keyword))                ; (MATCHER . MATCH)
1551          (list (car keyword) (list (cdr keyword) 'font-lock-keyword-face)))
1552         ((symbolp (cdr keyword))                ; (MATCHER . FACENAME)
1553          (list (car keyword) (list 0 (cdr keyword))))
1554         ((nlistp (nth 1 keyword))               ; (MATCHER . HIGHLIGHT)
1555          (list (car keyword) (cdr keyword)))
1556         (t                                      ; (MATCHER HIGHLIGHT ...)
1557          keyword)))
1558
1559 (defun font-lock-eval-keywords (keywords)
1560   "Evalulate KEYWORDS if a function (funcall) or variable (eval) name."
1561   (if (listp keywords)
1562       keywords
1563     (font-lock-eval-keywords (if (fboundp keywords)
1564                                  (funcall keywords)
1565                                (eval keywords)))))
1566
1567 (defun font-lock-value-in-major-mode (alist)
1568   "Return value in ALIST for `major-mode', or ALIST if it is not an alist.
1569 Structure is ((MAJOR-MODE . VALUE) ...) where MAJOR-MODE may be t."
1570   (if (consp alist)
1571       (cdr (or (assq major-mode alist) (assq t alist)))
1572     alist))
1573
1574 (defun font-lock-choose-keywords (keywords level)
1575   "Return LEVELth element of KEYWORDS.
1576 A LEVEL of nil is equal to a LEVEL of 0, a LEVEL of t is equal to
1577 \(1- (length KEYWORDS))."
1578   (cond ((not (and (listp keywords) (symbolp (car keywords))))
1579          keywords)
1580         ((numberp level)
1581          (or (nth level keywords) (car (reverse keywords))))
1582         ((eq level t)
1583          (car (reverse keywords)))
1584         (t
1585          (car keywords))))
1586
1587 (defvar font-lock-set-defaults nil)     ; Whether we have set up defaults.
1588
1589 (defvar font-lock-mode-major-mode)
1590 (defun font-lock-set-defaults ()
1591   "Set fontification defaults appropriately for this mode.
1592 Sets various variables using `font-lock-defaults' (or, if nil, using
1593 `font-lock-defaults-alist') and `font-lock-maximum-decoration'."
1594   ;; Set fontification defaults iff not previously set for correct major mode.
1595   (unless (and font-lock-set-defaults
1596                (eq font-lock-mode-major-mode major-mode))
1597     (setq font-lock-mode-major-mode major-mode)
1598     (set (make-local-variable 'font-lock-set-defaults) t)
1599     (make-local-variable 'font-lock-fontified)
1600     (make-local-variable 'font-lock-multiline)
1601     (let* ((defaults (or font-lock-defaults
1602                          (cdr (assq major-mode
1603                                     (with-no-warnings
1604                                       font-lock-defaults-alist)))))
1605            (keywords
1606             (font-lock-choose-keywords (nth 0 defaults)
1607                                        (font-lock-value-in-major-mode font-lock-maximum-decoration)))
1608            (local (cdr (assq major-mode font-lock-keywords-alist)))
1609            (removed-keywords
1610             (cdr-safe (assq major-mode font-lock-removed-keywords-alist))))
1611       (set (make-local-variable 'font-lock-defaults) defaults)
1612       ;; Syntactic fontification?
1613       (when (nth 1 defaults)
1614         (set (make-local-variable 'font-lock-keywords-only) t))
1615       ;; Case fold during regexp fontification?
1616       (when (nth 2 defaults)
1617         (set (make-local-variable 'font-lock-keywords-case-fold-search) t))
1618       ;; Syntax table for regexp and syntactic fontification?
1619       (when (nth 3 defaults)
1620         (set (make-local-variable 'font-lock-syntax-table)
1621              (copy-syntax-table (syntax-table)))
1622         (dolist (selem (nth 3 defaults))
1623           ;; The character to modify may be a single CHAR or a STRING.
1624           (let ((syntax (cdr selem)))
1625             (dolist (char (if (numberp (car selem))
1626                               (list (car selem))
1627                             (mapcar 'identity (car selem))))
1628               (modify-syntax-entry char syntax font-lock-syntax-table)))))
1629       ;; Syntax function for syntactic fontification?
1630       (when (nth 4 defaults)
1631         (set (make-local-variable 'font-lock-beginning-of-syntax-function)
1632              (nth 4 defaults)))
1633       ;; Variable alist?
1634       (dolist (x (nthcdr 5 defaults))
1635         (set (make-local-variable (car x)) (cdr x)))
1636       ;; Set up `font-lock-keywords' last because its value might depend
1637       ;; on other settings (e.g. font-lock-compile-keywords uses
1638       ;; font-lock-beginning-of-syntax-function).
1639       (set (make-local-variable 'font-lock-keywords)
1640            (font-lock-eval-keywords keywords))
1641       ;; Local fontification?
1642       (while local
1643         (font-lock-add-keywords nil (car (car local)) (cdr (car local)))
1644         (setq local (cdr local)))
1645       (when removed-keywords
1646         (font-lock-remove-keywords nil removed-keywords))
1647       ;; Now compile the keywords.
1648       (unless (eq (car font-lock-keywords) t)
1649         (set (make-local-variable 'font-lock-keywords)
1650              (font-lock-compile-keywords font-lock-keywords t))))))
1651 \f
1652 ;;; Colour etc. support.
1653
1654 ;; Originally face attributes were specified via `font-lock-face-attributes'.
1655 ;; Users then changed the default face attributes by setting that variable.
1656 ;; However, we try and be back-compatible and respect its value if set except
1657 ;; for faces where M-x customize has been used to save changes for the face.
1658 (when (boundp 'font-lock-face-attributes)
1659   (let ((face-attributes font-lock-face-attributes))
1660     (while face-attributes
1661       (let* ((face-attribute (pop face-attributes))
1662              (face (car face-attribute)))
1663         ;; Rustle up a `defface' SPEC from a `font-lock-face-attributes' entry.
1664         (unless (get face 'saved-face)
1665           (let ((foreground (nth 1 face-attribute))
1666                 (background (nth 2 face-attribute))
1667                 (bold-p (nth 3 face-attribute))
1668                 (italic-p (nth 4 face-attribute))
1669                 (underline-p (nth 5 face-attribute))
1670                 face-spec)
1671             (when foreground
1672               (setq face-spec (cons ':foreground (cons foreground face-spec))))
1673             (when background
1674               (setq face-spec (cons ':background (cons background face-spec))))
1675             (when bold-p
1676               (setq face-spec (append '(:weight bold) face-spec)))
1677             (when italic-p
1678               (setq face-spec (append '(:slant italic) face-spec)))
1679             (when underline-p
1680               (setq face-spec (append '(:underline t) face-spec)))
1681             (custom-declare-face face (list (list t face-spec)) nil)))))))
1682
1683 ;; But now we do it the custom way.  Note that `defface' will not overwrite any
1684 ;; faces declared above via `custom-declare-face'.
1685 (defface font-lock-comment-face
1686   '((((class grayscale) (background light))
1687      (:foreground "DimGray" :weight bold :slant italic))
1688     (((class grayscale) (background dark))
1689      (:foreground "LightGray" :weight bold :slant italic))
1690     (((class color) (min-colors 88) (background light))
1691      (:foreground "Firebrick"))
1692     (((class color) (min-colors 88) (background dark))
1693      (:foreground "chocolate1"))
1694     (((class color) (min-colors 16) (background light))
1695      (:foreground "red"))
1696     (((class color) (min-colors 16) (background dark))
1697      (:foreground "red1"))
1698     (((class color) (min-colors 8) (background light))
1699      )
1700     (((class color) (min-colors 8) (background dark))
1701      )
1702     (t (:weight bold :slant italic)))
1703   "Font Lock mode face used to highlight comments."
1704   :group 'font-lock-highlighting-faces)
1705
1706 (defface font-lock-comment-delimiter-face
1707   '((default :inherit font-lock-comment-face)
1708     (((class grayscale)))
1709     (((class color) (min-colors 16)))
1710     (((class color) (min-colors 8) (background light))
1711      :foreground "red")
1712     (((class color) (min-colors 8) (background dark))
1713      :foreground "red1"))
1714   "Font Lock mode face used to highlight comment delimiters."
1715   :group 'font-lock-highlighting-faces)
1716
1717 (defface font-lock-string-face
1718   '((((class grayscale) (background light)) (:foreground "DimGray" :slant italic))
1719     (((class grayscale) (background dark)) (:foreground "LightGray" :slant italic))
1720     (((class color) (min-colors 88) (background light)) (:foreground "RosyBrown"))
1721     (((class color) (min-colors 88) (background dark)) (:foreground "LightSalmon"))
1722     (((class color) (min-colors 16) (background light)) (:foreground "RosyBrown"))
1723     (((class color) (min-colors 16) (background dark)) (:foreground "LightSalmon"))
1724     (((class color) (min-colors 8)) (:foreground "green"))
1725     (t (:slant italic)))
1726   "Font Lock mode face used to highlight strings."
1727   :group 'font-lock-highlighting-faces)
1728
1729 (defface font-lock-doc-face
1730   '((t :inherit font-lock-string-face))
1731   "Font Lock mode face used to highlight documentation."
1732   :group 'font-lock-highlighting-faces)
1733
1734 (defface font-lock-keyword-face
1735   '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold))
1736     (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold))
1737     (((class color) (min-colors 88) (background light)) (:foreground "Purple"))
1738     (((class color) (min-colors 88) (background dark)) (:foreground "Cyan1"))
1739     (((class color) (min-colors 16) (background light)) (:foreground "Purple"))
1740     (((class color) (min-colors 16) (background dark)) (:foreground "Cyan"))
1741     (((class color) (min-colors 8)) (:foreground "cyan" :weight bold))
1742     (t (:weight bold)))
1743   "Font Lock mode face used to highlight keywords."
1744   :group 'font-lock-highlighting-faces)
1745
1746 (defface font-lock-builtin-face
1747   '((((class grayscale) (background light)) (:foreground "LightGray" :weight bold))
1748     (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold))
1749     (((class color) (min-colors 88) (background light)) (:foreground "Orchid"))
1750     (((class color) (min-colors 88) (background dark)) (:foreground "LightSteelBlue"))
1751     (((class color) (min-colors 16) (background light)) (:foreground "Orchid"))
1752     (((class color) (min-colors 16) (background dark)) (:foreground "LightSteelBlue"))
1753     (((class color) (min-colors 8)) (:foreground "blue" :weight bold))
1754     (t (:weight bold)))
1755   "Font Lock mode face used to highlight builtins."
1756   :group 'font-lock-highlighting-faces)
1757
1758 (defface font-lock-function-name-face
1759   '((((class color) (min-colors 88) (background light)) (:foreground "Blue1"))
1760     (((class color) (min-colors 88) (background dark)) (:foreground "LightSkyBlue"))
1761     (((class color) (min-colors 16) (background light)) (:foreground "Blue"))
1762     (((class color) (min-colors 16) (background dark)) (:foreground "LightSkyBlue"))
1763     (((class color) (min-colors 8)) (:foreground "blue" :weight bold))
1764     (t (:inverse-video t :weight bold)))
1765   "Font Lock mode face used to highlight function names."
1766   :group 'font-lock-highlighting-faces)
1767
1768 (defface font-lock-variable-name-face
1769   '((((class grayscale) (background light))
1770      (:foreground "Gray90" :weight bold :slant italic))
1771     (((class grayscale) (background dark))
1772      (:foreground "DimGray" :weight bold :slant italic))
1773     (((class color) (min-colors 88) (background light)) (:foreground "DarkGoldenrod"))
1774     (((class color) (min-colors 88) (background dark)) (:foreground "LightGoldenrod"))
1775     (((class color) (min-colors 16) (background light)) (:foreground "DarkGoldenrod"))
1776     (((class color) (min-colors 16) (background dark)) (:foreground "LightGoldenrod"))
1777     (((class color) (min-colors 8)) (:foreground "yellow" :weight light))
1778     (t (:weight bold :slant italic)))
1779   "Font Lock mode face used to highlight variable names."
1780   :group 'font-lock-highlighting-faces)
1781
1782 (defface font-lock-type-face
1783   '((((class grayscale) (background light)) (:foreground "Gray90" :weight bold))
1784     (((class grayscale) (background dark)) (:foreground "DimGray" :weight bold))
1785     (((class color) (min-colors 88) (background light)) (:foreground "ForestGreen"))
1786     (((class color) (min-colors 88) (background dark)) (:foreground "PaleGreen"))
1787     (((class color) (min-colors 16) (background light)) (:foreground "ForestGreen"))
1788     (((class color) (min-colors 16) (background dark)) (:foreground "PaleGreen"))
1789     (((class color) (min-colors 8)) (:foreground "green"))
1790     (t (:weight bold :underline t)))
1791   "Font Lock mode face used to highlight type and classes."
1792   :group 'font-lock-highlighting-faces)
1793
1794 (defface font-lock-constant-face
1795   '((((class grayscale) (background light))
1796      (:foreground "LightGray" :weight bold :underline t))
1797     (((class grayscale) (background dark))
1798      (:foreground "Gray50" :weight bold :underline t))
1799     (((class color) (min-colors 88) (background light)) (:foreground "CadetBlue"))
1800     (((class color) (min-colors 88) (background dark)) (:foreground "Aquamarine"))
1801     (((class color) (min-colors 16) (background light)) (:foreground "CadetBlue"))
1802     (((class color) (min-colors 16) (background dark)) (:foreground "Aquamarine"))
1803     (((class color) (min-colors 8)) (:foreground "magenta"))
1804     (t (:weight bold :underline t)))
1805   "Font Lock mode face used to highlight constants and labels."
1806   :group 'font-lock-highlighting-faces)
1807
1808 (defface font-lock-warning-face
1809   '((((class color) (min-colors 88) (background light)) (:foreground "Red1" :weight bold))
1810     (((class color) (min-colors 88) (background dark)) (:foreground "Pink" :weight bold))
1811     (((class color) (min-colors 16) (background light)) (:foreground "Red" :weight bold))
1812     (((class color) (min-colors 16) (background dark)) (:foreground "Pink" :weight bold))
1813     (((class color) (min-colors 8)) (:foreground "red"))
1814     (t (:inverse-video t :weight bold)))
1815   "Font Lock mode face used to highlight warnings."
1816   :group 'font-lock-highlighting-faces)
1817
1818 (defface font-lock-negation-char-face
1819   '((t nil))
1820   "Font Lock mode face used to highlight easy to overlook negation."
1821   :group 'font-lock-highlighting-faces)
1822
1823 (defface font-lock-preprocessor-face
1824   '((t :inherit font-lock-builtin-face))
1825   "Font Lock mode face used to highlight preprocessor directives."
1826   :group 'font-lock-highlighting-faces)
1827
1828 (defface font-lock-regexp-grouping-backslash
1829   '((t :inherit bold))
1830   "Font Lock mode face for backslashes in Lisp regexp grouping constructs."
1831   :group 'font-lock-highlighting-faces)
1832
1833 (defface font-lock-regexp-grouping-construct
1834   '((t :inherit bold))
1835   "Font Lock mode face used to highlight grouping constructs in Lisp regexps."
1836   :group 'font-lock-highlighting-faces)
1837
1838 ;;; End of Colour etc. support.
1839 \f
1840 ;;; Menu support.
1841
1842 ;; This section of code is commented out because Emacs does not have real menu
1843 ;; buttons.  (We can mimic them by putting "( ) " or "(X) " at the beginning of
1844 ;; the menu entry text, but with Xt it looks both ugly and embarrassingly
1845 ;; amateur.)  If/When Emacs gets real menus buttons, put in menu-bar.el after
1846 ;; the entry for "Text Properties" something like:
1847 ;;
1848 ;; (define-key menu-bar-edit-menu [font-lock]
1849 ;;   (cons "Syntax Highlighting" font-lock-menu))
1850 ;;
1851 ;; and remove a single ";" from the beginning of each line in the rest of this
1852 ;; section.  Probably the mechanism for telling the menu code what are menu
1853 ;; buttons and when they are on or off needs tweaking.  I have assumed that the
1854 ;; mechanism is via `menu-toggle' and `menu-selected' symbol properties.  sm.
1855
1856 ;;;;;###autoload
1857 ;;(progn
1858 ;;  ;; Make the Font Lock menu.
1859 ;;  (defvar font-lock-menu (make-sparse-keymap "Syntax Highlighting"))
1860 ;;  ;; Add the menu items in reverse order.
1861 ;;  (define-key font-lock-menu [fontify-less]
1862 ;;    '("Less In Current Buffer" . font-lock-fontify-less))
1863 ;;  (define-key font-lock-menu [fontify-more]
1864 ;;    '("More In Current Buffer" . font-lock-fontify-more))
1865 ;;  (define-key font-lock-menu [font-lock-sep]
1866 ;;    '("--"))
1867 ;;  (define-key font-lock-menu [font-lock-mode]
1868 ;;    '("In Current Buffer" . font-lock-mode))
1869 ;;  (define-key font-lock-menu [global-font-lock-mode]
1870 ;;    '("In All Buffers" . global-font-lock-mode)))
1871 ;;
1872 ;;;;;###autoload
1873 ;;(progn
1874 ;;  ;; We put the appropriate `menu-enable' etc. symbol property values on when
1875 ;;  ;; font-lock.el is loaded, so we don't need to autoload the three variables.
1876 ;;  (put 'global-font-lock-mode 'menu-toggle t)
1877 ;;  (put 'font-lock-mode 'menu-toggle t)
1878 ;;  (put 'font-lock-fontify-more 'menu-enable '(identity))
1879 ;;  (put 'font-lock-fontify-less 'menu-enable '(identity)))
1880 ;;
1881 ;; ;; Put the appropriate symbol property values on now.  See above.
1882 ;;(put 'global-font-lock-mode 'menu-selected 'global-font-lock-mode)
1883 ;;(put 'font-lock-mode 'menu-selected 'font-lock-mode)
1884 ;;(put 'font-lock-fontify-more 'menu-enable '(nth 2 font-lock-fontify-level))
1885 ;;(put 'font-lock-fontify-less 'menu-enable '(nth 1 font-lock-fontify-level))
1886 ;;
1887 ;;(defvar font-lock-fontify-level nil)  ; For less/more fontification.
1888 ;;
1889 ;;(defun font-lock-fontify-level (level)
1890 ;;  (let ((font-lock-maximum-decoration level))
1891 ;;    (when font-lock-mode
1892 ;;      (font-lock-mode))
1893 ;;    (font-lock-mode)
1894 ;;    (when font-lock-verbose
1895 ;;      (message "Fontifying %s... level %d" (buffer-name) level))))
1896 ;;
1897 ;;(defun font-lock-fontify-less ()
1898 ;;  "Fontify the current buffer with less decoration.
1899 ;;See `font-lock-maximum-decoration'."
1900 ;;  (interactive)
1901 ;;  ;; Check in case we get called interactively.
1902 ;;  (if (nth 1 font-lock-fontify-level)
1903 ;;      (font-lock-fontify-level (1- (car font-lock-fontify-level)))
1904 ;;    (error "No less decoration")))
1905 ;;
1906 ;;(defun font-lock-fontify-more ()
1907 ;;  "Fontify the current buffer with more decoration.
1908 ;;See `font-lock-maximum-decoration'."
1909 ;;  (interactive)
1910 ;;  ;; Check in case we get called interactively.
1911 ;;  (if (nth 2 font-lock-fontify-level)
1912 ;;      (font-lock-fontify-level (1+ (car font-lock-fontify-level)))
1913 ;;    (error "No more decoration")))
1914 ;;
1915 ;; ;; This should be called by `font-lock-set-defaults'.
1916 ;;(defun font-lock-set-menu ()
1917 ;;  ;; Activate less/more fontification entries if there are multiple levels for
1918 ;;  ;; the current buffer.  Sets `font-lock-fontify-level' to be of the form
1919 ;;  ;; (CURRENT-LEVEL IS-LOWER-LEVEL-P IS-HIGHER-LEVEL-P) for menu activation.
1920 ;;  (let ((keywords (or (nth 0 font-lock-defaults)
1921 ;;                    (nth 1 (assq major-mode font-lock-defaults-alist))))
1922 ;;      (level (font-lock-value-in-major-mode font-lock-maximum-decoration)))
1923 ;;    (make-local-variable 'font-lock-fontify-level)
1924 ;;    (if (or (symbolp keywords) (= (length keywords) 1))
1925 ;;      (font-lock-unset-menu)
1926 ;;      (cond ((eq level t)
1927 ;;           (setq level (1- (length keywords))))
1928 ;;          ((or (null level) (zerop level))
1929 ;;           ;; The default level is usually, but not necessarily, level 1.
1930 ;;           (setq level (- (length keywords)
1931 ;;                          (length (member (eval (car keywords))
1932 ;;                                          (mapcar 'eval (cdr keywords))))))))
1933 ;;      (setq font-lock-fontify-level (list level (> level 1)
1934 ;;                                        (< level (1- (length keywords))))))))
1935 ;;
1936 ;; ;; This should be called by `font-lock-unset-defaults'.
1937 ;;(defun font-lock-unset-menu ()
1938 ;;  ;; Deactivate less/more fontification entries.
1939 ;;  (setq font-lock-fontify-level nil))
1940
1941 ;;; End of Menu support.
1942 \f
1943 ;;; Various regexp information shared by several modes.
1944 ;; ;; Information specific to a single mode should go in its load library.
1945
1946 ;; Font Lock support for C, C++, Objective-C and Java modes is now in
1947 ;; cc-fonts.el (and required by cc-mode.el).  However, the below function
1948 ;; should stay in font-lock.el, since it is used by other libraries.  sm.
1949
1950 (defun font-lock-match-c-style-declaration-item-and-skip-to-next (limit)
1951   "Match, and move over, any declaration/definition item after point.
1952 Matches after point, but ignores leading whitespace and `*' characters.
1953 Does not move further than LIMIT.
1954
1955 The expected syntax of a declaration/definition item is `word' (preceded by
1956 optional whitespace and `*' characters and proceeded by optional whitespace)
1957 optionally followed by a `('.  Everything following the item (but belonging to
1958 it) is expected to be skip-able by `scan-sexps', and items are expected to be
1959 separated with a `,' and to be terminated with a `;'.
1960
1961 Thus the regexp matches after point:    word (
1962                                         ^^^^ ^
1963 Where the match subexpressions are:       1  2
1964
1965 The item is delimited by (match-beginning 1) and (match-end 1).
1966 If (match-beginning 2) is non-nil, the item is followed by a `('.
1967
1968 This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
1969   (when (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?")
1970     (when (and (match-end 2) (> (- (match-end 2) (match-beginning 2)) 1))
1971       ;; If `word' is followed by a double open-paren, it's probably
1972       ;; a macro used for "int myfun P_ ((int arg1))".  Let's go back one
1973       ;; word to try and match `myfun' rather than `P_'.
1974       (let ((pos (point)))
1975         (skip-chars-backward " \t\n")
1976         (skip-syntax-backward "w")
1977         (unless (looking-at "\\(\\sw+\\)[ \t\n]*\\sw+[ \t\n]*\\(((?\\)?")
1978           ;; Looks like it was something else, so go back to where we
1979           ;; were and reset the match data by rematching.
1980           (goto-char pos)
1981           (looking-at "[ \n\t*]*\\(\\sw+\\)[ \t\n]*\\(((?\\)?"))))
1982     (save-match-data
1983       (condition-case nil
1984           (save-restriction
1985             ;; Restrict to the LIMIT.
1986             (narrow-to-region (point-min) limit)
1987             (goto-char (match-end 1))
1988             ;; Move over any item value, etc., to the next item.
1989             (while (not (looking-at "[ \t\n]*\\(\\(,\\)\\|;\\|\\'\\)"))
1990               (goto-char (or (scan-sexps (point) 1) (point-max))))
1991             (if (match-end 2)
1992                 (goto-char (match-end 2))))
1993         (error t)))))
1994 \f
1995 ;; Lisp.
1996
1997 (defconst lisp-font-lock-keywords-1
1998   (eval-when-compile
1999     `(;; Definitions.
2000       (,(concat "(\\(def\\("
2001                 ;; Function declarations.
2002                 "\\(advice\\|varalias\\|alias\\|generic\\|macro\\*?\\|method\\|"
2003                 "setf\\|subst\\*?\\|un\\*?\\|"
2004                 "ine-\\(condition\\|\\(?:derived\\|minor\\|generic\\)-mode\\|"
2005                 "method-combination\\|setf-expander\\|skeleton\\|widget\\|"
2006                 "function\\|\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|"
2007                 ;; Variable declarations.
2008                 "\\(const\\(ant\\)?\\|custom\\|face\\|parameter\\|var\\)\\|"
2009                 ;; Structure declarations.
2010                 "\\(class\\|group\\|theme\\|package\\|struct\\|type\\)"
2011                 "\\)\\)\\>"
2012                 ;; Any whitespace and defined object.
2013                 "[ \t'\(]*"
2014                 "\\(setf[ \t]+\\sw+)\\|\\sw+\\)?")
2015        (1 font-lock-keyword-face)
2016        (9 (cond ((match-beginning 3) font-lock-function-name-face)
2017                 ((match-beginning 6) font-lock-variable-name-face)
2018                 (t font-lock-type-face))
2019           nil t))
2020       ;; Emacs Lisp autoload cookies.
2021       ("^;;;###\\(autoload\\)" 1 font-lock-warning-face prepend)
2022       ;; Regexp negated char group.
2023       ("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend)))
2024   "Subdued level highlighting for Lisp modes.")
2025
2026 (defconst lisp-font-lock-keywords-2
2027   (append lisp-font-lock-keywords-1
2028    (eval-when-compile
2029      `(;; Control structures.  Emacs Lisp forms.
2030        (,(concat
2031           "(" (regexp-opt
2032                '("cond" "if" "while" "while-no-input" "let" "let*"
2033                  "prog" "progn" "progv" "prog1" "prog2" "prog*"
2034                  "inline" "lambda" "save-restriction" "save-excursion"
2035                  "save-window-excursion" "save-selected-window"
2036                  "save-match-data" "save-current-buffer" "unwind-protect"
2037                  "condition-case" "track-mouse"
2038                  "eval-after-load" "eval-and-compile" "eval-when-compile"
2039                  "eval-when"
2040                  "with-category-table"
2041                  "with-current-buffer" "with-electric-help"
2042                  "with-local-quit" "with-no-warnings"
2043                  "with-output-to-string" "with-output-to-temp-buffer"
2044                  "with-selected-window" "with-syntax-table"
2045                  "with-temp-buffer" "with-temp-file" "with-temp-message"
2046                  "with-timeout" "with-timeout-handler") t)
2047           "\\>")
2048           .  1)
2049        ;; Control structures.  Common Lisp forms.
2050        (,(concat
2051           "(" (regexp-opt
2052                '("when" "unless" "case" "ecase" "typecase" "etypecase"
2053                  "ccase" "ctypecase" "handler-case" "handler-bind"
2054                  "restart-bind" "restart-case" "in-package"
2055                  "break" "ignore-errors"
2056                  "loop" "do" "do*" "dotimes" "dolist" "the" "locally"
2057                  "proclaim" "declaim" "declare" "symbol-macrolet"
2058                  "lexical-let" "lexical-let*" "flet" "labels" "compiler-let"
2059                  "destructuring-bind" "macrolet" "tagbody" "block" "go"
2060                  "multiple-value-bind" "multiple-value-prog1"
2061                  "return" "return-from"
2062                  "with-accessors" "with-compilation-unit"
2063                  "with-condition-restarts" "with-hash-table-iterator"
2064                  "with-input-from-string" "with-open-file"
2065                  "with-open-stream" "with-output-to-string"
2066                  "with-package-iterator" "with-simple-restart"
2067                  "with-slots" "with-standard-io-syntax") t)
2068           "\\>")
2069           . 1)
2070        ;; Exit/Feature symbols as constants.
2071        (,(concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\>"
2072                  "[ \t']*\\(\\sw+\\)?")
2073         (1 font-lock-keyword-face)
2074         (2 font-lock-constant-face nil t))
2075        ;; Erroneous structures.
2076        ("(\\(abort\\|assert\\|warn\\|check-type\\|cerror\\|error\\|signal\\)\\>" 1 font-lock-warning-face)
2077        ;; Words inside \\[] tend to be for `substitute-command-keys'.
2078        ("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-constant-face prepend)
2079        ;; Words inside `' tend to be symbol names.
2080        ("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend)
2081        ;; Constant values.
2082        ("\\<:\\sw+\\>" 0 font-lock-builtin-face)
2083        ;; ELisp and CLisp `&' keywords as types.
2084        ("\\&\\sw+\\>" . font-lock-type-face)
2085        ;; ELisp regexp grouping constructs
2086        ((lambda (bound)
2087           (catch 'found
2088             ;; The following loop is needed to continue searching after matches
2089             ;; that do not occur in strings.  The associated regexp matches one
2090             ;; of `\\\\' `\\(' `\\(?:' `\\|' `\\)'.  `\\\\' has been included to
2091             ;; avoid highlighting, for example, `\\(' in `\\\\('.
2092             (while (re-search-forward "\\(\\\\\\\\\\)\\(?:\\(\\\\\\\\\\)\\|\\((\\(?:\\?:\\)?\\|[|)]\\)\\)" bound t)
2093               (unless (match-beginning 2)
2094                 (let ((face (get-text-property (1- (point)) 'face)))
2095                   (when (or (and (listp face)
2096                                  (memq 'font-lock-string-face face))
2097                             (eq 'font-lock-string-face face))
2098                     (throw 'found t)))))))
2099         (1 'font-lock-regexp-grouping-backslash prepend)
2100         (3 'font-lock-regexp-grouping-construct prepend))
2101 ;;;  This is too general -- rms.
2102 ;;;  A user complained that he has functions whose names start with `do'
2103 ;;;  and that they get the wrong color.
2104 ;;;      ;; CL `with-' and `do-' constructs
2105 ;;;      ("(\\(\\(do-\\|with-\\)\\(\\s_\\|\\w\\)*\\)" 1 font-lock-keyword-face)
2106       )))
2107   "Gaudy level highlighting for Lisp modes.")
2108
2109 (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
2110   "Default expressions to highlight in Lisp modes.")
2111 \f
2112 (provide 'font-lock)
2113
2114 ;; arch-tag: 682327e4-64d8-4057-b20b-1fbb9f1fc54c
2115 ;;; font-lock.el ends here