1 ;;; font-lock.el --- decorating source files with fonts/colors based on syntax
3 ;; Copyright (C) 1992-1995, 1997 Free Software Foundation, Inc.
4 ;; Copyright (C) 1995 Amdahl Corporation.
5 ;; Copyright (C) 1996 Ben Wing.
7 ;; Author: Jamie Zawinski <jwz@jwz.org>, for the LISPM Preservation Society.
8 ;; Minimally merged with FSF 19.34 by Barry Warsaw <bwarsaw@python.org>
9 ;; Then (partially) synched with FSF 19.30, leading to:
11 ;; Next Author: Simon Marshall <simon@gnu.ai.mit.edu>
12 ;; Latest XEmacs Author: Ben Wing
13 ;; Maintainer: XEmacs Development Team
14 ;; Keywords: languages, faces
16 ;; This file is part of XEmacs.
18 ;; XEmacs is free software; you can redistribute it and/or modify it
19 ;; under the terms of the GNU General Public License as published by
20 ;; the Free Software Foundation; either version 2, or (at your option)
23 ;; XEmacs is distributed in the hope that it will be useful, but
24 ;; WITHOUT ANY WARRANTY; without even the implied warranty of
25 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26 ;; General Public License for more details.
28 ;; You should have received a copy of the GNU General Public License
29 ;; along with XEmacs; see the file COPYING. If not, write to the
30 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
31 ;; Boston, MA 02111-1307, USA.
33 ;;; Synched up with: FSF 19.30 except for the code to initialize the faces.
37 ;; Font-lock-mode is a minor mode that causes your comments to be
38 ;; displayed in one face, strings in another, reserved words in another,
39 ;; documentation strings in another, and so on.
41 ;; Comments will be displayed in `font-lock-comment-face'.
42 ;; Strings will be displayed in `font-lock-string-face'.
43 ;; Doc strings will be displayed in `font-lock-doc-string-face'.
44 ;; Function and variable names (in their defining forms) will be
45 ;; displayed in `font-lock-function-name-face'.
46 ;; Reserved words will be displayed in `font-lock-keyword-face'.
48 ;; Don't let the name fool you: you can highlight things using different
49 ;; colors or background stipples instead of fonts, though that is not the
50 ;; default. See the variables `font-lock-use-colors' and
51 ;; `font-lock-use-fonts' for broad control over this, or see the
52 ;; documentation on faces and how to change their attributes for
53 ;; fine-grained control.
55 ;; To make the text you type be fontified, use M-x font-lock-mode. When
56 ;; this minor mode is on, the fonts of the current line will be updated
57 ;; with every insertion or deletion.
59 ;; By default, font-lock will automatically put newly loaded files
60 ;; into font-lock-mode if it knows about the file's mode. See the
61 ;; variables `font-lock-auto-fontify', `font-lock-mode-enable-list',
62 ;; and `font-lock-mode-disable-list' for control over this.
64 ;; The `font-lock-keywords' variable defines other patterns to highlight.
65 ;; The default font-lock-mode-hook sets it to the value of the variables
66 ;; lisp-font-lock-keywords, c-font-lock-keywords, etc, as appropriate.
67 ;; The easiest way to change the highlighting patterns is to change the
68 ;; values of c-font-lock-keywords and related variables. See the doc
69 ;; string of the variable `font-lock-keywords' for the appropriate syntax.
71 ;; The default value for `lisp-font-lock-keywords' is the value of the variable
72 ;; `lisp-font-lock-keywords-1'. You may like `lisp-font-lock-keywords-2'
73 ;; better; it highlights many more words, but is slower and makes your buffers
74 ;; be very visually noisy.
76 ;; The same is true of `c-font-lock-keywords-1' and `c-font-lock-keywords-2';
77 ;; the former is subdued, the latter is loud.
79 ;; You can make font-lock default to the gaudier variety of keyword
80 ;; highlighting by setting the variable `font-lock-maximum-decoration'
81 ;; before loading font-lock, or by calling the functions
82 ;; `font-lock-use-default-maximal-decoration' or
83 ;; `font-lock-use-default-minimal-decoration'.
85 ;; On a Sparc10, the initial fontification takes about 6 seconds for a typical
86 ;; 140k file of C code, using the default configuration. The actual speed
87 ;; depends heavily on the type of code in the file, and how many non-syntactic
88 ;; patterns match; for example, Xlib.h takes 23 seconds for 101k, because many
89 ;; patterns match in it. You can speed this up substantially by removing some
90 ;; of the patterns that are highlighted by default. Fontifying lisp code is
91 ;; significantly faster, because lisp has a more regular syntax than C, so the
92 ;; regular expressions don't have to be as complicated.
94 ;; It's called font-lock-mode here because on the Lispms it was called
95 ;; "Electric Font Lock Mode." It was called that because there was an older
96 ;; mode called "Electric Caps Lock Mode" which had the function of causing all
97 ;; of your source code to be in upper case except for strings and comments,
98 ;; without you having to blip the caps lock key by hand all the time (thus the
99 ;; "electric", as in `electric-c-brace'.)
101 ;; See also the related packages `fast-lock' and `lazy-lock'. Both
102 ;; attempt to speed up the initial fontification. `fast-lock' saves
103 ;; the fontification info when you exit Emacs and reloads it next time
104 ;; you load the file, so that the file doesn't have to be fontified
105 ;; again. `lazy-lock' does "lazy" fontification -- i.e. it only
106 ;; fontifies the text as it becomes visible rather than fontifying
107 ;; the whole file when it's first loaded in.
109 ;; Further comments from the FSF:
111 ;; Nasty regexps of the form "bar\\(\\|lo\\)\\|f\\(oo\\|u\\(\\|bar\\)\\)\\|lo"
112 ;; are made thusly: (regexp-opt '("foo" "fu" "fubar" "bar" "barlo" "lo")) for
115 ;; What is fontification for? You might say, "It's to make my code look nice."
116 ;; I think it should be for adding information in the form of cues. These cues
117 ;; should provide you with enough information to both (a) distinguish between
118 ;; different items, and (b) identify the item meanings, without having to read
119 ;; the items and think about it. Therefore, fontification allows you to think
120 ;; less about, say, the structure of code, and more about, say, why the code
121 ;; doesn't work. Or maybe it allows you to think less and drift off to sleep.
123 ;; So, here are my opinions/advice/guidelines:
125 ;; - Use the same face for the same conceptual object, across all modes.
126 ;; i.e., (b) above, all modes that have items that can be thought of as, say,
127 ;; keywords, should be highlighted with the same face, etc.
128 ;; - Keep the faces distinct from each other as far as possible.
130 ;; - Make the face attributes fit the concept as far as possible.
131 ;; i.e., function names might be a bold color such as blue, comments might
132 ;; be a bright color such as red, character strings might be brown, because,
133 ;; err, strings are brown (that was not the reason, please believe me).
134 ;; - Don't use a non-nil OVERRIDE unless you have a good reason.
135 ;; Only use OVERRIDE for special things that are easy to define, such as the
136 ;; way `...' quotes are treated in strings and comments in Emacs Lisp mode.
137 ;; Don't use it to, say, highlight keywords in commented out code or strings.
143 (require 'fontl-hooks)
145 ;;;;;;;;;;;;;;;;;;;;;; user variables ;;;;;;;;;;;;;;;;;;;;;;
147 (defgroup font-lock nil
148 "Decorate source files with fonts/colors based on syntax.
149 Font-lock-mode is a minor mode that causes your comments to be
150 displayed in one face, strings in another, reserved words in another,
151 documentation strings in another, and so on.
153 Comments will be displayed in `font-lock-comment-face'.
154 Strings will be displayed in `font-lock-string-face'.
155 Doc strings will be displayed in `font-lock-doc-string-face'.
156 Function and variable names (in their defining forms) will be displayed
157 in `font-lock-function-name-face'.
158 Reserved words will be displayed in `font-lock-keyword-face'.
159 Preprocessor conditionals will be displayed in `font-lock-preprocessor-face'."
162 (defgroup font-lock-faces nil
163 "Faces used by the font-lock package."
168 (defcustom font-lock-verbose t
169 "*If non-nil, means show status messages when fontifying.
170 See also `font-lock-message-threshold'."
174 (defcustom font-lock-message-threshold 6000
175 "*Minimum size of region being fontified for status messages to appear.
177 The size is measured in characters. This affects `font-lock-fontify-region'
178 but not `font-lock-fontify-buffer'. (In other words, when you first visit
179 a file and it gets fontified, you will see status messages no matter what
180 size the file is. However, if you do something else like paste a
181 chunk of text or revert a buffer, you will see status messages only if the
182 changed region is large enough.)
184 Note that setting `font-lock-verbose' to nil disables the status
190 (defcustom font-lock-auto-fontify t
191 "*Whether font-lock should automatically fontify files as they're loaded.
192 This will only happen if font-lock has fontifying keywords for the major
193 mode of the file. You can get finer-grained control over auto-fontification
194 by using this variable in combination with `font-lock-mode-enable-list' or
195 `font-lock-mode-disable-list'."
200 (defcustom font-lock-mode-enable-list nil
201 "*List of modes to auto-fontify, if `font-lock-auto-fontify' is nil."
202 :type '(repeat (symbol :tag "Mode"))
206 (defcustom font-lock-mode-disable-list nil
207 "*List of modes not to auto-fontify, if `font-lock-auto-fontify' is t."
208 :type '(repeat (symbol :tag "Mode"))
212 (defcustom font-lock-use-colors '(color)
213 "*Specification for when Font Lock will set up color defaults.
214 Normally this should be '(color), meaning that Font Lock will set up
215 color defaults that are only used on color displays. Set this to nil
216 if you don't want Font Lock to set up color defaults at all. This
219 -- a list of valid tags, meaning that the color defaults will be used
220 when all of the tags apply. (e.g. '(color x))
221 -- a list whose first element is 'or and whose remaining elements are
222 lists of valid tags, meaning that the defaults will be used when
223 any of the tag lists apply.
224 -- nil, meaning that the defaults should not be set up at all.
226 \(If you specify face values in your init file, they will override any
227 that Font Lock specifies, regardless of whether you specify the face
228 values before or after loading Font Lock.)
230 See also `font-lock-use-fonts'. If you want more control over the faces
231 used for fontification, see the documentation of `font-lock-mode' for
238 (defcustom font-lock-use-fonts '(or (mono) (grayscale))
239 "*Specification for when Font Lock will set up non-color defaults.
241 Normally this should be '(or (mono) (grayscale)), meaning that Font
242 Lock will set up non-color defaults that are only used on either mono
243 or grayscale displays. Set this to nil if you don't want Font Lock to
244 set up non-color defaults at all. This should be one of
246 -- a list of valid tags, meaning that the non-color defaults will be used
247 when all of the tags apply. (e.g. '(grayscale x))
248 -- a list whose first element is 'or and whose remaining elements are
249 lists of valid tags, meaning that the defaults will be used when
250 any of the tag lists apply.
251 -- nil, meaning that the defaults should not be set up at all.
253 \(If you specify face values in your init file, they will override any
254 that Font Lock specifies, regardless of whether you specify the face
255 values before or after loading Font Lock.)
257 See also `font-lock-use-colors'. If you want more control over the faces
258 used for fontification, see the documentation of `font-lock-mode' for
264 (defcustom font-lock-maximum-decoration t
265 "*If non-nil, the maximum decoration level for fontifying.
266 If nil, use the minimum decoration (equivalent to level 0).
267 If t, use the maximum decoration available.
268 If a number, use that level of decoration (or if not available the maximum).
269 If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),
270 where MAJOR-MODE is a symbol or t (meaning the default). For example:
271 ((c++-mode . 2) (c-mode . t) (t . 1))
272 means use level 2 decoration for buffers in `c++-mode', the maximum decoration
273 available for buffers in `c-mode', and level 1 decoration otherwise."
274 :type '(choice (const :tag "default" nil)
275 (const :tag "maximum" t)
276 (integer :tag "level" 1)
277 (repeat :menu-tag "mode specific" :tag "mode specific"
279 (cons :tag "Instance"
282 (symbol :tag "name"))
283 (radio :tag "Decoration"
284 (const :tag "default" nil)
285 (const :tag "maximum" t)
286 (integer :tag "level" 1)))))
290 (define-obsolete-variable-alias 'font-lock-use-maximal-decoration
291 'font-lock-maximum-decoration)
294 (defcustom font-lock-maximum-size (* 250 1024)
295 "*If non-nil, the maximum size for buffers for fontifying.
296 Only buffers less than this can be fontified when Font Lock mode is turned on.
297 If nil, means size is irrelevant.
298 If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
299 where MAJOR-MODE is a symbol or t (meaning the default). For example:
300 ((c++-mode . 256000) (c-mode . 256000) (rmail-mode . 1048576))
301 means that the maximum size is 250K for buffers in `c++-mode' or `c-mode', one
302 megabyte for buffers in `rmail-mode', and size is irrelevant otherwise."
303 :type '(choice (const :tag "none" nil)
304 (integer :tag "size")
305 (repeat :menu-tag "mode specific" :tag "mode specific"
307 (cons :tag "Instance"
310 (symbol :tag "name"))
312 (const :tag "none" nil)
313 (integer :tag "size")))))
317 ;; Fontification variables:
320 (defvar font-lock-keywords nil
321 "A list of the keywords to highlight.
322 Each element should be of the form:
327 (MATCHER . HIGHLIGHT)
328 (MATCHER HIGHLIGHT ...)
331 where HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED.
333 FORM is an expression, whose value should be a keyword element,
334 evaluated when the keyword is (first) used in a buffer. This feature
335 can be used to provide a keyword that can only be generated when Font
336 Lock mode is actually turned on.
338 For highlighting single items, typically only MATCH-HIGHLIGHT is required.
339 However, if an item or (typically) items is to be highlighted following the
340 instance of another item (the anchor) then MATCH-ANCHORED may be required.
342 MATCH-HIGHLIGHT should be of the form:
344 (MATCH FACENAME OVERRIDE LAXMATCH)
346 Where MATCHER can be either the regexp to search for, a variable
347 containing the regexp to search for, or the function to call to make
348 the search (called with one argument, the limit of the search). MATCH
349 is the subexpression of MATCHER to be highlighted. FACENAME is either
350 a symbol naming a face, or an expression whose value is the face name
351 to use. If you want FACENAME to be a symbol that evaluates to a face,
352 use a form like \"(progn sym)\".
354 OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing fontification may
355 be overwritten. If `keep', only parts not already fontified are highlighted.
356 If `prepend' or `append', existing fontification is merged with the new, in
357 which the new or existing fontification, respectively, takes precedence.
358 If LAXMATCH is non-nil, no error is signalled if there is no MATCH in MATCHER.
360 For example, an element of the form highlights (if not already highlighted):
362 \"\\\\\\=<foo\\\\\\=>\" Discrete occurrences of \"foo\" in the value of the
363 variable `font-lock-keyword-face'.
364 (\"fu\\\\(bar\\\\)\" . 1) Substring \"bar\" within all occurrences of \"fubar\" in
365 the value of `font-lock-keyword-face'.
366 (\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of `fubar-face'.
367 (\"foo\\\\|bar\" 0 foo-bar-face t)
368 Occurrences of either \"foo\" or \"bar\" in the value
369 of `foo-bar-face', even if already highlighted.
371 MATCH-ANCHORED should be of the form:
373 (MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...)
375 Where MATCHER is as for MATCH-HIGHLIGHT with one exception; see below.
376 PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after
377 the last, instance MATCH-ANCHORED's MATCHER is used. Therefore they can be
378 used to initialize before, and cleanup after, MATCHER is used. Typically,
379 PRE-MATCH-FORM is used to move to some position relative to the original
380 MATCHER, before starting with MATCH-ANCHORED's MATCHER. POST-MATCH-FORM might
381 be used to move, before resuming with MATCH-ANCHORED's parent's MATCHER.
383 For example, an element of the form highlights (if not already highlighted):
385 (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
387 Discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent
388 discrete occurrences of \"item\" (on the same line) in the value of `item-face'.
389 (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore \"item\" is
390 initially searched for starting from the end of the match of \"anchor\", and
391 searching for subsequent instance of \"anchor\" resumes from where searching
392 for \"item\" concluded.)
394 The above-mentioned exception is as follows. The limit of the MATCHER search
395 defaults to the end of the line after PRE-MATCH-FORM is evaluated.
396 However, if PRE-MATCH-FORM returns a position greater than the position after
397 PRE-MATCH-FORM is evaluated, that position is used as the limit of the search.
398 It is generally a bad idea to return a position greater than the end of the
399 line, i.e., cause the MATCHER search to span lines.
401 Note that the MATCH-ANCHORED feature is experimental; in the future, we may
402 replace it with other ways of providing this functionality.
404 These regular expressions should not match text which spans lines. While
405 \\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating
406 when you edit the buffer does not, since it considers text one line at a time.
408 Be very careful composing regexps for this list;
409 the wrong pattern can dramatically slow things down!")
411 (make-variable-buffer-local 'font-lock-keywords)
413 (defvar font-lock-defaults nil
414 "The defaults font Font Lock mode for the current buffer.
415 Normally, do not set this directly. If you are writing a major mode,
416 put a property of `font-lock-defaults' on the major-mode symbol with
421 \(KEYWORDS KEYWORDS-ONLY CASE-FOLD SYNTAX-ALIST SYNTAX-BEGIN)
423 KEYWORDS may be a symbol (a variable or function whose value is the keywords
424 to use for fontification) or a list of symbols. If KEYWORDS-ONLY is non-nil,
425 syntactic fontification (strings and comments) is not performed. If CASE-FOLD
426 is non-nil, the case of the keywords is ignored when fontifying. If
427 SYNTAX-ALIST is non-nil, it should be a list of cons pairs of the form (CHAR
428 . STRING) used to set the local Font Lock syntax table, for keyword and
429 syntactic fontification (see `modify-syntax-entry').
431 If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move
432 backwards outside any enclosing syntactic block, for syntactic fontification.
433 Typical values are `beginning-of-line' (i.e., the start of the line is known to
434 be outside a syntactic block), or `beginning-of-defun' for programming modes or
435 `backward-paragraph' for textual modes (i.e., the mode-dependent function is
436 known to move outside a syntactic block). If nil, the beginning of the buffer
437 is used as a position outside of a syntactic block, in the worst case.
439 These item elements are used by Font Lock mode to set the variables
440 `font-lock-keywords', `font-lock-keywords-only',
441 `font-lock-keywords-case-fold-search', `font-lock-syntax-table' and
442 `font-lock-beginning-of-syntax-function', respectively.
444 Alternatively, if the value is a symbol, it should name a major mode,
445 and the defaults for that mode will apply.")
446 (make-variable-buffer-local 'font-lock-defaults)
448 ;; FSF uses `font-lock-defaults-alist' and expects the major mode to
449 ;; set a value for `font-lock-defaults', but I don't like either of
450 ;; these -- requiring the mode to set `font-lock-defaults' makes it
451 ;; impossible to have defaults for a minor mode, and using an alist is
452 ;; generally a bad idea for information that really should be
453 ;; decentralized. (Who knows what strange modes might want
456 (defvar font-lock-keywords-only nil
457 "Non-nil means Font Lock should not do syntactic fontification.
458 This is normally set via `font-lock-defaults'.
460 This should be nil for all ``language'' modes, but other modes, like
461 dired, do not have anything useful in the syntax tables (no comment
462 or string delimiters, etc) and so there is no need to use them and
463 this variable should have a value of t.
465 You should not set this variable directly; its value is computed
466 from `font-lock-defaults', or (if that does not specify anything)
467 by examining the syntax table to see whether it appears to contain
469 (make-variable-buffer-local 'font-lock-keywords-only)
471 (defvar font-lock-keywords-case-fold-search nil
472 "Whether the strings in `font-lock-keywords' should be case-folded.
473 This variable is automatically buffer-local, as the correct value depends
474 on the language in use.")
475 (make-variable-buffer-local 'font-lock-keywords-case-fold-search)
477 (defvar font-lock-after-fontify-buffer-hook nil
478 "Function or functions to run after completion of font-lock-fontify-buffer.")
480 (defvar font-lock-syntax-table nil
481 "Non-nil means use this syntax table for fontifying.
482 If this is nil, the major mode's syntax table is used.
483 This is normally set via `font-lock-defaults'.")
484 (make-variable-buffer-local 'font-lock-syntax-table)
486 ;; These are used in the FSF version in syntactic font-locking.
487 ;; We do this all in C.
488 ;;; These record the parse state at a particular position, always the
489 ;;; start of a line. Used to make
490 ;;; `font-lock-fontify-syntactically-region' faster.
491 ;(defvar font-lock-cache-position nil)
492 ;(defvar font-lock-cache-state nil)
493 ;(make-variable-buffer-local 'font-lock-cache-position)
494 ;(make-variable-buffer-local 'font-lock-cache-state)
496 ;; If this is nil, we only use the beginning of the buffer if we can't use
497 ;; `font-lock-cache-position' and `font-lock-cache-state'.
498 (defvar font-lock-beginning-of-syntax-function nil
499 "Non-nil means use this function to move back outside of a syntactic block.
500 If this is nil, the beginning of the buffer is used (in the worst case).
501 This is normally set via `font-lock-defaults'.")
502 (make-variable-buffer-local 'font-lock-beginning-of-syntax-function)
504 (defvar font-lock-fontify-buffer-function 'font-lock-default-fontify-buffer
505 "Function to use for fontifying the buffer.
506 This is normally set via `font-lock-defaults'.")
508 (defvar font-lock-unfontify-buffer-function 'font-lock-default-unfontify-buffer
509 "Function to use for unfontifying the buffer.
510 This is used when turning off Font Lock mode.
511 This is normally set via `font-lock-defaults'.")
513 (defvar font-lock-fontify-region-function 'font-lock-default-fontify-region
514 "Function to use for fontifying a region.
515 It should take two args, the beginning and end of the region, and an optional
516 third arg VERBOSE. If non-nil, the function should print status messages.
517 This is normally set via `font-lock-defaults'.")
519 (defvar font-lock-unfontify-region-function 'font-lock-default-unfontify-region
520 "Function to use for unfontifying a region.
521 It should take two args, the beginning and end of the region.
522 This is normally set via `font-lock-defaults'.")
524 (defvar font-lock-inhibit-thing-lock nil
525 "List of Font Lock mode related modes that should not be turned on.
526 Currently, valid mode names as `fast-lock-mode' and `lazy-lock-mode'.
527 This is normally set via `font-lock-defaults'.")
530 (defcustom font-lock-mode nil ;; customized for the option menu. dverna
531 "Non nil means `font-lock-mode' is on"
534 :initialize 'custom-initialize-default
536 :set #'(lambda (var val) (font-lock-mode (or val 0)))
539 (defvar font-lock-fontified nil) ; whether we have hacked this buffer
540 (put 'font-lock-fontified 'permanent-local t)
543 (defvar font-lock-mode-hook nil
544 "Function or functions to run on entry to font-lock-mode.")
546 ; whether font-lock-set-defaults has already been run.
547 (defvar font-lock-defaults-computed nil)
548 (make-variable-buffer-local 'font-lock-defaults-computed)
551 ;;; Initialization of faces.
553 ;; #### barf gag retch. Horrid FSF lossage that we need to
554 ;; keep around for compatibility with font-lock-keywords that
555 ;; forget to properly quote their faces.
556 (defvar font-lock-comment-face 'font-lock-comment-face
557 "Don't even think of using this.")
558 (defvar font-lock-doc-string-face 'font-lock-doc-string-face
559 "Don't even think of using this.")
560 (defvar font-lock-string-face 'font-lock-string-face
561 "Don't even think of using this.")
562 (defvar font-lock-keyword-face 'font-lock-keyword-face
563 "Don't even think of using this.")
564 (defvar font-lock-function-name-face 'font-lock-function-name-face
565 "Don't even think of using this.")
566 (defvar font-lock-variable-name-face 'font-lock-variable-name-face
567 "Don't even think of using this.")
568 (defvar font-lock-type-face 'font-lock-type-face
569 "Don't even think of using this.")
570 (defvar font-lock-reference-face 'font-lock-reference-face
571 "Don't even think of using this.")
572 (defvar font-lock-preprocessor-face 'font-lock-preprocessor-face
573 "Don't even think of using this.")
575 (defconst font-lock-face-list
576 '(font-lock-comment-face
577 font-lock-string-face
578 font-lock-doc-string-face
579 font-lock-keyword-face
580 font-lock-function-name-face
581 font-lock-variable-name-face
583 font-lock-reference-face
584 font-lock-preprocessor-face
585 font-lock-warning-face))
587 ;; #### There should be an emulation for the old font-lock-use-*
590 (defface font-lock-comment-face
591 '((((class color) (background dark)) (:foreground "gray80"))
592 (((class color) (background light)) (:foreground "blue4"))
593 (((class grayscale) (background light))
594 (:foreground "DimGray" :bold t :italic t))
595 (((class grayscale) (background dark))
596 (:foreground "LightGray" :bold t :italic t))
598 "Font Lock mode face used to highlight comments."
599 :group 'font-lock-faces)
601 (defface font-lock-string-face
602 '((((class color) (background dark)) (:foreground "tan"))
603 (((class color) (background light)) (:foreground "green4"))
604 (((class grayscale) (background light)) (:foreground "DimGray" :italic t))
605 (((class grayscale) (background dark)) (:foreground "LightGray" :italic t))
607 "Font Lock mode face used to highlight strings."
608 :group 'font-lock-faces)
610 (defface font-lock-doc-string-face
611 '((((class color) (background dark)) (:foreground "light coral"))
612 (((class color) (background light)) (:foreground "green4"))
614 "Font Lock mode face used to highlight documentation strings.
615 This is currently supported only in Lisp-like modes, which are those
616 with \"lisp\" or \"scheme\" in their name. You can explicitly make
617 a mode Lisp-like by putting a non-nil `font-lock-lisp-like' property
618 on the major mode's symbol."
619 :group 'font-lock-faces)
621 (defface font-lock-keyword-face
622 '((((class color) (background dark)) (:foreground "cyan"))
623 (((class color) (background light)) (:foreground "red4"))
624 (((class grayscale) (background light)) (:foreground "LightGray" :bold t))
625 (((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
627 "Font Lock mode face used to highlight keywords."
628 :group 'font-lock-faces)
630 (defface font-lock-function-name-face
631 '((((class color) (background dark)) (:foreground "aquamarine"))
632 (((class color) (background light)) (:foreground "brown4"))
633 (t (:bold t :underline t)))
634 "Font Lock mode face used to highlight function names."
635 :group 'font-lock-faces)
637 (defface font-lock-variable-name-face
638 '((((class color) (background dark)) (:foreground "cyan3"))
639 (((class color) (background light)) (:foreground "magenta4"))
640 (((class grayscale) (background light))
641 (:foreground "Gray90" :bold t :italic t))
642 (((class grayscale) (background dark))
643 (:foreground "DimGray" :bold t :italic t))
645 "Font Lock mode face used to highlight variable names."
646 :group 'font-lock-faces)
648 (defface font-lock-type-face
649 '((((class color) (background dark)) (:foreground "wheat"))
650 (((class color) (background light)) (:foreground "steelblue"))
651 (((class grayscale) (background light)) (:foreground "Gray90" :bold t))
652 (((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
654 "Font Lock mode face used to highlight types."
655 :group 'font-lock-faces)
657 (defface font-lock-reference-face
658 '((((class color) (background dark)) (:foreground "cadetblue2"))
659 (((class color) (background light)) (:foreground "red3"))
660 (((class grayscale) (background light))
661 (:foreground "LightGray" :bold t :underline t))
662 (((class grayscale) (background dark))
663 (:foreground "Gray50" :bold t :underline t)))
664 "Font Lock mode face used to highlight references."
665 :group 'font-lock-faces)
667 ;; #### FSF has font-lock-builtin-face.
669 (defface font-lock-preprocessor-face
670 '((((class color) (background dark)) (:foreground "steelblue1"))
671 (((class color) (background light)) (:foreground "blue3"))
673 "Font Lock Mode face used to highlight preprocessor conditionals."
674 :group 'font-lock-faces)
676 ;; #### Currently unused
677 (defface font-lock-warning-face
678 '((((class color) (background light)) (:foreground "Red" :bold t))
679 (((class color) (background dark)) (:foreground "Pink" :bold t))
680 (t (:inverse-video t :bold t)))
681 "Font Lock mode face used to highlight warnings."
682 :group 'font-lock-faces)
684 (defun font-lock-recompute-variables ()
685 ;; Is this a Draconian thing to do?
686 (mapc #'(lambda (buffer)
687 (with-current-buffer buffer
689 (font-lock-set-defaults t)))
692 ;; Backwards-compatible crud.
694 (defun font-lock-reset-all-faces ()
695 (dolist (face font-lock-face-list)
696 (face-spec-set face (get face 'face-defface-spec))))
698 (defun font-lock-use-default-fonts ()
699 "Reset the font-lock faces to a default set of fonts."
702 (font-lock-reset-all-faces))
704 (defun font-lock-use-default-colors ()
705 "Reset the font-lock faces to a default set of colors."
708 (font-lock-reset-all-faces))
710 (defun font-lock-use-default-minimal-decoration ()
711 "Reset the font-lock patterns to a fast, minimal set of decorations."
712 (and font-lock-maximum-decoration
713 (setq font-lock-maximum-decoration nil)
714 (font-lock-recompute-variables)))
716 (defun font-lock-use-default-maximal-decoration ()
717 "Reset the font-lock patterns to a larger set of decorations."
718 (and (not (eq t font-lock-maximum-decoration))
719 (setq font-lock-maximum-decoration t)
720 (font-lock-recompute-variables)))
723 ;;;;;;;;;;;;;;;;;;;;;; actual code ;;;;;;;;;;;;;;;;;;;;;;
725 ;;; To fontify the whole buffer by language syntax, we go through it a
726 ;;; character at a time, creating extents on the boundary of each syntactic
727 ;;; unit (that is, one extent for each block comment, one for each line
728 ;;; comment, one for each string, etc.) This is done with the C function
729 ;;; syntactically-sectionize. It's in C for speed (the speed of lisp function
730 ;;; calls was a real bottleneck for this task since it involves examining each
731 ;;; character in turn.)
733 ;;; Then we make a second pass, to fontify the buffer based on other patterns
734 ;;; specified by regexp. When we find a match for a region of text, we need
735 ;;; to change the fonts on those characters. This is done with the
736 ;;; put-text-property function, which knows how to efficiently share extents.
737 ;;; Conceptually, we are attaching some particular face to each of the
738 ;;; characters in a range, but the implementation of this involves creating
739 ;;; extents, or resizing existing ones.
741 ;;; Each time a modification happens to a line, we re-fontify the entire line.
742 ;;; We do this by first removing the extents (text properties) on the line,
743 ;;; and then doing the syntactic and keyword passes again on that line. (More
744 ;;; generally, each modified region is extended to include the preceding and
745 ;;; following BOL or EOL.)
747 ;;; This means that, as the user types, we repeatedly go back to the beginning
748 ;;; of the line, doing more work the longer the line gets. This doesn't cost
749 ;;; much in practice, and if we don't, then we incorrectly fontify things when,
750 ;;; for example, inserting spaces into `intfoo () {}'.
754 ;; The user level functions
757 (defun font-lock-mode (&optional arg)
758 "Toggle Font Lock Mode.
759 With arg, turn font-lock mode on if and only if arg is positive.
761 When Font Lock mode is enabled, text is fontified as you type it:
763 - Comments are displayed in `font-lock-comment-face';
764 - Strings are displayed in `font-lock-string-face';
765 - Documentation strings (in Lisp-like languages) are displayed in
766 `font-lock-doc-string-face';
767 - Language keywords (\"reserved words\") are displayed in
768 `font-lock-keyword-face';
769 - Function names in their defining form are displayed in
770 `font-lock-function-name-face';
771 - Variable names in their defining form are displayed in
772 `font-lock-variable-name-face';
773 - Type names are displayed in `font-lock-type-face';
774 - References appearing in help files and the like are displayed
775 in `font-lock-reference-face';
776 - Preprocessor declarations are displayed in
777 `font-lock-preprocessor-face';
781 - Certain other expressions are displayed in other faces according
782 to the value of the variable `font-lock-keywords'.
784 Where modes support different levels of fontification, you can use the variable
785 `font-lock-maximum-decoration' to specify which level you generally prefer.
786 When you turn Font Lock mode on/off the buffer is fontified/defontified, though
787 fontification occurs only if the buffer is less than `font-lock-maximum-size'.
788 To fontify a buffer without turning on Font Lock mode, and regardless of buffer
789 size, you can use \\[font-lock-fontify-buffer].
791 See the variable `font-lock-keywords' for customization."
793 (let ((on-p (if arg (> (prefix-numeric-value arg) 0) (not font-lock-mode)))
794 (maximum-size (if (not (consp font-lock-maximum-size))
795 font-lock-maximum-size
796 (cdr (or (assq major-mode font-lock-maximum-size)
797 (assq t font-lock-maximum-size))))))
798 ;; Font-lock mode will refuse to turn itself on if in batch mode, or if
799 ;; the current buffer is "invisible". The latter is because packages
800 ;; sometimes put their temporary buffers into some particular major mode
801 ;; to get syntax tables and variables and whatnot, but we don't want the
802 ;; fact that the user has font-lock-mode on a mode hook to slow these
804 (if (or noninteractive (eq (aref (buffer-name) 0) ?\ ))
806 (if (equal (buffer-name) " *Compiler Input*") ; hack for bytecomp...
809 (make-local-hook 'after-change-functions)
810 (add-hook 'after-change-functions
811 'font-lock-after-change-function nil t)
812 (add-hook 'pre-idle-hook 'font-lock-pre-idle-hook))
814 (remove-hook 'after-change-functions
815 'font-lock-after-change-function t)
816 (setq font-lock-defaults-computed nil
817 font-lock-keywords nil)
818 ;; We have no business doing this here, since
819 ;; pre-idle-hook is global. Other buffers may
820 ;; still be in font-lock mode. -dkindred@cs.cmu.edu
821 ;; (remove-hook 'pre-idle-hook 'font-lock-pre-idle-hook)
823 (set (make-local-variable 'font-lock-mode) on-p)
825 (font-lock-set-defaults-1)
826 (make-local-hook 'before-revert-hook)
827 (make-local-hook 'after-revert-hook)
828 ;; If buffer is reverted, must clean up the state.
829 (add-hook 'before-revert-hook 'font-lock-revert-setup nil t)
830 (add-hook 'after-revert-hook 'font-lock-revert-cleanup nil t)
831 (run-hooks 'font-lock-mode-hook)
832 (cond (font-lock-fontified
834 ((or (null maximum-size) (<= (buffer-size) maximum-size))
835 (font-lock-fontify-buffer))
837 (lmessage 'command "Fontifying %s... buffer too big."
840 (setq font-lock-fontified nil)
841 (remove-hook 'before-revert-hook 'font-lock-revert-setup t)
842 (remove-hook 'after-revert-hook 'font-lock-revert-cleanup t)
843 (font-lock-unfontify-region (point-min) (point-max))
844 (font-lock-thing-lock-cleanup))
846 (remove-hook 'before-revert-hook 'font-lock-revert-setup t)
847 (remove-hook 'after-revert-hook 'font-lock-revert-cleanup t)
848 (font-lock-thing-lock-cleanup)))
851 ;; For init-file hooks
853 (defun turn-on-font-lock ()
854 "Unconditionally turn on Font Lock mode."
858 (defun turn-off-font-lock ()
859 "Unconditionally turn off Font Lock mode."
864 ;; support for add-keywords, global-font-lock-mode and
865 ;; font-lock-support-mode (unified support for various *-lock modes).
868 ;; Fontification functions.
870 ;; We first define some defsubsts to encapsulate the way we add
871 ;; faces to a region of text. I am planning on modifying the
872 ;; text-property mechanism so that multiple independent classes
873 ;; of text properties can exist. That way, for example, ediff's
874 ;; face text properties don't interfere with font lock's face
875 ;; text properties. Due to the XEmacs implementation of text
876 ;; properties in terms of extents, doing this is fairly trivial:
877 ;; instead of using the `text-prop' property, you just use a
878 ;; specified property.
880 (defsubst font-lock-set-face (start end face)
881 ;; Set the face on the characters in the range.
882 (put-nonduplicable-text-property start end 'face face)
883 (put-nonduplicable-text-property start end 'font-lock t))
885 (defsubst font-lock-remove-face (start end)
886 ;; Remove any syntax highlighting on the characters in the range.
887 (put-nonduplicable-text-property start end 'face nil)
888 (put-nonduplicable-text-property start end 'font-lock nil))
890 (defsubst font-lock-any-faces-p (start end)
891 ;; Return non-nil if we've put any syntax highlighting on
892 ;; the characters in the range.
894 ;; used to look for 'text-prop property, but this has problems if
895 ;; you put any other text properties in the vicinity. Simon
896 ;; Marshall suggested looking for the 'face property (this is what
897 ;; FSF Emacs does) but that's equally bogus. Only reliable way is
898 ;; for font-lock to specially mark its extents.
900 ;; FSF's (equivalent) definition of this defsubst would be
901 ;; (text-property-not-all start end 'font-lock nil)
903 ;; Perhaps our `map-extents' is faster than our definition
904 ;; of `text-property-not-all'. #### If so, `text-property-not-all'
905 ;; should be fixed ...
907 (map-extents 'extent-property (current-buffer) start (1- end) 'font-lock))
910 ;; Fontification functions.
912 ;; Rather than the function, e.g., `font-lock-fontify-region' containing the
913 ;; code to fontify a region, the function runs the function whose name is the
914 ;; value of the variable, e.g., `font-lock-fontify-region-function'. Normally,
915 ;; the value of this variable is, e.g., `font-lock-default-fontify-region'
916 ;; which does contain the code to fontify a region. However, the value of the
917 ;; variable could be anything and thus, e.g., `font-lock-fontify-region' could
918 ;; do anything. The indirection of the fontification functions gives major
919 ;; modes the capability of modifying the way font-lock.el fontifies. Major
920 ;; modes can modify the values of, e.g., `font-lock-fontify-region-function',
921 ;; via the variable `font-lock-defaults'.
923 ;; For example, Rmail mode sets the variable `font-lock-defaults' so that
924 ;; font-lock.el uses its own function for buffer fontification. This function
925 ;; makes fontification be on a message-by-message basis and so visiting an
926 ;; RMAIL file is much faster. A clever implementation of the function might
927 ;; fontify the headers differently than the message body. (It should, and
928 ;; correspondingly for Mail mode, but I can't be bothered to do the work. Can
929 ;; you?) This hints at a more interesting use...
931 ;; Languages that contain text normally contained in different major modes
932 ;; could define their own fontification functions that treat text differently
933 ;; depending on its context. For example, Perl mode could arrange that here
934 ;; docs are fontified differently than Perl code. Or Yacc mode could fontify
935 ;; rules one way and C code another. Neat!
937 ;; A further reason to use the fontification indirection feature is when the
938 ;; default syntactual fontification, or the default fontification in general,
939 ;; is not flexible enough for a particular major mode. For example, perhaps
940 ;; comments are just too hairy for `font-lock-fontify-syntactically-region' to
941 ;; cope with. You need to write your own version of that function, e.g.,
942 ;; `hairy-fontify-syntactically-region', and make your own version of
943 ;; `hairy-fontify-region' call that function before calling
944 ;; `font-lock-fontify-keywords-region' for the normal regexp fontification
945 ;; pass. And Hairy mode would set `font-lock-defaults' so that font-lock.el
946 ;; would call your region fontification function instead of its own. For
947 ;; example, TeX modes could fontify {\foo ...} and \bar{...} etc. multi-line
948 ;; directives correctly and cleanly. (It is the same problem as fontifying
949 ;; multi-line strings and comments; regexps are not appropriate for the job.)
952 (defun font-lock-fontify-buffer ()
953 "Fontify the current buffer the way `font-lock-mode' would.
954 See `font-lock-mode' for details.
956 This can take a while for large buffers."
958 (let ((font-lock-verbose (or font-lock-verbose (interactive-p))))
959 (funcall font-lock-fontify-buffer-function)))
961 (defun font-lock-unfontify-buffer ()
962 (funcall font-lock-unfontify-buffer-function))
964 (defun font-lock-fontify-region (beg end &optional loudly)
965 (funcall font-lock-fontify-region-function beg end loudly))
967 (defun font-lock-unfontify-region (beg end &optional loudly)
968 (funcall font-lock-unfontify-region-function beg end loudly))
970 ;; #### In these functions, the FSF is careful to do
973 ;; before anything else. Should we copy?
974 (defun font-lock-default-fontify-buffer ()
976 (let ((was-on font-lock-mode)
977 (font-lock-verbose (or font-lock-verbose (interactive-p)))
978 (font-lock-message-threshold 0)
980 ;; Turn it on to run hooks and get the right font-lock-keywords.
981 (or was-on (font-lock-mode 1))
982 (font-lock-unfontify-region (point-min) (point-max) t)
983 ;; (buffer-syntactic-context-flush-cache)
985 ;; If a ^G is typed during fontification, abort the fontification, but
986 ;; return normally (do not signal.) This is to make it easy to abort
987 ;; fontification if it's taking a long time, without also causing the
988 ;; buffer not to pop up. If a real abort is desired, the user can ^G
991 ;; Possibly this should happen down in font-lock-fontify-region instead
992 ;; of here, but since that happens from the after-change-hook (meaning
993 ;; much more frequently) I'm afraid of the bad consequences of stealing
994 ;; the interrupt character at inopportune times.
998 (font-lock-fontify-region (point-min) (point-max)))
1002 (or was-on ; turn it off if it was off.
1003 (let ((font-lock-fontified nil)) ; kludge to prevent defontification
1004 (font-lock-mode 0)))
1005 (set (make-local-variable 'font-lock-fontified) t)
1006 (when (and aborted font-lock-verbose)
1007 (lmessage 'command "Fontifying %s... aborted." (buffer-name))))
1008 (run-hooks 'font-lock-after-fontify-buffer-hook))
1010 (defun font-lock-default-unfontify-buffer ()
1011 (font-lock-unfontify-region (point-min) (point-max))
1012 (set (make-local-variable 'font-lock-fontified) nil))
1014 ;; This used to be `font-lock-fontify-region', and before that,
1015 ;; `font-lock-fontify-region' used to be the name used for what is now
1016 ;; `font-lock-fontify-syntactically-region'.
1017 (defun font-lock-default-fontify-region (beg end &optional loudly)
1018 (let ((modified (buffer-modified-p))
1019 (buffer-undo-list t) (inhibit-read-only t)
1020 (old-syntax-table (syntax-table))
1021 buffer-file-name buffer-file-truename)
1024 ;; Use the fontification syntax table, if any.
1025 (if font-lock-syntax-table (set-syntax-table font-lock-syntax-table))
1026 ;; Now do the fontification.
1027 (if font-lock-keywords-only
1028 (font-lock-unfontify-region beg end)
1029 (font-lock-fontify-syntactically-region beg end loudly))
1030 (font-lock-fontify-keywords-region beg end loudly))
1032 (set-syntax-table old-syntax-table)
1033 (and (not modified) (buffer-modified-p) (set-buffer-modified-p nil)))))
1035 ;; The following must be rethought, since keywords can override fontification.
1036 ; ;; Now scan for keywords, but not if we are inside a comment now.
1037 ; (or (and (not font-lock-keywords-only)
1038 ; (let ((state (parse-partial-sexp beg end nil nil
1039 ; font-lock-cache-state)))
1040 ; (or (nth 4 state) (nth 7 state))))
1041 ; (font-lock-fontify-keywords-region beg end))
1043 (defun font-lock-default-unfontify-region (beg end &optional maybe-loudly)
1044 (when (and maybe-loudly font-lock-verbose
1045 (>= (- end beg) font-lock-message-threshold))
1046 (lmessage 'progress "Fontifying %s..." (buffer-name)))
1047 (let ((modified (buffer-modified-p))
1048 (buffer-undo-list t) (inhibit-read-only t)
1049 buffer-file-name buffer-file-truename)
1050 (font-lock-remove-face beg end)
1051 (and (not modified) (buffer-modified-p) (set-buffer-modified-p nil))))
1053 ;; Following is the original FSF version (similar to our original
1054 ;; version, before all the crap I added below).
1056 ;; Probably that crap should either be fixed up so it works better,
1059 ;; I think that lazy-lock v2 tries to do something similar.
1060 ;; Those efforts should be merged.
1062 ;; Called when any modification is made to buffer text.
1063 ;(defun font-lock-after-change-function (beg end old-len)
1066 ; ;; Rescan between start of line from `beg' and start of line after `end'.
1067 ; (font-lock-fontify-region
1068 ; (progn (goto-char beg) (beginning-of-line) (point))
1069 ; (progn (goto-char end) (forward-line 1) (point))))))
1071 (defvar font-lock-old-extent nil)
1072 (defvar font-lock-old-len 0)
1074 (defun font-lock-fontify-glumped-region ()
1075 ;; even if something goes wrong in the fontification, mark the glumped
1076 ;; region as fontified; otherwise, the same error might get signaled
1077 ;; after every command.
1079 ;; buffer/extent may be deleted.
1080 (if (and (extent-live-p font-lock-old-extent)
1081 (buffer-live-p (extent-object font-lock-old-extent)))
1083 (set-buffer (extent-object font-lock-old-extent))
1084 (font-lock-after-change-function-1
1085 (extent-start-position font-lock-old-extent)
1086 (extent-end-position font-lock-old-extent)
1087 font-lock-old-len)))
1088 (detach-extent font-lock-old-extent)
1089 (setq font-lock-old-extent nil)))
1091 (defun font-lock-pre-idle-hook ()
1093 (if font-lock-old-extent
1094 (font-lock-fontify-glumped-region))
1095 (error (warn "Error caught in `font-lock-pre-idle-hook'"))))
1097 (defvar font-lock-always-fontify-immediately nil
1098 "Set this to non-nil to disable font-lock deferral.")
1100 ;;; called when any modification is made to buffer text. This function
1101 ;;; attempts to glump adjacent changes together so that excessive
1102 ;;; fontification is avoided. This function could easily be adapted
1103 ;;; to other after-change-functions.
1105 (defun font-lock-after-change-function (beg end old-len)
1106 (let ((obeg (and font-lock-old-extent
1107 (extent-start-position font-lock-old-extent)))
1108 (oend (and font-lock-old-extent
1109 (extent-end-position font-lock-old-extent)))
1110 (bc-end (+ beg old-len)))
1112 ;; If this change can't be merged into the glumped one,
1113 ;; we need to fontify the glumped one right now.
1114 (if (and font-lock-old-extent
1115 (or (not (eq (current-buffer)
1116 (extent-object font-lock-old-extent)))
1119 (font-lock-fontify-glumped-region))
1121 (if font-lock-old-extent
1122 ;; Update glumped region.
1124 ;; Any characters in the before-change region that are
1125 ;; outside the glumped region go into the glumped
1126 ;; before-change region.
1128 (setq font-lock-old-len (+ font-lock-old-len (- bc-end oend))))
1130 (setq font-lock-old-len (+ font-lock-old-len (- obeg beg))))
1131 ;; New glumped region is the union of the glumped region
1132 ;; and the new region.
1133 (set-extent-endpoints font-lock-old-extent
1137 ;; No glumped region, so create one.
1138 (setq font-lock-old-extent (make-extent beg end))
1139 (set-extent-property font-lock-old-extent 'detachable nil)
1140 (set-extent-property font-lock-old-extent 'end-open nil)
1141 (setq font-lock-old-len old-len))
1143 (if font-lock-always-fontify-immediately
1144 (font-lock-fontify-glumped-region))))
1146 (defun font-lock-after-change-function-1 (beg end old-len)
1147 (if (null font-lock-mode)
1151 ;; if we don't widen, then fill-paragraph (and any command that
1152 ;; operates on a narrowed region) confuses things, because the C
1153 ;; code will fail to realize that we're inside a comment.
1156 (let ((zmacs-region-stays zmacs-region-stays)) ; protect from change!
1158 ;; Maybe flush the internal cache used by syntactically-sectionize.
1159 ;; (It'd be nice if this was more automatic.) Any deletions mean
1160 ;; the cache is invalid, and insertions at beginning or end of line
1161 ;; mean that the bol cache might be invalid.
1162 ;; (if (or (> old-len 0) (bobp) (= (preceding-char) ?\n))
1163 ;; (buffer-syntactic-context-flush-cache))
1165 ;; Always recompute the whole line.
1172 ;; Rescan between start of line from `beg' and start of line after
1174 (font-lock-fontify-region beg end)))))))
1177 ;; Syntactic fontification functions.
1179 ;; Note: Here is the FSF version. Our version is much faster because
1180 ;; of the C support we provide. This may be useful for reference,
1181 ;; however, and perhaps there is something useful here that should
1182 ;; be merged into our version.
1184 ;(defun font-lock-fontify-syntactically-region (start end &optional loudly)
1185 ; "Put proper face on each string and comment between START and END.
1186 ;START should be at the beginning of a line."
1187 ; (let ((synstart (if comment-start-skip
1188 ; (concat "\\s\"\\|" comment-start-skip)
1190 ; (comstart (if comment-start-skip
1191 ; (concat "\\s<\\|" comment-start-skip)
1193 ; state prev prevstate)
1194 ; (if loudly (message "Fontifying %s... (syntactically...)" (buffer-name)))
1199 ; ;; Find the state at the `beginning-of-line' before `start'.
1200 ; (if (eq start font-lock-cache-position)
1201 ; ;; Use the cache for the state of `start'.
1202 ; (setq state font-lock-cache-state)
1203 ; ;; Find the state of `start'.
1204 ; (if (null font-lock-beginning-of-syntax-function)
1205 ; ;; Use the state at the previous cache position, if any, or
1206 ; ;; otherwise calculate from `point-min'.
1207 ; (if (or (null font-lock-cache-position)
1208 ; (< start font-lock-cache-position))
1209 ; (setq state (parse-partial-sexp (point-min) start))
1210 ; (setq state (parse-partial-sexp font-lock-cache-position start
1211 ; nil nil font-lock-cache-state)))
1212 ; ;; Call the function to move outside any syntactic block.
1213 ; (funcall font-lock-beginning-of-syntax-function)
1214 ; (setq state (parse-partial-sexp (point) start)))
1215 ; ;; Cache the state and position of `start'.
1216 ; (setq font-lock-cache-state state
1217 ; font-lock-cache-position start))
1219 ; ;; If the region starts inside a string, show the extent of it.
1221 ; (let ((beg (point)))
1222 ; (while (and (re-search-forward "\\s\"" end 'move)
1223 ; (nth 3 (parse-partial-sexp beg (point)
1225 ; (put-text-property beg (point) 'face font-lock-string-face)
1226 ; (setq state (parse-partial-sexp beg (point) nil nil state))))
1228 ; ;; Likewise for a comment.
1229 ; (if (or (nth 4 state) (nth 7 state))
1230 ; (let ((beg (point)))
1232 ; (narrow-to-region (point-min) end)
1233 ; (condition-case nil
1235 ; (re-search-backward comstart (point-min) 'move)
1236 ; (forward-comment 1)
1237 ; ;; forward-comment skips all whitespace,
1238 ; ;; so go back to the real end of the comment.
1239 ; (skip-chars-backward " \t"))
1240 ; (error (goto-char end))))
1241 ; (put-text-property beg (point) 'face font-lock-comment-face)
1242 ; (setq state (parse-partial-sexp beg (point) nil nil state))))
1244 ; ;; Find each interesting place between here and `end'.
1245 ; (while (and (< (point) end)
1246 ; (setq prev (point) prevstate state)
1247 ; (re-search-forward synstart end t)
1249 ; ;; Clear out the fonts of what we skip over.
1250 ; (remove-text-properties prev (point) '(face nil))
1251 ; ;; Verify the state at that place
1252 ; ;; so we don't get fooled by \" or \;.
1253 ; (setq state (parse-partial-sexp prev (point)
1255 ; (let ((here (point)))
1256 ; (if (or (nth 4 state) (nth 7 state))
1258 ; ;; We found a real comment start.
1259 ; (let ((beg (match-beginning 0)))
1262 ; (narrow-to-region (point-min) end)
1263 ; (condition-case nil
1265 ; (forward-comment 1)
1266 ; ;; forward-comment skips all whitespace,
1267 ; ;; so go back to the real end of the comment.
1268 ; (skip-chars-backward " \t"))
1269 ; (error (goto-char end))))
1270 ; (put-text-property beg (point) 'face
1271 ; font-lock-comment-face)
1272 ; (setq state (parse-partial-sexp here (point) nil nil state)))
1275 ; ;; We found a real string start.
1276 ; (let ((beg (match-beginning 0)))
1277 ; (while (and (re-search-forward "\\s\"" end 'move)
1278 ; (nth 3 (parse-partial-sexp here (point)
1280 ; (put-text-property beg (point) 'face font-lock-string-face)
1281 ; (setq state (parse-partial-sexp here (point)
1282 ; nil nil state))))))
1284 ; ;; Make sure `prev' is non-nil after the loop
1285 ; ;; only if it was set on the very last iteration.
1289 ; (and prev (remove-text-properties prev end '(face nil)))))
1291 (defun font-lock-lisp-like (mode)
1292 ;; Note: (or (get mode 'font-lock-lisp-like) (string-match ...)) is
1293 ;; not enough because the property needs to be able to specify a nil
1295 (if (plist-member (symbol-plist mode) 'font-lock-lisp-like)
1296 (get mode 'font-lock-lisp-like)
1297 ;; If the property is not specified, guess. Similar logic exists
1298 ;; in add-log, but I think this encompasses more modes.
1299 (string-match "lisp\\|scheme" (symbol-name mode))))
1301 (defun font-lock-fontify-syntactically-region (start end &optional loudly)
1302 "Put proper face on each string and comment between START and END.
1303 START should be at the beginning of a line."
1304 (if font-lock-keywords-only
1306 (when (and font-lock-verbose
1307 (>= (- end start) font-lock-message-threshold))
1308 (lmessage 'progress "Fontifying %s... (syntactically...)"
1310 (font-lock-unfontify-region start end loudly)
1312 (if (> end (point-max)) (setq end (point-max)))
1313 (let ((lisp-like (font-lock-lisp-like major-mode)))
1314 (syntactically-sectionize
1315 #'(lambda (s e context depth)
1317 (cond ((eq context 'string)
1319 ;; #### It would be nice if we handled
1320 ;; Python and other non-Lisp languages with
1321 ;; docstrings correctly.
1322 (if (and lisp-like (= depth 1))
1323 ;; really we should only use this if
1324 ;; in position 3 depth 1, but that's
1325 ;; too expensive to compute.
1326 'font-lock-doc-string-face
1327 'font-lock-string-face)))
1328 ((or (eq context 'comment)
1329 (eq context 'block-comment))
1330 (setq face 'font-lock-comment-face)
1331 ; ;; Don't fontify whitespace at the beginning of lines;
1332 ; ;; otherwise comment blocks may not line up with code.
1333 ; ;; (This is sometimes a good idea, sometimes not; in any
1334 ; ;; event it should be in C for speed --jwz)
1337 ; (while (prog1 (search-forward "\n" (1- e) 'move)
1338 ; (setq face 'font-lock-comment-face)
1340 ; (skip-chars-forward " \t\n")
1343 (font-lock-set-face s e face)))
1347 ;;; Additional text property functions.
1349 ;; The following three text property functions are not generally available (and
1350 ;; it's not certain that they should be) so they are inlined for speed.
1351 ;; The case for `fillin-text-property' is simple; it may or not be generally
1352 ;; useful. (Since it is used here, it is useful in at least one place.;-)
1353 ;; However, the case for `append-text-property' and `prepend-text-property' is
1354 ;; more complicated. Should they remove duplicate property values or not? If
1355 ;; so, should the first or last duplicate item remain? Or the one that was
1356 ;; added? In our implementation, the first duplicate remains.
1358 ;; XEmacs: modified all these functions to use
1359 ;; `put-nonduplicable-text-property' instead of `put-text-property', and
1360 ;; the first one to take both SETPROP and MARKPROP, in accordance with the
1361 ;; changed definitions of `font-lock-any-faces-p' and `font-lock-set-face'.
1363 (defsubst font-lock-fillin-text-property (start end setprop markprop value &optional object)
1364 "Fill in one property of the text from START to END.
1365 Arguments PROP and VALUE specify the property and value to put where none are
1366 already in place. Therefore existing property values are not overwritten.
1367 Optional argument OBJECT is the string or buffer containing the text."
1368 (let ((start (text-property-any start end markprop nil object)) next)
1370 (setq next (next-single-property-change start markprop object end))
1371 (put-nonduplicable-text-property start next setprop value object)
1372 (put-nonduplicable-text-property start next markprop value object)
1373 (setq start (text-property-any next end markprop nil object)))))
1375 ;; This function (from simon's unique.el) is rewritten and inlined for speed.
1376 ;(defun unique (list function)
1377 ; "Uniquify LIST, deleting elements using FUNCTION.
1378 ;Return the list with subsequent duplicate items removed by side effects.
1379 ;FUNCTION is called with an element of LIST and a list of elements from LIST,
1380 ;and should return the list of elements with occurrences of the element removed,
1381 ;i.e., a function such as `delete' or `delq'.
1382 ;This function will work even if LIST is unsorted. See also `uniq'."
1383 ; (let ((list list))
1385 ; (setq list (setcdr list (funcall function (car list) (cdr list))))))
1388 (defsubst font-lock-unique (list)
1389 "Uniquify LIST, deleting elements using `delq'.
1390 Return the list with subsequent duplicate items removed by side effects."
1393 (setq list (setcdr list (delq (car list) (cdr list))))))
1396 ;; A generalisation of `facemenu-add-face' for any property, but without the
1397 ;; removal of inactive faces via `facemenu-discard-redundant-faces' and special
1398 ;; treatment of `default'. Uses `unique' to remove duplicate property values.
1399 (defsubst font-lock-prepend-text-property (start end prop value &optional object)
1400 "Prepend to one property of the text from START to END.
1401 Arguments PROP and VALUE specify the property and value to prepend to the value
1402 already in place. The resulting property values are always lists, and unique.
1403 Optional argument OBJECT is the string or buffer containing the text."
1404 (let ((val (if (listp value) value (list value))) next prev)
1405 (while (/= start end)
1406 (setq next (next-single-property-change start prop object end)
1407 prev (get-text-property start prop object))
1410 (font-lock-unique (append val (if (listp prev) prev (list prev))))
1412 (setq start next))))
1414 (defsubst font-lock-append-text-property (start end prop value &optional object)
1415 "Append to one property of the text from START to END.
1416 Arguments PROP and VALUE specify the property and value to append to the value
1417 already in place. The resulting property values are always lists, and unique.
1418 Optional argument OBJECT is the string or buffer containing the text."
1419 (let ((val (if (listp value) value (list value))) next prev)
1420 (while (/= start end)
1421 (setq next (next-single-property-change start prop object end)
1422 prev (get-text-property start prop object))
1425 (font-lock-unique (append (if (listp prev) prev (list prev)) val))
1427 (setq start next))))
1429 ;;; Regexp fontification functions.
1431 (defsubst font-lock-apply-highlight (highlight)
1432 "Apply HIGHLIGHT following a match.
1433 HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'."
1434 (let* ((match (nth 0 highlight))
1435 (start (match-beginning match)) (end (match-end match))
1436 (override (nth 2 highlight)))
1437 (let ((newface (nth 1 highlight)))
1438 (or (symbolp newface)
1439 (setq newface (eval newface)))
1441 ;; No match but we might not signal an error.
1442 (or (nth 3 highlight)
1443 (error "No match %d in highlight %S" match highlight)))
1446 ;; Cannot override existing fontification.
1447 (or (font-lock-any-faces-p start end)
1448 (font-lock-set-face start end newface)))
1450 ;; Override existing fontification.
1451 (font-lock-set-face start end newface))
1452 ((eq override 'keep)
1453 ;; Keep existing fontification.
1454 (font-lock-fillin-text-property start end 'face 'font-lock
1456 ((eq override 'prepend)
1457 ;; Prepend to existing fontification.
1458 (font-lock-prepend-text-property start end 'face newface))
1459 ((eq override 'append)
1460 ;; Append to existing fontification.
1461 (font-lock-append-text-property start end 'face newface))))))
1463 (defsubst font-lock-fontify-anchored-keywords (keywords limit)
1464 "Fontify according to KEYWORDS until LIMIT.
1465 KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords',
1466 LIMIT can be modified by the value of its PRE-MATCH-FORM."
1467 (let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights
1468 ;; Evaluate PRE-MATCH-FORM.
1469 (pre-match-value (eval (nth 1 keywords))))
1470 ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line.
1471 (if (and (numberp pre-match-value) (> pre-match-value (point)))
1472 (setq limit pre-match-value)
1473 (save-excursion (end-of-line) (setq limit (point))))
1475 ;; Find an occurrence of `matcher' before `limit'.
1476 (while (if (stringp matcher)
1477 (re-search-forward matcher limit t)
1478 (funcall matcher limit))
1479 ;; Apply each highlight to this instance of `matcher'.
1480 (setq highlights lowdarks)
1482 (font-lock-apply-highlight (car highlights))
1483 (setq highlights (cdr highlights)))))
1484 ;; Evaluate POST-MATCH-FORM.
1485 (eval (nth 2 keywords))))
1487 (defun font-lock-fontify-keywords-region (start end &optional loudvar)
1488 "Fontify according to `font-lock-keywords' between START and END.
1489 START should be at the beginning of a line."
1490 (let ((loudly (and font-lock-verbose
1491 (>= (- end start) font-lock-message-threshold))))
1492 (let ((case-fold-search font-lock-keywords-case-fold-search)
1493 (keywords (cdr (if (eq (car-safe font-lock-keywords) t)
1495 (font-lock-compile-keywords))))
1496 (bufname (buffer-name)) (count 0)
1497 keyword matcher highlights)
1499 ;; Fontify each item in `font-lock-keywords' from `start' to `end'.
1501 (when loudly (lmessage 'progress "Fontifying %s... (regexps..%s)"
1503 (make-string (setq count (1+ count)) ?.)))
1505 ;; Find an occurrence of `matcher' from `start' to `end'.
1506 (setq keyword (car keywords) matcher (car keyword))
1508 (while (and (< (point) end)
1509 (if (stringp matcher)
1510 (re-search-forward matcher end t)
1511 (funcall matcher end)))
1512 ;; Apply each highlight to this instance of `matcher', which may be
1513 ;; specific highlights or more keywords anchored to `matcher'.
1514 (setq highlights (cdr keyword))
1516 (if (numberp (car (car highlights)))
1517 (let ((end (match-end (car (car highlights)))))
1518 (font-lock-apply-highlight (car highlights))
1519 ;; restart search just after the end of the
1520 ;; keyword so keywords can share bracketing
1522 (and end (goto-char end)))
1523 (font-lock-fontify-anchored-keywords (car highlights) end))
1524 (setq highlights (cdr highlights))))
1525 (setq keywords (cdr keywords))))
1526 (if loudly (lmessage 'progress "Fontifying %s... done." (buffer-name)))))
1529 ;; Various functions.
1531 ;; Turn off other related packages if they're on. I prefer a hook. --sm.
1532 ;; These explicit calls are easier to understand
1533 ;; because people know what they will do.
1534 ;; A hook is a mystery because it might do anything whatever. --rms.
1535 (defun font-lock-thing-lock-cleanup ()
1536 (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
1537 (fast-lock-mode -1))
1538 ((and (boundp 'lazy-lock-mode) lazy-lock-mode)
1539 (lazy-lock-mode -1))
1540 ((and (boundp 'lazy-shot-mode) lazy-shot-mode)
1541 (lazy-shot-mode -1))))
1543 ;; Do something special for these packages after fontifying. I prefer a hook.
1544 (defun font-lock-after-fontify-buffer ()
1545 (cond ((and (boundp 'fast-lock-mode) fast-lock-mode)
1546 (fast-lock-after-fontify-buffer))
1547 ((and (boundp 'lazy-lock-mode) lazy-lock-mode)
1548 (lazy-lock-after-fontify-buffer))))
1550 ;; If the buffer is about to be reverted, it won't be fontified afterward.
1551 (defun font-lock-revert-setup ()
1552 (setq font-lock-fontified nil))
1554 ;; If the buffer has just been reverted, normally that turns off
1555 ;; Font Lock mode. So turn the mode back on if necessary.
1556 ;; sb 1999-03-03 -- The above comment no longer appears to be operative as
1557 ;; the first call to normal-mode *will* restore the font-lock state and
1558 ;; this call forces a second font-locking to occur when reverting a buffer,
1559 ;; which is wasteful at best.
1560 ;(defalias 'font-lock-revert-cleanup 'turn-on-font-lock)
1561 (defun font-lock-revert-cleanup ())
1564 ;; Various functions.
1566 (defun font-lock-compile-keywords (&optional keywords)
1567 ;; Compile `font-lock-keywords' into the form (t KEYWORD ...) where KEYWORD
1568 ;; is the (MATCHER HIGHLIGHT ...) shown in the variable's doc string.
1569 (let ((keywords (or keywords font-lock-keywords)))
1570 (setq font-lock-keywords
1571 (if (eq (car-safe keywords) t)
1573 (cons t (mapcar 'font-lock-compile-keyword keywords))))))
1575 (defun font-lock-compile-keyword (keyword)
1576 (cond ((nlistp keyword) ; Just MATCHER
1577 (list keyword '(0 font-lock-keyword-face)))
1578 ((eq (car keyword) 'eval) ; Specified (eval . FORM)
1579 (font-lock-compile-keyword (eval (cdr keyword))))
1580 ((numberp (cdr keyword)) ; Specified (MATCHER . MATCH)
1581 (list (car keyword) (list (cdr keyword) 'font-lock-keyword-face)))
1582 ((symbolp (cdr keyword)) ; Specified (MATCHER . FACENAME)
1583 (list (car keyword) (list 0 (cdr keyword))))
1584 ((nlistp (nth 1 keyword)) ; Specified (MATCHER . HIGHLIGHT)
1585 (list (car keyword) (cdr keyword)))
1586 (t ; Hopefully (MATCHER HIGHLIGHT ...)
1589 (defun font-lock-choose-keywords (keywords level)
1590 ;; Return LEVELth element of KEYWORDS. A LEVEL of nil is equal to a
1591 ;; LEVEL of 0, a LEVEL of t is equal to (1- (length KEYWORDS)).
1592 (let ((level (if (not (consp level))
1594 (cdr (or (assq major-mode level) (assq t level))))))
1595 (cond ((symbolp keywords)
1598 (or (nth level keywords) (car (reverse keywords))))
1600 (car (reverse keywords)))
1605 ;;; Determining which set of font-lock keywords to use.
1607 (defun font-lock-find-font-lock-defaults (modesym)
1608 ;; Get the defaults based on the major mode.
1610 ;; I want a do-while loop!
1612 (setq raw-defaults (get modesym 'font-lock-defaults))
1613 (and raw-defaults (symbolp raw-defaults)
1614 (setq modesym raw-defaults)))
1618 (defun font-lock-examine-syntax-table ()
1619 ; Computes the value of font-lock-keywords-only for this buffer.
1620 (if (eq (syntax-table) (standard-syntax-table))
1621 ;; Assume that modes which haven't bothered to install their own
1622 ;; syntax table don't do anything syntactically interesting.
1623 ;; Really, the standard-syntax-table shouldn't have comments and
1624 ;; strings in it, but changing that now might break things.
1626 ;; else map over the syntax table looking for strings or comments.
1629 (if (fboundp 'map-syntax-table)
1632 #'(lambda (key value)
1633 (memq (char-syntax-from-code value)
1634 '(?\" ?\< ?\> ?\$)))
1637 (let ((i (1- (length (syntax-table)))))
1639 (if (memq (char-syntax i) '(?\" ?\< ?\> ?\$))
1640 (setq got-one t i 0))
1642 (set (make-local-variable 'font-lock-keywords-only) (not got-one)))))
1644 ;; font-lock-set-defaults is in fontl-hooks.el.
1647 (defun font-lock-set-defaults-1 (&optional explicit-defaults)
1648 ;; does everything that font-lock-set-defaults does except
1649 ;; enable font-lock-mode. This is called by `font-lock-mode'.
1650 ;; Note that the return value is used!
1652 (if (and font-lock-defaults-computed (not explicit-defaults))
1656 (or font-lock-keywords
1657 (let* ((defaults (or (and (not (eq t explicit-defaults))
1659 ;; in case modes decide to set
1660 ;; `font-lock-defaults' themselves,
1663 (font-lock-find-font-lock-defaults major-mode)))
1664 (keywords (font-lock-choose-keywords
1665 (nth 0 defaults) font-lock-maximum-decoration)))
1668 (setq font-lock-keywords (if (fboundp keywords)
1671 (or font-lock-keywords
1673 ;; try to look for a variable `foo-mode-font-lock-keywords',
1675 (let ((major (symbol-name major-mode))
1677 (if (stringp n) (setq n (intern-soft n)))
1682 (setq font-lock-keywords
1684 (or (funcall try (get major-mode 'font-lock-keywords))
1685 (funcall try (concat major "-font-lock-keywords"))
1686 (funcall try (and (string-match "-mode\\'" major)
1689 (match-beginning 0))
1690 "-font-lock-keywords")))
1691 'font-lock-keywords)))))
1694 (if (>= (length defaults) 3)
1695 (setq font-lock-keywords-case-fold-search (nth 2 defaults))
1697 ;; look for a property 'font-lock-keywords-case-fold-search on
1698 ;; the major-mode symbol.
1699 (let* ((nonexist (make-symbol ""))
1700 (value (get major-mode 'font-lock-keywords-case-fold-search
1702 (if (not (eq nonexist value))
1703 (setq font-lock-keywords-case-fold-search value))))
1706 (if (>= (length defaults) 2)
1707 (setq font-lock-keywords-only (nth 1 defaults))
1709 ;; cleverly examine the syntax table.
1710 (font-lock-examine-syntax-table))
1713 (if (nth 3 defaults)
1714 (let ((slist (nth 3 defaults)))
1715 (setq font-lock-syntax-table
1716 (copy-syntax-table (syntax-table)))
1718 (modify-syntax-entry (car (car slist)) (cdr (car slist))
1719 font-lock-syntax-table)
1720 (setq slist (cdr slist)))))
1724 (setq font-lock-beginning-of-syntax-function
1728 ;; defaults not specified at all, so use `beginning-of-defun'.
1729 (setq font-lock-beginning-of-syntax-function
1730 'beginning-of-defun)))))
1732 (setq font-lock-defaults-computed t)))
1735 ;;;;;;;;;;;;;;;;;;;;;; keywords ;;;;;;;;;;;;;;;;;;;;;;
1737 ;;; Various major-mode interfaces.
1738 ;;; Probably these should go in with the source of the respective major modes.
1740 ;; The defaults and keywords listed here should perhaps be moved into
1741 ;; mode-specific files.
1743 ;; For C and Lisp modes we use `beginning-of-defun', rather than nil,
1744 ;; for SYNTAX-BEGIN. Thus the calculation of the cache is usually
1745 ;; faster but not infallible, so we risk mis-fontification. --sm.
1747 (put 'c-mode 'font-lock-defaults
1748 '((c-font-lock-keywords
1749 c-font-lock-keywords-1 c-font-lock-keywords-2 c-font-lock-keywords-3)
1750 nil nil ((?_ . "w")) beginning-of-defun))
1751 (put 'c++-c-mode 'font-lock-defaults 'c-mode)
1752 (put 'elec-c-mode 'font-lock-defaults 'c-mode)
1754 (put 'c++-mode 'font-lock-defaults
1755 '((c++-font-lock-keywords
1756 c++-font-lock-keywords-1 c++-font-lock-keywords-2
1757 c++-font-lock-keywords-3)
1758 nil nil ((?_ . "w") (?~ . "w")) beginning-of-defun))
1760 (put 'java-mode 'font-lock-defaults
1761 '((java-font-lock-keywords
1762 java-font-lock-keywords-1 java-font-lock-keywords-2
1763 java-font-lock-keywords-3)
1764 nil nil ((?_ . "w")) beginning-of-defun
1765 (font-lock-mark-block-function . mark-defun)))
1767 (put 'lisp-mode 'font-lock-defaults
1768 '((lisp-font-lock-keywords
1769 lisp-font-lock-keywords-1 lisp-font-lock-keywords-2)
1771 ((?: . "w") (?- . "w") (?* . "w") (?+ . "w") (?. . "w") (?< . "w")
1772 (?> . "w") (?= . "w") (?! . "w") (?? . "w") (?$ . "w") (?% . "w")
1773 (?_ . "w") (?& . "w") (?~ . "w") (?^ . "w") (?/ . "w"))
1774 beginning-of-defun))
1775 (put 'emacs-lisp-mode 'font-lock-defaults 'lisp-mode)
1776 (put 'lisp-interaction-mode 'font-lock-defaults 'lisp-mode)
1778 (put 'scheme-mode 'font-lock-defaults
1779 '(scheme-font-lock-keywords
1781 ((?: . "w") (?- . "w") (?* . "w") (?+ . "w") (?. . "w") (?< . "w")
1782 (?> . "w") (?= . "w") (?! . "w") (?? . "w") (?$ . "w") (?% . "w")
1783 (?_ . "w") (?& . "w") (?~ . "w") (?^ . "w") (?/ . "w"))
1784 beginning-of-defun))
1785 (put 'inferior-scheme-mode 'font-lock-defaults 'scheme-mode)
1786 (put 'scheme-interaction-mode 'font-lock-defaults 'scheme-mode)
1788 (put 'tex-mode 'font-lock-defaults
1789 ;; For TeX modes we could use `backward-paragraph' for the same reason.
1790 '(tex-font-lock-keywords nil nil ((?$ . "\""))))
1791 ;; the nine billion names of TeX mode...
1792 (put 'bibtex-mode 'font-lock-defaults 'tex-mode)
1793 (put 'plain-tex-mode 'font-lock-defaults 'tex-mode)
1794 (put 'slitex-tex-mode 'font-lock-defaults 'tex-mode)
1795 (put 'SliTeX-mode 'font-lock-defaults 'tex-mode)
1796 (put 'slitex-mode 'font-lock-defaults 'tex-mode)
1797 (put 'latex-tex-mode 'font-lock-defaults 'tex-mode)
1798 (put 'LaTex-tex-mode 'font-lock-defaults 'tex-mode)
1799 (put 'latex-mode 'font-lock-defaults 'tex-mode)
1800 (put 'LaTeX-mode 'font-lock-defaults 'tex-mode)
1801 (put 'japanese-LaTeX-mode 'font-lock-defaults 'tex-mode)
1802 (put 'japanese-SliTeX-mode 'font-lock-defaults 'tex-mode)
1803 (put 'FoilTeX-mode 'font-lock-defaults 'tex-mode)
1804 (put 'LATeX-MoDe 'font-lock-defaults 'tex-mode)
1805 (put 'lATEx-mODe 'font-lock-defaults 'tex-mode)
1806 ;; ok, this is getting a bit silly ...
1807 (put 'eDOm-xETAl 'font-lock-defaults 'tex-mode)
1809 ;;; Various regexp information shared by several modes.
1810 ;;; Information specific to a single mode should go in its load library.
1812 (defconst lisp-font-lock-keywords-1
1814 ;; Anything not a variable or type declaration is fontified as a function.
1815 ;; It would be cleaner to allow preceding whitespace, but it would also be
1816 ;; about five times slower.
1817 (list (concat "^(\\(def\\("
1818 ;; Variable declarations.
1819 "\\(const\\(\\|ant\\)\\|ine-key\\(\\|-after\\)\\|var\\|custom\\)\\|"
1820 ;; Structure declarations.
1821 "\\(class\\|struct\\|type\\)\\|"
1822 ;; Everything else is a function declaration.
1823 "\\([^ \t\n\(\)]+\\)"
1825 ;; Any whitespace and declared object.
1827 "\\([^ \t\n\)]+\\)?")
1828 '(1 font-lock-keyword-face)
1829 '(8 (cond ((match-beginning 3) 'font-lock-variable-name-face)
1830 ((match-beginning 6) 'font-lock-type-face)
1831 (t 'font-lock-function-name-face))
1834 "Subdued level highlighting Lisp modes.")
1836 (defconst lisp-font-lock-keywords-2
1837 (append lisp-font-lock-keywords-1
1840 ;; Control structures. ELisp and CLisp combined.
1843 ;; '("cond" "if" "while" "let" "let*" "prog" "progn" "prog1"
1844 ;; "prog2" "progv" "catch" "throw" "save-restriction"
1845 ;; "save-excursion" "save-window-excursion"
1846 ;; "save-current-buffer" "with-current-buffer"
1847 ;; "with-temp-file" "with-temp-buffer" "with-output-to-string"
1848 ;; "with-string-as-buffer-contents"
1849 ;; "save-selected-window" "save-match-data" "unwind-protect"
1850 ;; "condition-case" "track-mouse" "autoload"
1851 ;; "eval-after-load" "eval-and-compile" "eval-when-compile"
1852 ;; "when" "unless" "do" "dolist" "dotimes" "flet" "labels"
1853 ;; "lambda" "return" "return-from"))
1857 "autoload\\|c\\(atch\\|ond\\(ition-case\\)?\\)\\|do\\(list\\|"
1858 "times\\)?\\|eval-\\(a\\(fter-load\\|nd-compile\\)\\|when-compile\\)\\|"
1859 "flet\\|if\\|l\\(a\\(bels\\|mbda\\)\\|et\\*?\\)\\|"
1860 "prog[nv12\\*]?\\|return\\(-from\\)?\\|save-\\(current-buffer\\|"
1861 "excursion\\|match-data\\|restriction\\|selected-window\\|"
1862 "window-excursion\\)\\|t\\(hrow\\|rack-mouse\\)\\|un\\(less\\|"
1863 "wind-protect\\)\\|w\\(h\\(en\\|ile\\)\\|ith-\\(current-buffer\\|"
1864 "output-to-string\\|string-as-buffer-contents\\|temp-\\(buffer\\|"
1868 ;; Feature symbols as references.
1869 '("(\\(featurep\\|provide\\|require\\)\\>[ \t']*\\(\\sw+\\)?"
1870 (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
1872 ;; Words inside \\[] tend to be for `substitute-command-keys'.
1873 '("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-reference-face prepend)
1875 ;; Words inside `' tend to be symbol names.
1876 '("`\\(\\sw\\sw+\\)'" 1 font-lock-reference-face prepend)
1878 ;; CLisp `:' keywords as references.
1879 '("\\<:\\sw+\\>" 0 font-lock-reference-face prepend)
1881 ;; ELisp and CLisp `&' keywords as types.
1882 '("\\<\\&\\(optional\\|rest\\|whole\\)\\>" . font-lock-type-face)
1884 "Gaudy level highlighting for Lisp modes.")
1886 (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
1887 "Default expressions to highlight in Lisp modes.")
1889 ;; The previous version, before replacing it with the FSF version.
1890 ;(defconst lisp-font-lock-keywords-1 (purecopy
1892 ; ;; highlight defining forms. This doesn't work too nicely for
1893 ; ;; (defun (setf foo) ...) but it does work for (defvar foo) which
1894 ; ;; is more important.
1895 ; ("^(def[-a-z]+\\s +\\([^ \t\n\)]+\\)" 1 font-lock-function-name-face)
1897 ; ;; highlight CL keywords (three clauses seems faster than one)
1898 ; ("\\s :\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1)
1899 ; ("(:\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1)
1900 ; ("':\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1)
1902 ; ;; this is highlights things like (def* (setf foo) (bar baz)), but may
1903 ; ;; be slower (I haven't really thought about it)
1904 ;; ("^(def[-a-z]+\\s +\\(\\s(\\S)*\\s)\\|\\S(\\S *\\)"
1905 ;; 1 font-lock-function-name-face)
1907 ; "For consideration as a value of `lisp-font-lock-keywords'.
1908 ;This does fairly subdued highlighting.")
1910 ;(defconst lisp-font-lock-keywords-2 (purecopy
1911 ; (append lisp-font-lock-keywords-1
1913 ; ;; Highlight control structures
1914 ; ("(\\(cond\\|if\\|when\\|unless\\|[ec]?\\(type\\)?case\\)[ \t\n]" . 1)
1915 ; ("(\\(while\\|do\\|let\\*?\\|flet\\|labels\\|prog[nv12*]?\\)[ \t\n]" . 1)
1916 ; ("(\\(do\\*\\|dotimes\\|dolist\\|loop\\)[ \t\n]" . 1)
1917 ; ("(\\(catch\\|\\throw\\|block\\|return\\|return-from\\)[ \t\n]" . 1)
1918 ; ("(\\(save-restriction\\|save-window-restriction\\)[ \t\n]" . 1)
1919 ; ("(\\(save-excursion\\|unwind-protect\\|condition-case\\)[ \t\n]" . 1)
1921 ; ;; highlight function names in emacs-lisp docstrings (in the syntax
1922 ; ;; that substitute-command-keys understands.)
1923 ; ("\\\\\\\\\\[\\([^]\\\n]+\\)]" 1 font-lock-keyword-face t)
1925 ; ;; highlight words inside `' which tend to be function names
1926 ; ("`\\([-a-zA-Z0-9_][-a-zA-Z0-9_][-a-zA-Z0-9_.]+\\)'"
1927 ; 1 font-lock-keyword-face t)
1929 ; "For consideration as a value of `lisp-font-lock-keywords'.
1931 ;This does a lot more highlighting.")
1933 (defvar scheme-font-lock-keywords
1937 ;; Declarations. Hannes Haug <hannes.haug@student.uni-tuebingen.de> says
1938 ;; this works for SOS, STklos, SCOOPS, Meroon and Tiny CLOS.
1939 (list (concat "(\\(define\\("
1941 "\\(\\|-\\(generic\\(\\|-procedure\\)\\|method\\)\\)\\|"
1942 ;; Macro names, as variable names. A bit dubious, this.
1947 ;; Any whitespace and declared object.
1950 '(1 font-lock-keyword-face)
1951 '(8 (cond ((match-beginning 3) 'font-lock-function-name-face)
1952 ((match-beginning 6) 'font-lock-variable-name-face)
1953 (t 'font-lock-type-face))
1956 ;; Control structures.
1957 ;(regexp-opt '("begin" "call-with-current-continuation" "call/cc"
1958 ; "call-with-input-file" "call-with-output-file" "case" "cond"
1959 ; "do" "else" "for-each" "if" "lambda"
1960 ; "let\\*?" "let-syntax" "letrec" "letrec-syntax"
1961 ; ;; Hannes Haug <hannes.haug@student.uni-tuebingen.de> wants:
1962 ; "and" "or" "delay"
1963 ; ;; Stefan Monnier <stefan.monnier@epfl.ch> says don't bother:
1964 ; ;;"quasiquote" "quote" "unquote" "unquote-splicing"
1965 ; "map" "syntax" "syntax-rules"))
1968 "and\\|begin\\|c\\(a\\(ll\\(-with-\\(current-continuation\\|"
1969 "input-file\\|output-file\\)\\|/cc\\)\\|se\\)\\|ond\\)\\|"
1970 "d\\(elay\\|o\\)\\|else\\|for-each\\|if\\|"
1971 "l\\(ambda\\|et\\(-syntax\\|\\*?\\|rec\\(\\|-syntax\\)\\)\\)\\|"
1972 "map\\|or\\|syntax\\(\\|-rules\\)"
1975 ;; David Fox <fox@graphics.cs.nyu.edu> for SOS/STklos class specifiers.
1976 '("\\<<\\sw+>\\>" . font-lock-type-face)
1978 ;; Scheme `:' keywords as references.
1979 '("\\<:\\sw+\\>" . font-lock-reference-face)
1981 "Default expressions to highlight in Scheme modes.")
1983 ;; The previous version, before replacing it with the FSF version.
1984 ;(defconst scheme-font-lock-keywords (purecopy
1985 ; '(("(define[ \t]+(?\\([^ \t\n\)]+\\)" 1 font-lock-function-name-face)
1986 ; ("(\\(cond\\|lambda\\|begin\\|if\\|else\\|case\\|do\\)[ \t\n]" . 1)
1987 ; ("(\\(\\|letrec\\|let\\*?\\|set!\\|and\\|or\\)[ \t\n]" . 1)
1988 ; ("(\\(quote\\|unquote\\|quasiquote\\|unquote-splicing\\)[ \t\n]" . 1)
1989 ; ("(\\(syntax\\|syntax-rules\\|define-syntax\\|let-syntax\\|letrec-syntax\\)[ \t\n]" . 1)))
1990 ; "Expressions to highlight in Scheme buffers.")
1992 (defconst c-font-lock-keywords-1 nil
1993 "Subdued level highlighting for C modes.")
1995 (defconst c-font-lock-keywords-2 nil
1996 "Medium level highlighting for C modes.")
1998 (defconst c-font-lock-keywords-3 nil
1999 "Gaudy level highlighting for C modes.")
2001 (defconst c++-font-lock-keywords-1 nil
2002 "Subdued level highlighting for C++ modes.")
2004 (defconst c++-font-lock-keywords-2 nil
2005 "Medium level highlighting for C++ modes.")
2007 (defconst c++-font-lock-keywords-3 nil
2008 "Gaudy level highlighting for C++ modes.")
2010 (defun font-lock-match-c++-style-declaration-item-and-skip-to-next (limit)
2011 ;; Match, and move over, any declaration/definition item after point.
2012 ;; The expect syntax of an item is "word" or "word::word", possibly ending
2013 ;; with optional whitespace and a "(". Everything following the item (but
2014 ;; belonging to it) is expected to by skip-able by `forward-sexp', and items
2015 ;; are expected to be separated with a "," or ";".
2016 (if (looking-at "[ \t*&]*\\(\\(?:\\sw\\|\\s_\\)+\\)\\(::\\(\\(?:\\sw\\|\\s_\\)+\\)\\)?[ \t]*\\((\\)?")
2020 ;; Restrict to the end of line, currently guaranteed to be LIMIT.
2021 (narrow-to-region (point-min) limit)
2022 (goto-char (match-end 1))
2023 ;; Move over any item value, etc., to the next item.
2024 (while (not (looking-at "[ \t]*\\([,;]\\|$\\)"))
2025 (goto-char (or (scan-sexps (point) 1) (point-max))))
2026 (goto-char (match-end 0)))
2030 ; ("break" "continue" "do" "else" "for" "if" "return" "switch" "while")
2031 "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|switch\\|while")
2033 ; ("auto" "extern" "register" "static" "typedef" "struct" "union" "enum"
2034 ; "signed" "unsigned" "short" "long" "int" "char" "float" "double"
2035 ; "void" "volatile" "const")
2036 (concat "auto\\|c\\(har\\|onst\\)\\|double\\|e\\(num\\|xtern\\)\\|"
2037 "float\\|int\\|long\\|register\\|"
2038 "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|typedef\\|"
2039 "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)")) ; 6 ()s deep.
2041 ; ("break" "continue" "do" "else" "for" "if" "return" "switch" "while"
2042 ; "asm" "catch" "delete" "new" "operator" "sizeof" "this" "throw" "try"
2043 ; "protected" "private" "public")
2044 (concat "asm\\|break\\|c\\(atch\\|ontinue\\)\\|d\\(elete\\|o\\)\\|"
2045 "else\\|for\\|if\\|new\\|"
2046 "p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|return\\|"
2047 "s\\(izeof\\|witch\\)\\|t\\(h\\(is\\|row\\)\\|ry\\)\\|while"))
2049 ; ("auto" "extern" "register" "static" "typedef" "struct" "union" "enum"
2050 ; "signed" "unsigned" "short" "long" "int" "char" "float" "double"
2051 ; "void" "volatile" "const" "class" "inline" "friend" "bool"
2052 ; "virtual" "complex" "template")
2053 (concat "auto\\|bool\\|c\\(har\\|lass\\|o\\(mplex\\|nst\\)\\)\\|"
2054 "double\\|e\\(num\\|xtern\\)\\|f\\(loat\\|riend\\)\\|"
2055 "in\\(line\\|t\\)\\|long\\|register\\|"
2056 "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|"
2057 "t\\(emplate\\|ypedef\\)\\|un\\(ion\\|signed\\)\\|"
2058 "v\\(irtual\\|o\\(id\\|latile\\)\\)")) ; 11 ()s deep.
2059 (ctoken "\\(\\sw\\|\\s_\\|[:~*&]\\)+")
2061 (setq c-font-lock-keywords-1
2064 ;; These are all anchored at the beginning of line for speed.
2066 ;; Fontify function name definitions (GNU style; without type on line).
2068 ;; In FSF this has the simpler definition of "\\sw+" for ctoken.
2069 ;; I'm not sure if ours is more correct.
2070 ;; This is a subset of the next rule, and is slower when present. --dmoore
2071 ;; (list (concat "^\\(" ctoken "\\)[ \t]*(") 1 'font-lock-function-name-face)
2073 ;; fontify the names of functions being defined.
2074 ;; FSF doesn't have this but I think it should be fast for us because
2075 ;; our regexp routines are more intelligent than FSF's about handling
2076 ;; anchored-at-newline. (When I added this hack in regex.c, it halved
2077 ;; the time to do the regexp phase of font-lock for a C file!) Not
2078 ;; including this discriminates against those who don't follow the
2079 ;; GNU coding style. --ben
2080 ;; x?x?x?y?z should always be: (x(xx?)?)?y?z --dmoore
2083 "\\(" ctoken "[ \t]+\\)" ; type specs; there can be no
2085 "\\(" ctoken "[ \t]+\\)" ; more than 3 tokens, right?
2086 "\\(" ctoken "[ \t]+\\)"
2088 "\\([*&]+[ \t]*\\)?" ; pointer
2089 "\\(" ctoken "\\)[ \t]*(") ; name
2090 10 'font-lock-function-name-face)
2092 ;; This is faster but not by much. I don't see why not.
2093 ;(list (concat "^\\(" ctoken "\\)[ \t]*(") 1 'font-lock-function-name-face)
2095 ;; Added next two; they're both jolly-good fastmatch candidates so
2096 ;; should be fast. --ben
2098 ;; Fontify structure names (in structure definition form).
2099 (list (concat "^\\(typedef[ \t]+struct\\|struct\\|static[ \t]+struct\\)"
2100 "[ \t]+\\(" ctoken "\\)[ \t]*\\(\{\\|$\\)")
2101 2 'font-lock-function-name-face)
2103 ;; Fontify case clauses. This is fast because its anchored on the left.
2104 '("case[ \t]+\\(\\(\\sw\\|\\s_\\)+\\)[ \t]+:". 1)
2106 '("\\<\\(default\\):". 1)
2107 ;; Fontify filenames in #include <...> preprocessor directives as strings.
2108 '("^#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" 1 font-lock-string-face)
2110 ;; Fontify function macro names.
2111 '("^#[ \t]*define[ \t]+\\(\\(\\sw+\\)(\\)" 2 font-lock-function-name-face)
2113 ;; Fontify symbol names in #if ... defined preprocessor directives.
2115 ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil
2116 (1 font-lock-preprocessor-face) (2 font-lock-variable-name-face nil t)))
2118 ;; Fontify symbol names in #elif ... defined preprocessor directives.
2120 ("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil
2121 (1 font-lock-preprocessor-face) (2 font-lock-variable-name-face nil t)))
2123 ;; Fontify otherwise as symbol names, and the preprocessor directive names.
2124 '("^\\(#[ \t]*[a-z]+\\)\\>[ \t]*\\(\\sw+\\)?"
2125 (1 font-lock-preprocessor-face) (2 font-lock-variable-name-face nil t))
2128 (setq c-font-lock-keywords-2
2129 (append c-font-lock-keywords-1
2132 ;; Simple regexps for speed.
2134 ;; Fontify all type specifiers.
2135 (cons (concat "\\<\\(" c-type-types "\\)\\>") 'font-lock-type-face)
2137 ;; Fontify all builtin keywords (except case, default and goto; see below).
2138 (cons (concat "\\<\\(" c-keywords "\\)\\>") 'font-lock-keyword-face)
2140 ;; Fontify case/goto keywords and targets, and case default/goto tags.
2141 '("\\<\\(case\\|goto\\)\\>[ \t]*\\([^ \t\n:;]+\\)?"
2142 (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
2143 '("^[ \t]*\\(\\sw+\\)[ \t]*:" 1 font-lock-reference-face)
2146 (setq c-font-lock-keywords-3
2147 (append c-font-lock-keywords-2
2149 ;; More complicated regexps for more complete highlighting for types.
2150 ;; We still have to fontify type specifiers individually, as C is so hairy.
2153 ;; Fontify all storage classes and type specifiers, plus their items.
2154 (list (concat "\\<\\(" c-type-types "\\)\\>"
2155 "\\([ \t*&]+\\sw+\\>\\)*")
2156 ;; Fontify each declaration item.
2157 '(font-lock-match-c++-style-declaration-item-and-skip-to-next
2158 ;; Start with point after all type specifiers.
2159 (goto-char (or (match-beginning 8) (match-end 1)))
2160 ;; Finish with point after first type specifier.
2161 (goto-char (match-end 1))
2162 ;; Fontify as a variable or function name.
2163 (1 (if (match-beginning 4)
2164 font-lock-function-name-face
2165 font-lock-variable-name-face))))
2167 ;; Fontify structures, or typedef names, plus their items.
2168 '("\\(}\\)[ \t*]*\\sw"
2169 (font-lock-match-c++-style-declaration-item-and-skip-to-next
2170 (goto-char (match-end 1)) nil
2171 (1 (if (match-beginning 4)
2172 font-lock-function-name-face
2173 font-lock-variable-name-face))))
2175 ;; Fontify anything at beginning of line as a declaration or definition.
2176 '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*"
2177 (1 font-lock-type-face)
2178 (font-lock-match-c++-style-declaration-item-and-skip-to-next
2179 (goto-char (or (match-beginning 2) (match-end 1))) nil
2180 (1 (if (match-beginning 4)
2181 font-lock-function-name-face
2182 font-lock-variable-name-face))))
2185 (setq c++-font-lock-keywords-1
2188 ;; The list `c-font-lock-keywords-1' less that for function names.
2189 ;; the simple function form regexp has been removed. --dmoore
2190 ;;(cdr c-font-lock-keywords-1)
2191 c-font-lock-keywords-1
2193 ;; Fontify function name definitions, possibly incorporating class name.
2195 '("^\\(\\sw+\\)\\(::\\(\\sw+\\)\\)?[ \t]*("
2196 (1 (if (match-beginning 2)
2198 font-lock-function-name-face))
2199 (3 (if (match-beginning 2) font-lock-function-name-face) nil t))
2202 (setq c++-font-lock-keywords-2
2203 (append c++-font-lock-keywords-1
2206 ;; The list `c-font-lock-keywords-2' for C++ plus operator overloading.
2207 (cons (concat "\\<\\(" c++-type-types "\\)\\>") 'font-lock-type-face)
2209 ;; Fontify operator function name overloading.
2210 '("\\<\\(operator\\)\\>[ \t]*\\([][)(><!=+-][][)(><!=+-]?\\)?"
2211 (1 font-lock-keyword-face) (2 font-lock-function-name-face nil t))
2213 ;; Fontify case/goto keywords and targets, and case default/goto tags.
2214 '("\\<\\(case\\|goto\\)\\>[ \t]*\\([^ \t\n:;]+\\)?"
2215 (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
2216 '("^[ \t]*\\(\\sw+\\)[ \t]*:[^:]" 1 font-lock-reference-face)
2218 ;; Fontify other builtin keywords.
2219 (cons (concat "\\<\\(" c++-keywords "\\)\\>") 'font-lock-keyword-face)
2222 (setq c++-font-lock-keywords-3
2223 (append c++-font-lock-keywords-2
2225 ;; More complicated regexps for more complete highlighting for types.
2228 ;; Fontify all storage classes and type specifiers, plus their items.
2229 (list (concat "\\<\\(" c++-type-types "\\)\\>"
2230 "\\([ \t*&]+\\sw+\\>\\)*")
2231 ;; Fontify each declaration item.
2232 '(font-lock-match-c++-style-declaration-item-and-skip-to-next
2233 ;; Start with point after all type specifiers.
2234 (goto-char (or (match-beginning 13) (match-end 1)))
2235 ;; Finish with point after first type specifier.
2236 (goto-char (match-end 1))
2237 ;; Fontify as a variable or function name.
2238 (1 (cond ((match-beginning 2) 'font-lock-type-face)
2239 ((match-beginning 4) 'font-lock-function-name-face)
2240 (t 'font-lock-variable-name-face)))
2241 (3 (if (match-beginning 4)
2242 'font-lock-function-name-face
2243 'font-lock-variable-name-face) nil t)))
2245 ;; Fontify structures, or typedef names, plus their items.
2246 '("\\(}\\)[ \t*]*\\sw"
2247 (font-lock-match-c++-style-declaration-item-and-skip-to-next
2248 (goto-char (match-end 1)) nil
2249 (1 (if (match-beginning 4)
2250 font-lock-function-name-face
2251 font-lock-variable-name-face))))
2253 ;; Fontify anything at beginning of line as a declaration or definition.
2254 '("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*"
2255 (1 font-lock-type-face)
2256 (font-lock-match-c++-style-declaration-item-and-skip-to-next
2257 (goto-char (or (match-beginning 2) (match-end 1))) nil
2258 (1 (cond ((match-beginning 2) 'font-lock-type-face)
2259 ((match-beginning 4) 'font-lock-function-name-face)
2260 (t 'font-lock-variable-name-face)))
2261 (3 (if (match-beginning 4)
2262 'font-lock-function-name-face
2263 'font-lock-variable-name-face) nil t)))
2267 (defvar c-font-lock-keywords c-font-lock-keywords-1
2268 "Default expressions to highlight in C mode.")
2270 (defvar c++-font-lock-keywords c++-font-lock-keywords-1
2271 "Default expressions to highlight in C++ mode.")
2275 ;; Java support has been written by XEmacs people, and it's apparently
2276 ;; totally divergent from the FSF. I don't know if it's better or
2277 ;; worse, so I'm leaving it in until someone convinces me the FSF
2278 ;; version is better. --hniksic
2280 (defconst java-font-lock-keywords-1 nil
2281 "For consideration as a value of `java-font-lock-keywords'.
2282 This does fairly subdued highlighting.")
2284 (defconst java-font-lock-keywords-2 nil
2285 "For consideration as a value of `java-font-lock-keywords'.
2286 This adds highlighting of types and identifier names.")
2288 (defconst java-font-lock-keywords-3 nil
2289 "For consideration as a value of `java-font-lock-keywords'.
2290 This adds highlighting of Java documentation tags, such as @see.")
2292 (defvar java-font-lock-type-regexp
2293 (concat "\\<\\(boolean\\|byte\\|char\\|double\\|float\\|int"
2294 "\\|long\\|short\\|void\\)\\>")
2295 "Regexp which should match a primitive type.")
2297 (let ((capital-letter "A-Z\300-\326\330-\337")
2298 (letter "a-zA-Z_$\300-\326\330-\366\370-\377")
2300 (defvar java-font-lock-identifier-regexp
2301 (concat "\\<\\([" letter "][" letter digit "]*\\)\\>")
2302 "Regexp which should match all Java identifiers.")
2304 (defvar java-font-lock-class-name-regexp
2305 (concat "\\<\\([" capital-letter "][" letter digit "]*\\)\\>")
2306 "Regexp which should match a class or an interface name.
2307 The name is assumed to begin with a capital letter.")
2311 (let ((java-modifier-regexp
2312 (concat "\\<\\(abstract\\|const\\|final\\|native\\|"
2313 "private\\|protected\\|public\\|"
2314 "static\\|synchronized\\|transient\\|volatile\\)\\>")))
2316 ;; Basic font-lock support:
2317 (setq java-font-lock-keywords-1
2323 "break\\|byvalue\\|"
2324 "case\\|cast\\|catch\\|class\\|continue\\|"
2325 "do\\|else\\|extends\\|"
2326 "finally\\|for\\|future\\|"
2328 "if\\|implements\\|import\\|"
2329 "instanceof\\|interface\\|"
2330 "new\\|package\\|return\\|switch\\|"
2331 "throws?\\|try\\|while\\)\\>")
2332 1 'font-lock-keyword-face)
2335 (list java-modifier-regexp 1 font-lock-type-face)
2337 ;; Special constants:
2338 '("\\<\\(this\\|super\\)\\>" (1 font-lock-reference-face))
2339 '("\\<\\(false\\|null\\|true\\)\\>" (1 font-lock-keyword-face))
2342 (list (concat "\\<class\\>\\s *" java-font-lock-identifier-regexp)
2343 1 'font-lock-function-name-face)
2345 ;; Package declarations:
2346 (list (concat "\\<\\(package\\|import\\)\\>\\s *"
2347 java-font-lock-identifier-regexp)
2348 '(2 font-lock-reference-face)
2350 "\\=\\.\\(" java-font-lock-identifier-regexp "\\)")
2351 nil nil '(1 (if (equal (char-after (match-end 0)) ?.)
2352 'font-lock-reference-face
2353 'font-lock-type-face))))
2357 "^\\s *\\(" java-modifier-regexp "\\s +\\)*"
2358 java-font-lock-class-name-regexp "\\s *\(")
2360 '(condition-case nil
2362 (goto-char (scan-sexps (- (match-end 0) 1) 1))
2363 (parse-partial-sexp (point) (point-max) nil t)
2364 (and (looking-at "\\($\\|\\<throws\\>\\|{\\)")
2365 'font-lock-function-name-face))
2366 (error 'font-lock-function-name-face))))
2369 (list (concat "\\(" java-font-lock-type-regexp "\\|"
2370 java-font-lock-class-name-regexp "\\)"
2371 "\\s *\\(\\[\\s *\\]\\s *\\)*"
2372 java-font-lock-identifier-regexp "\\s *\(")
2374 'font-lock-function-name-face)
2379 (concat "^\\s *" java-font-lock-identifier-regexp "\\s *:")
2380 '(beginning-of-line) '(end-of-line)
2381 '(1 font-lock-reference-face)))
2383 ;; `break' and continue' destination labels:
2384 (list (concat "\\<\\(break\\|continue\\)\\>\\s *"
2385 java-font-lock-identifier-regexp)
2386 2 'font-lock-reference-face)
2389 ;; In Java, any constant expression is allowed.
2390 '("\\<case\\>\\s *\\(.*\\):" 1 font-lock-reference-face)))
2392 ;; Types and declared variable names:
2393 (setq java-font-lock-keywords-2
2396 java-font-lock-keywords-1
2398 ;; Keywords followed by a type:
2399 (list (concat "\\<\\(extends\\|instanceof\\|new\\)\\>\\s *"
2400 java-font-lock-identifier-regexp)
2401 '(2 (if (equal (char-after (match-end 0)) ?.)
2402 'font-lock-reference-face 'font-lock-type-face))
2403 (list (concat "\\=\\." java-font-lock-identifier-regexp)
2404 '(goto-char (match-end 0)) nil
2405 '(1 (if (equal (char-after (match-end 0)) ?.)
2406 'font-lock-reference-face 'font-lock-type-face))))
2408 ;; Keywords followed by a type list:
2409 (list (concat "\\<\\(implements\\|throws\\)\\>\\ s*"
2410 java-font-lock-identifier-regexp)
2411 '(2 (if (equal (char-after (match-end 0)) ?.)
2412 font-lock-reference-face font-lock-type-face))
2413 (list (concat "\\=\\(\\.\\|\\s *\\(,\\)\\s *\\)"
2414 java-font-lock-identifier-regexp)
2415 '(goto-char (match-end 0)) nil
2416 '(3 (if (equal (char-after (match-end 0)) ?.)
2417 font-lock-reference-face font-lock-type-face))))
2419 ;; primitive types, can't be confused with anything else.
2420 (list java-font-lock-type-regexp
2421 '(1 font-lock-type-face)
2422 '(font-lock-match-java-declarations
2423 (goto-char (match-end 0))
2424 (goto-char (match-end 0))
2425 (0 font-lock-variable-name-face)))
2427 ;; Declarations, class types and capitalized variables:
2429 ;; Declarations are easy to recognize. Capitalized words
2430 ;; followed by a closing parenthesis are treated as casts if they
2431 ;; also are followed by an expression. Expressions beginning with
2432 ;; a unary numerical operator, e.g. +, can't be cast to an object
2435 ;; The path of a fully qualified type, e.g. java.lang.Foo, is
2436 ;; fontified in the reference face.
2438 ;; An access to a static field, e.g. System.out.println, is
2439 ;; not fontified since it can't be distinguished from the
2440 ;; usage of a capitalized variable, e.g. Foo.out.println.
2442 (list (concat java-font-lock-class-name-regexp
2443 "\\s *\\(\\[\\s *\\]\\s *\\)*"
2444 "\\(\\<\\|$\\|)\\s *\\([\(\"]\\|\\<\\)\\)")
2445 '(1 (save-match-data
2448 (match-beginning 3))
2449 (if (not (looking-at "\\<instanceof\\>"))
2450 'font-lock-type-face))))
2451 (list (concat "\\=" java-font-lock-identifier-regexp "\\.")
2453 (goto-char (match-beginning 0))
2454 (while (or (= (preceding-char) ?.)
2455 (= (char-syntax (preceding-char)) ?w))
2457 '(goto-char (match-end 0))
2458 '(1 font-lock-reference-face)
2459 '(0 nil)) ; Workaround for bug in XEmacs.
2460 '(font-lock-match-java-declarations
2461 (goto-char (match-end 1))
2462 (goto-char (match-end 0))
2463 (1 font-lock-variable-name-face))))))
2465 ;; Modifier keywords and Java doc tags
2466 (setq java-font-lock-keywords-3
2471 ;; These must come first or the Modifiers from keywords-1 will
2472 ;; catch them. We don't want to use override fontification here
2473 ;; because then these terms will be fontified within comments.
2474 ("\\<private\\>" 0 font-lock-string-face)
2475 ("\\<protected\\>" 0 font-lock-preprocessor-face)
2476 ("\\<public\\>" 0 font-lock-reference-face))
2477 java-font-lock-keywords-2
2482 '("@\\(author\\|exception\\|throws\\|deprecated\\|param\\|return\\|see\\|since\\|version\\)\\s "
2483 0 font-lock-keyword-face t)
2485 ;; Doc tag - Parameter identifiers
2486 (list (concat "@param\\s +" java-font-lock-identifier-regexp)
2487 1 'font-lock-variable-name-face t)
2489 ;; Doc tag - Exception types
2490 (list (concat "@exception\\s +"
2491 java-font-lock-identifier-regexp)
2492 '(1 (if (equal (char-after (match-end 0)) ?.)
2493 font-lock-reference-face font-lock-type-face) t)
2494 (list (concat "\\=\\." java-font-lock-identifier-regexp)
2495 '(goto-char (match-end 0)) nil
2496 '(1 (if (equal (char-after (match-end 0)) ?.)
2497 'font-lock-reference-face 'font-lock-type-face) t)))
2499 ;; Doc tag - Exception types
2500 (list (concat "@exception\\s +"
2501 java-font-lock-identifier-regexp)
2502 '(1 (if (equal (char-after (match-end 0)) ?.)
2503 font-lock-reference-face font-lock-type-face) t)
2504 (list (concat "\\=\\." java-font-lock-identifier-regexp)
2505 '(goto-char (match-end 0)) nil
2506 '(1 (if (equal (char-after (match-end 0)) ?.)
2507 'font-lock-reference-face 'font-lock-type-face) t)))
2509 ;; Doc tag - Cross-references, usually to methods
2510 '("@see\\s +\\(\\S *[^][ \t\n\r\f(){},.;:]\\)"
2511 1 font-lock-function-name-face t)
2514 '("{@link\\s +\\([^}]*\\)}"
2515 0 font-lock-keyword-face t)
2517 '("{@link\\s +\\(\\S +\\s +\\S +\\)}"
2518 1 font-lock-function-name-face t)
2523 (defvar java-font-lock-keywords java-font-lock-keywords-1
2524 "Additional expressions to highlight in Java mode.")
2526 ;; Match and move over any declaration/definition item after
2527 ;; point. Does not match items which look like a type declaration
2528 ;; (primitive types and class names, i.e. capitalized words.)
2529 ;; Should the variable name be followed by a comma, we reposition
2530 ;; the cursor to fontify more identifiers.
2531 (defun font-lock-match-java-declarations (limit)
2532 "Match and skip over variable definitions."
2533 (if (looking-at "\\s *\\(\\[\\s *\\]\\s *\\)*")
2534 (goto-char (match-end 0)))
2536 (looking-at java-font-lock-identifier-regexp)
2538 (not (string-match java-font-lock-type-regexp
2539 (buffer-substring (match-beginning 1)
2543 (goto-char (match-beginning 1))
2545 (concat java-font-lock-class-name-regexp
2546 "\\s *\\(\\[\\s *\\]\\s *\\)*\\<")))))
2550 (narrow-to-region (point-min) limit)
2551 (goto-char (match-end 0))
2552 ;; Note: Both `scan-sexps' and the second goto-char can
2553 ;; generate an error which is caught by the
2554 ;; `condition-case' expression.
2555 (while (not (looking-at "\\s *\\(\\(,\\)\\|;\\|$\\)"))
2556 (goto-char (or (scan-sexps (point) 1) (point-max))))
2557 (goto-char (match-end 2))) ; non-nil
2561 (defvar tex-font-lock-keywords
2562 ; ;; Regexps updated with help from Ulrik Dickow <dickow@nbi.dk>.
2563 ; '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
2564 ; 2 font-lock-function-name-face)
2565 ; ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
2566 ; 2 font-lock-reference-face)
2567 ; ;; It seems a bit dubious to use `bold' and `italic' faces since we might
2568 ; ;; not be able to display those fonts.
2569 ; ("{\\\\bf\\([^}]+\\)}" 1 'bold keep)
2570 ; ("{\\\\\\(em\\|it\\|sl\\)\\([^}]+\\)}" 2 'italic keep)
2571 ; ("\\\\\\([a-zA-Z@]+\\|.\\)" . font-lock-keyword-face)
2572 ; ("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face keep))
2573 ;; Rewritten and extended for LaTeX2e by Ulrik Dickow <dickow@nbi.dk>.
2574 '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
2575 2 font-lock-function-name-face)
2576 ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
2577 2 font-lock-reference-face)
2578 ("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)" 1 font-lock-function-name-face)
2579 "\\\\\\([a-zA-Z@]+\\|.\\)"
2580 ;; It seems a bit dubious to use `bold' and `italic' faces since we might
2581 ;; not be able to display those fonts.
2582 ;; LaTeX2e: \emph{This is emphasized}.
2583 ("\\\\emph{\\([^}]+\\)}" 1 'italic keep)
2584 ;; LaTeX2e: \textbf{This is bold}, \textit{...}, \textsl{...}
2585 ("\\\\text\\(\\(bf\\)\\|it\\|sl\\){\\([^}]+\\)}"
2586 3 (if (match-beginning 2) 'bold 'italic) keep)
2587 ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for good tables.
2588 ("\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)"
2589 3 (if (match-beginning 2) 'bold 'italic) keep))
2590 "Default expressions to highlight in TeX modes.")
2592 (defconst ksh-font-lock-keywords (purecopy
2594 '("\\(^\\|[^\$\\\]\\)#.*" . font-lock-comment-face)
2595 '("\\<\\(if\\|then\\|else\\|elif\\|fi\\|case\\|esac\\|for\\|do\\|done\\|foreach\\|in\\|end\\|select\\|while\\|repeat\\|time\\|function\\|until\\|exec\\|command\\|coproc\\|noglob\\|nohup\\|nocorrect\\|source\\|autoload\\|alias\\|unalias\\|export\\|set\\|echo\\|eval\\|cd\\|log\\|compctl\\)\\>" . font-lock-keyword-face)
2596 '("\\<\\[\\[.*\\]\\]\\>" . font-lock-type-face)
2597 '("\$\(.*\)" . font-lock-type-face)
2599 "Additional expressions to highlight in ksh-mode.")
2601 (defconst sh-font-lock-keywords (purecopy
2603 '("\\(^\\|[^\$\\\]\\)#.*" . font-lock-comment-face)
2604 '("\\<\\(if\\|then\\|else\\|elif\\|fi\\|case\\|esac\\|for\\|do\\|done\\|in\\|while\\|exec\\|export\\|set\\|echo\\|eval\\|cd\\)\\>" . font-lock-keyword-face)
2605 '("\\[.*\\]" . font-lock-type-face)
2606 '("`.*`" . font-lock-type-face)
2608 "Additional expressions to highlight in sh-mode.")
2611 ;; Install ourselves:
2613 (add-hook 'find-file-hooks 'font-lock-set-defaults t)
2616 (add-minor-mode 'font-lock-mode " Font")
2618 ;; Provide ourselves:
2620 (provide 'font-lock)
2622 ;;; font-lock.el ends here