(defgroup font-lock nil
"Font Lock mode text highlighting package."
:link '(custom-manual "(emacs)Font Lock")
:link '(custom-manual "(elisp)Font Lock Mode")
:group 'faces)
(defgroup font-lock-highlighting-faces nil
"Faces for highlighting text."
:prefix "font-lock-"
:group 'font-lock)
(defgroup font-lock-extra-types nil
"Extra mode-specific type names for highlighting declarations."
:group 'font-lock)
(defgroup fast-lock nil
"Font Lock support mode to cache fontification."
:link '(custom-manual "(emacs)Support Modes")
:load 'fast-lock
:group 'font-lock)
(defgroup lazy-lock nil
"Font Lock support mode to fontify lazily."
:link '(custom-manual "(emacs)Support Modes")
:load 'lazy-lock
:group 'font-lock)
(defgroup jit-lock nil
"Font Lock support mode to fontify just-in-time."
:link '(custom-manual "(emacs)Support Modes")
:version "21.1"
:load 'jit-lock
:group 'font-lock)
(defcustom font-lock-maximum-size 256000
"*Maximum size of a buffer for buffer fontification.
Only buffers less than this can be fontified when Font Lock mode is turned on.
If nil, means size is irrelevant.
If a list, each element should be a cons pair of the form (MAJOR-MODE . SIZE),
where MAJOR-MODE is a symbol or t (meaning the default). For example:
((c-mode . 256000) (c++-mode . 256000) (rmail-mode . 1048576))
means that the maximum size is 250K for buffers in C or C++ modes, one megabyte
for buffers in Rmail mode, and size is irrelevant otherwise."
:type '(choice (const :tag "none" nil)
(integer :tag "size")
(repeat :menu-tag "mode specific" :tag "mode specific"
:value ((t . nil))
(cons :tag "Instance"
(radio :tag "Mode"
(const :tag "all" t)
(symbol :tag "name"))
(radio :tag "Size"
(const :tag "none" nil)
(integer :tag "size")))))
:group 'font-lock)
(defcustom font-lock-maximum-decoration t
"*Maximum decoration level for fontification.
If nil, use the default decoration (typically the minimum available).
If t, use the maximum decoration available.
If a number, use that level of decoration (or if not available the maximum).
If a list, each element should be a cons pair of the form (MAJOR-MODE . LEVEL),
where MAJOR-MODE is a symbol or t (meaning the default). For example:
((c-mode . t) (c++-mode . 2) (t . 1))
means use the maximum decoration available for buffers in C mode, level 2
decoration for buffers in C++ mode, and level 1 decoration otherwise."
:type '(choice (const :tag "default" nil)
(const :tag "maximum" t)
(integer :tag "level" 1)
(repeat :menu-tag "mode specific" :tag "mode specific"
:value ((t . t))
(cons :tag "Instance"
(radio :tag "Mode"
(const :tag "all" t)
(symbol :tag "name"))
(radio :tag "Decoration"
(const :tag "default" nil)
(const :tag "maximum" t)
(integer :tag "level" 1)))))
:group 'font-lock)
(defcustom font-lock-verbose 0
"*If non-nil, means show status messages for buffer fontification.
If a number, only buffers greater than this size have fontification messages."
:type '(choice (const :tag "never" nil)
(other :tag "always" t)
(integer :tag "size"))
:group 'font-lock)
(defvar font-lock-comment-face 'font-lock-comment-face
"Face name to use for comments.")
(defvar font-lock-string-face 'font-lock-string-face
"Face name to use for strings.")
(defvar font-lock-doc-face 'font-lock-doc-face
"Face name to use for documentation.")
(defvar font-lock-keyword-face 'font-lock-keyword-face
"Face name to use for keywords.")
(defvar font-lock-builtin-face 'font-lock-builtin-face
"Face name to use for builtins.")
(defvar font-lock-function-name-face 'font-lock-function-name-face
"Face name to use for function names.")
(defvar font-lock-variable-name-face 'font-lock-variable-name-face
"Face name to use for variable names.")
(defvar font-lock-type-face 'font-lock-type-face
"Face name to use for type and class names.")
(defvar font-lock-constant-face 'font-lock-constant-face
"Face name to use for constant and label names.")
(defvar font-lock-warning-face 'font-lock-warning-face
"Face name to use for things that should stand out.")
(defvar font-lock-reference-face 'font-lock-constant-face
"This variable is obsolete. Use `font-lock-constant-face'.")
(defvar font-lock-keywords nil
"A list of the keywords to highlight.
Each element should have one of these forms:
MATCHER
(MATCHER . MATCH)
(MATCHER . FACENAME)
(MATCHER . HIGHLIGHT)
(MATCHER HIGHLIGHT ...)
(eval . FORM)
where MATCHER can be either the regexp to search for, or the function name to
call to make the search (called with one argument, the limit of the search) and
return non-nil if it succeeds (and set `match-data' appropriately).
MATCHER regexps can be generated via the function `regexp-opt'.
FORM is an expression, whose value should be a keyword element, evaluated when
the keyword is (first) used in a buffer. This feature can be used to provide a
keyword that can only be generated when Font Lock mode is actually turned on.
HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED.
For highlighting single items, for example each instance of the word \"foo\",
typically only MATCH-HIGHLIGHT is required.
However, if an item or (typically) items are to be highlighted following the
instance of another item (the anchor), for example each instance of the
word \"bar\" following the word \"anchor\" then MATCH-ANCHORED may be required.
MATCH-HIGHLIGHT should be of the form:
(MATCH FACENAME OVERRIDE LAXMATCH)
MATCH is the subexpression of MATCHER to be highlighted. FACENAME is an
expression whose value is the face name to use. Face default attributes
can be modified via \\[customize]. Instead of a face, FACENAME can
evaluate to a property list of the form (face VAL1 PROP2 VAL2 PROP3 VAL3 ...)
in which case all the listed text-properties will be set rather than
just `face'. In such a case, you will most likely want to put those
properties in `font-lock-extra-managed-props' or to override
`font-lock-unfontify-region-function'.
OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing fontification can
be overwritten. If `keep', only parts not already fontified are highlighted.
If `prepend' or `append', existing fontification is merged with the new, in
which the new or existing fontification, respectively, takes precedence.
If LAXMATCH is non-nil, no error is signaled if there is no MATCH in MATCHER.
For example, an element of the form highlights (if not already highlighted):
\"\\\\\\=<foo\\\\\\=>\" discrete occurrences of \"foo\" in the value of the
variable `font-lock-keyword-face'.
(\"fu\\\\(bar\\\\)\" . 1) substring \"bar\" within all occurrences of \"fubar\" in
the value of `font-lock-keyword-face'.
(\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of `fubar-face'.
(\"foo\\\\|bar\" 0 foo-bar-face t)
occurrences of either \"foo\" or \"bar\" in the value
of `foo-bar-face', even if already highlighted.
(fubar-match 1 fubar-face)
the first subexpression within all occurrences of
whatever the function `fubar-match' finds and matches
in the value of `fubar-face'.
MATCH-ANCHORED should be of the form:
(MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...)
where MATCHER is a regexp to search for or the function name to call to make
the search, as for MATCH-HIGHLIGHT above, but with one exception; see below.
PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after
the last, instance MATCH-ANCHORED's MATCHER is used. Therefore they can be
used to initialise before, and cleanup after, MATCHER is used. Typically,
PRE-MATCH-FORM is used to move to some position relative to the original
MATCHER, before starting with MATCH-ANCHORED's MATCHER. POST-MATCH-FORM might
be used to move, before resuming with MATCH-ANCHORED's parent's MATCHER.
For example, an element of the form highlights (if not already highlighted):
(\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent
discrete occurrences of \"item\" (on the same line) in the value of `item-face'.
(Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore \"item\" is
initially searched for starting from the end of the match of \"anchor\", and
searching for subsequent instance of \"anchor\" resumes from where searching
for \"item\" concluded.)
The above-mentioned exception is as follows. The limit of the MATCHER search
defaults to the end of the line after PRE-MATCH-FORM is evaluated.
However, if PRE-MATCH-FORM returns a position greater than the position after
PRE-MATCH-FORM is evaluated, that position is used as the limit of the search.
It is generally a bad idea to return a position greater than the end of the
line, i.e., cause the MATCHER search to span lines.
These regular expressions can match text which spans lines, although
it is better to avoid it if possible since updating them while editing
text is slower, and it is not guaranteed to be always correct when using
support modes like jit-lock or lazy-lock.
This variable is set by major modes via the variable `font-lock-defaults'.
Be careful when composing regexps for this list; a poorly written pattern can
dramatically slow things down!")
(defvar font-lock-defaults nil
"Defaults for Font Lock mode specified by the major mode.
Defaults should be of the form:
(KEYWORDS KEYWORDS-ONLY CASE-FOLD SYNTAX-ALIST SYNTAX-BEGIN ...)
KEYWORDS may be a symbol (a variable or function whose value is the keywords to
use for fontification) or a list of symbols. If KEYWORDS-ONLY is non-nil,
syntactic fontification (strings and comments) is not performed.
If CASE-FOLD is non-nil, the case of the keywords is ignored when fontifying.
If SYNTAX-ALIST is non-nil, it should be a list of cons pairs of the form
\(CHAR-OR-STRING . STRING) used to set the local Font Lock syntax table, for
keyword and syntactic fontification (see `modify-syntax-entry').
If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move
backwards outside any enclosing syntactic block, for syntactic fontification.
Typical values are `beginning-of-line' (i.e., the start of the line is known to
be outside a syntactic block), or `beginning-of-defun' for programming modes or
`backward-paragraph' for textual modes (i.e., the mode-dependent function is
known to move outside a syntactic block). If nil, the beginning of the buffer
is used as a position outside of a syntactic block, in the worst case.
These item elements are used by Font Lock mode to set the variables
`font-lock-keywords', `font-lock-keywords-only',
`font-lock-keywords-case-fold-search', `font-lock-syntax-table' and
`font-lock-beginning-of-syntax-function', respectively.
Further item elements are alists of the form (VARIABLE . VALUE) and are in no
particular order. Each VARIABLE is made buffer-local before set to VALUE.
Currently, appropriate variables include `font-lock-mark-block-function'.
If this is non-nil, it should be a function with no args used to mark any
enclosing block of text, for fontification via \\[font-lock-fontify-block].
Typical values are `mark-defun' for programming modes or `mark-paragraph' for
textual modes (i.e., the mode-dependent function is known to put point and mark
around a text block relevant to that mode).
Other variables include that for syntactic keyword fontification,
`font-lock-syntactic-keywords'
and those for buffer-specialised fontification functions,
`font-lock-fontify-buffer-function', `font-lock-unfontify-buffer-function',
`font-lock-fontify-region-function', `font-lock-unfontify-region-function',
`font-lock-inhibit-thing-lock' and `font-lock-maximum-size'.")
(make-variable-buffer-local 'font-lock-defaults)
(defvar font-lock-defaults-alist
(let ( (c-mode-defaults
'((c-font-lock-keywords c-font-lock-keywords-1
c-font-lock-keywords-2 c-font-lock-keywords-3)
nil nil ((?_ . "w")) beginning-of-defun
(font-lock-mark-block-function . mark-defun)))
(c++-mode-defaults
'((c++-font-lock-keywords c++-font-lock-keywords-1
c++-font-lock-keywords-2 c++-font-lock-keywords-3)
nil nil ((?_ . "w")) beginning-of-defun
(font-lock-mark-block-function . mark-defun)))
(objc-mode-defaults
'((objc-font-lock-keywords objc-font-lock-keywords-1
objc-font-lock-keywords-2 objc-font-lock-keywords-3)
nil nil ((?_ . "w") (?$ . "w")) nil
(font-lock-mark-block-function . mark-defun)))
(java-mode-defaults
'((java-font-lock-keywords java-font-lock-keywords-1
java-font-lock-keywords-2 java-font-lock-keywords-3)
nil nil ((?_ . "w") (?$ . "w")) nil
(font-lock-mark-block-function . mark-defun)))
(lisp-mode-defaults
'((lisp-font-lock-keywords
lisp-font-lock-keywords-1 lisp-font-lock-keywords-2)
nil nil (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun
(font-lock-mark-block-function . mark-defun))))
(list
(cons 'c-mode c-mode-defaults)
(cons 'c++-mode c++-mode-defaults)
(cons 'objc-mode objc-mode-defaults)
(cons 'java-mode java-mode-defaults)
(cons 'emacs-lisp-mode lisp-mode-defaults)
(cons 'lisp-mode lisp-mode-defaults)
(cons 'lisp-interaction-mode lisp-mode-defaults)))
"Alist of fall-back Font Lock defaults for major modes.
This variable should not be used any more.
Set the buffer-local `font-lock-keywords' in the major mode instead.
Each item should be a list of the form:
(MAJOR-MODE . FONT-LOCK-DEFAULTS)
where MAJOR-MODE is a symbol and FONT-LOCK-DEFAULTS is a list of default
settings. See the variable `font-lock-defaults', which takes precedence.")
(make-obsolete-variable 'font-lock-defaults-alist 'font-lock-defaults)
(defvar font-lock-keywords-alist nil
"*Alist of `font-lock-keywords' local to a `major-mode'.
This is normally set via `font-lock-add-keywords' and
`font-lock-remove-keywords'.")
(defvar font-lock-removed-keywords-alist nil
"*Alist of `font-lock-keywords' removed from `major-mode'.
This is normally set via `font-lock-add-keywords' and
`font-lock-remove-keywords'.")
(defvar font-lock-keywords-only nil
"*Non-nil means Font Lock should not fontify comments or strings.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-keywords-case-fold-search nil
"*Non-nil means the patterns in `font-lock-keywords' are case-insensitive.
This is normally set via `font-lock-defaults'.")
(make-variable-buffer-local 'font-lock-keywords-case-fold-search)
(defvar font-lock-syntactically-fontified 0
"Point up to which `font-lock-syntactic-keywords' has been applied.
If nil, this is ignored, in which case the syntactic fontification may
sometimes be slightly incorrect.")
(make-variable-buffer-local 'font-lock-syntactically-fontified)
(defvar font-lock-syntactic-face-function
(lambda (state)
(if (nth 3 state) font-lock-string-face font-lock-comment-face))
"Function to determine which face to use when fontifying syntactically.
The function is called with a single parameter (the state as returned by
`parse-partial-sexp' at the beginning of the region to highlight) and
should return a face.")
(defvar font-lock-syntactic-keywords nil
"A list of the syntactic keywords to highlight.
Can be the list or the name of a function or variable whose value is the list.
See `font-lock-keywords' for a description of the form of this list;
the differences are listed below. MATCH-HIGHLIGHT should be of the form:
(MATCH SYNTAX OVERRIDE LAXMATCH)
where SYNTAX can be a string (as taken by `modify-syntax-entry'), a syntax
table, a cons cell (as returned by `string-to-syntax') or an expression whose
value is such a form. OVERRIDE cannot be `prepend' or `append'.
For example, an element of the form highlights syntactically:
(\"\\\\$\\\\(#\\\\)\" 1 \".\")
a hash character when following a dollar character, with a SYNTAX of
\".\" (meaning punctuation syntax). Assuming that the buffer syntax table does
specify hash characters to have comment start syntax, the element will only
highlight hash characters that do not follow dollar characters as comments
syntactically.
(\"\\\\('\\\\).\\\\('\\\\)\"
(1 \"\\\"\")
(2 \"\\\"\"))
both single quotes which surround a single character, with a SYNTAX of
\"\\\"\" (meaning string quote syntax). Assuming that the buffer syntax table
does not specify single quotes to have quote syntax, the element will only
highlight single quotes of the form 'c' as strings syntactically.
Other forms, such as foo'bar or 'fubar', will not be highlighted as strings.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-syntax-table nil
"Non-nil means use this syntax table for fontifying.
If this is nil, the major mode's syntax table is used.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-beginning-of-syntax-function nil
"*Non-nil means use this function to move back outside of a syntactic block.
When called with no args it should leave point at the beginning of any
enclosing syntactic block.
If this is nil, the beginning of the buffer is used (in the worst case).
This is normally set via `font-lock-defaults'.")
(defvar font-lock-mark-block-function nil
"*Non-nil means use this function to mark a block of text.
When called with no args it should leave point at the beginning of any
enclosing textual block and mark at the end.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-fontify-buffer-function 'font-lock-default-fontify-buffer
"Function to use for fontifying the buffer.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-unfontify-buffer-function 'font-lock-default-unfontify-buffer
"Function to use for unfontifying the buffer.
This is used when turning off Font Lock mode.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-fontify-region-function 'font-lock-default-fontify-region
"Function to use for fontifying a region.
It should take two args, the beginning and end of the region, and an optional
third arg VERBOSE. If non-nil, the function should print status messages.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-unfontify-region-function 'font-lock-default-unfontify-region
"Function to use for unfontifying a region.
It should take two args, the beginning and end of the region.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-inhibit-thing-lock nil
"List of Font Lock mode related modes that should not be turned on.
Currently, valid mode names are `fast-lock-mode', `jit-lock-mode' and
`lazy-lock-mode'. This is normally set via `font-lock-defaults'.")
(defvar font-lock-multiline nil
"Whether font-lock should cater to multiline keywords.
If nil, don't try to handle multiline patterns.
If t, always handle multiline patterns.
If `undecided', don't try to handle multiline patterns until you see one.
Major/minor modes can set this variable if they know which option applies.")
(defvar font-lock-fontified nil)
(eval-when-compile
(require 'cl)
(defmacro save-buffer-state (varlist &rest body)
"Bind variables according to VARLIST and eval BODY restoring buffer state."
`(let* ,(append varlist
'((modified (buffer-modified-p)) (buffer-undo-list t)
(inhibit-read-only t) (inhibit-point-motion-hooks t)
(inhibit-modification-hooks t)
deactivate-mark buffer-file-name buffer-file-truename))
,@body
(when (and (not modified) (buffer-modified-p))
(set-buffer-modified-p nil))))
(put 'save-buffer-state 'lisp-indent-function 1)
(def-edebug-spec save-buffer-state let)
(defvar font-lock-face-attributes))
(define-minor-mode font-lock-mode
"Toggle Font Lock mode.
With arg, turn Font Lock mode off if and only if arg is a non-positive
number; if arg is nil, toggle Font Lock mode; anything else turns Font
Lock on.
\(Font Lock is also known as \"syntax highlighting\".)
When Font Lock mode is enabled, text is fontified as you type it:
- Comments are displayed in `font-lock-comment-face';
- Strings are displayed in `font-lock-string-face';
- Certain other expressions are displayed in other faces according to the
value of the variable `font-lock-keywords'.
To customize the faces (colors, fonts, etc.) used by Font Lock for
fontifying different parts of buffer text, use \\[customize-face].
You can enable Font Lock mode in any major mode automatically by turning on in
the major mode's hook. For example, put in your ~/.emacs:
(add-hook 'c-mode-hook 'turn-on-font-lock)
Alternatively, you can use Global Font Lock mode to automagically turn on Font
Lock mode in buffers whose major mode supports it and whose major mode is one
of `font-lock-global-modes'. For example, put in your ~/.emacs:
(global-font-lock-mode t)
There are a number of support modes that may be used to speed up Font Lock mode
in various ways, specified via the variable `font-lock-support-mode'. Where
major modes support different levels of fontification, you can use the variable
`font-lock-maximum-decoration' to specify which level you generally prefer.
When you turn Font Lock mode on/off the buffer is fontified/defontified, though
fontification occurs only if the buffer is less than `font-lock-maximum-size'.
For example, to specify that Font Lock mode use use Lazy Lock mode as a support
mode and use maximum levels of fontification, put in your ~/.emacs:
(setq font-lock-support-mode 'lazy-lock-mode)
(setq font-lock-maximum-decoration t)
To add your own highlighting for some major mode, and modify the highlighting
selected automatically via the variable `font-lock-maximum-decoration', you can
use `font-lock-add-keywords'.
To fontify a buffer, without turning on Font Lock mode and regardless of buffer
size, you can use \\[font-lock-fontify-buffer].
To fontify a block (the function or paragraph containing point, or a number of
lines around point), perhaps because modification on the current line caused
syntactic change on other lines, you can use \\[font-lock-fontify-block].
See the variable `font-lock-defaults-alist' for the Font Lock mode default
settings. You can set your own default settings for some mode, by setting a
buffer local value for `font-lock-defaults', via its mode hook."
nil nil nil
(when (or noninteractive (eq (aref (buffer-name) 0) ?\ ))
(setq font-lock-mode nil))
(when font-lock-mode
(add-hook 'after-change-functions 'font-lock-after-change-function nil t)
(font-lock-set-defaults)
(font-lock-turn-on-thing-lock)
(let ((max-size (font-lock-value-in-major-mode font-lock-maximum-size)))
(cond (font-lock-fontified
nil)
((or (null max-size) (> max-size (buffer-size)))
(font-lock-fontify-buffer))
(font-lock-verbose
(message "Fontifying %s...buffer size greater than font-lock-maximum-size"
(buffer-name))))))
(unless font-lock-mode
(remove-hook 'after-change-functions 'font-lock-after-change-function t)
(font-lock-unfontify-buffer)
(font-lock-turn-off-thing-lock)
(font-lock-unset-defaults)))
(defun turn-on-font-lock ()
"Turn on Font Lock mode (only if the terminal can display it)."
(unless font-lock-mode
(font-lock-mode)))
(defun font-lock-add-keywords (mode keywords &optional append)
"Add highlighting KEYWORDS for MODE.
MODE should be a symbol, the major mode command name, such as `c-mode'
or nil. If nil, highlighting keywords are added for the current buffer.
KEYWORDS should be a list; see the variable `font-lock-keywords'.
By default they are added at the beginning of the current highlighting list.
If optional argument APPEND is `set', they are used to replace the current
highlighting list. If APPEND is any other non-nil value, they are added at the
end of the current highlighting list.
For example:
(font-lock-add-keywords 'c-mode
'((\"\\\\\\=<\\\\(FIXME\\\\):\" 1 font-lock-warning-face prepend)
(\"\\\\\\=<\\\\(and\\\\|or\\\\|not\\\\)\\\\\\=>\" . font-lock-keyword-face)))
adds two fontification patterns for C mode, to fontify `FIXME:' words, even in
comments, and to fontify `and', `or' and `not' words as keywords.
When used from an elisp package (such as a minor mode), it is recommended
to use nil for MODE (and place the call in a loop or on a hook) to avoid
subtle problems due to details of the implementation.
Note that some modes have specialised support for additional patterns, e.g.,
see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types',
`objc-font-lock-extra-types' and `java-font-lock-extra-types'."
(cond (mode
(let ((spec (cons keywords append)) cell)
(if (setq cell (assq mode font-lock-keywords-alist))
(if (eq append 'set)
(setcdr cell (list spec))
(setcdr cell (append (cdr cell) (list spec))))
(push (list mode spec) font-lock-keywords-alist)))
(font-lock-update-removed-keyword-alist mode keywords append))
(t
(font-lock-set-defaults)
(if (eq append 'set)
(setq font-lock-keywords keywords)
(font-lock-remove-keywords nil keywords) (let ((old (if (eq (car-safe font-lock-keywords) t)
(cdr font-lock-keywords)
font-lock-keywords)))
(setq font-lock-keywords (if append
(append old keywords)
(append keywords old))))))))
(defun font-lock-update-removed-keyword-alist (mode keywords append)
(let ((cell (assq mode font-lock-removed-keywords-alist)))
(if cell
(if (eq append 'set)
(setq font-lock-removed-keywords-alist
(delq cell font-lock-removed-keywords-alist))
(dolist (kword keywords)
(setcdr cell (delete kword (cdr cell))))
(if (null (cdr cell))
(setq font-lock-removed-keywords-alist
(delq cell font-lock-removed-keywords-alist)))))))
(defun font-lock-remove-keywords (mode keywords)
"Remove highlighting KEYWORDS for MODE.
MODE should be a symbol, the major mode command name, such as `c-mode'
or nil. If nil, highlighting keywords are removed for the current buffer.
When used from an elisp package (such as a minor mode), it is recommended
to use nil for MODE (and place the call in a loop or on a hook) to avoid
subtle problems due to details of the implementation."
(cond (mode
(dolist (keyword keywords)
(let ((top-cell (assq mode font-lock-keywords-alist)))
(when top-cell
(dolist (keyword-list-append-pair (cdr top-cell))
(setcar keyword-list-append-pair
(delete keyword (car keyword-list-append-pair))))
(let ((cell top-cell))
(while (cdr cell)
(if (and (null (car (car (cdr cell))))
(not (eq (cdr (car (cdr cell))) 'set)))
(setcdr cell (cdr (cdr cell)))
(setq cell (cdr cell)))))
(if (null (cdr top-cell))
(setq font-lock-keywords-alist
(delq top-cell font-lock-keywords-alist))))
(let ((cell (assq mode font-lock-removed-keywords-alist)))
(if cell
(unless (member keyword (cdr cell))
(nconc cell (list keyword)))
(push (cons mode (list keyword))
font-lock-removed-keywords-alist))))))
(t
(font-lock-set-defaults)
(setq font-lock-keywords (copy-sequence font-lock-keywords))
(dolist (keyword keywords)
(setq font-lock-keywords
(delete keyword
(delete (font-lock-compile-keyword keyword)
font-lock-keywords)))))))
(defcustom font-lock-global-modes t
"*Modes for which Font Lock mode is automagically turned on.
Global Font Lock mode is controlled by the command `global-font-lock-mode'.
If nil, means no modes have Font Lock mode automatically turned on.
If t, all modes that support Font Lock mode have it automatically turned on.
If a list, it should be a list of `major-mode' symbol names for which Font Lock
mode should be automatically turned on. The sense of the list is negated if it
begins with `not'. For example:
(c-mode c++-mode)
means that Font Lock mode is turned on for buffers in C and C++ modes only."
:type '(choice (const :tag "none" nil)
(const :tag "all" t)
(set :menu-tag "mode specific" :tag "modes"
:value (not)
(const :tag "Except" not)
(repeat :inline t (symbol :tag "mode"))))
:group 'font-lock)
(defun turn-on-font-lock-if-enabled ()
(when (and (or font-lock-defaults
(assq major-mode font-lock-defaults-alist))
(or (eq font-lock-global-modes t)
(if (eq (car-safe font-lock-global-modes) 'not)
(not (memq major-mode (cdr font-lock-global-modes)))
(memq major-mode font-lock-global-modes))))
(let (inhibit-quit)
(turn-on-font-lock))))
(easy-mmode-define-global-mode
global-font-lock-mode font-lock-mode turn-on-font-lock-if-enabled
:extra-args (dummy))
(defcustom font-lock-support-mode 'jit-lock-mode
"*Support mode for Font Lock mode.
Support modes speed up Font Lock mode by being choosy about when fontification
occurs. Known support modes are Fast Lock mode (symbol `fast-lock-mode'),
Lazy Lock mode (symbol `lazy-lock-mode'), and Just-in-time Lock mode (symbol
`jit-lock-mode'. See those modes for more info.
If nil, means support for Font Lock mode is never performed.
If a symbol, use that support mode.
If a list, each element should be of the form (MAJOR-MODE . SUPPORT-MODE),
where MAJOR-MODE is a symbol or t (meaning the default). For example:
((c-mode . fast-lock-mode) (c++-mode . fast-lock-mode) (t . lazy-lock-mode))
means that Fast Lock mode is used to support Font Lock mode for buffers in C or
C++ modes, and Lazy Lock mode is used to support Font Lock mode otherwise.
The value of this variable is used when Font Lock mode is turned on."
:type '(choice (const :tag "none" nil)
(const :tag "fast lock" fast-lock-mode)
(const :tag "lazy lock" lazy-lock-mode)
(const :tag "jit lock" jit-lock-mode)
(repeat :menu-tag "mode specific" :tag "mode specific"
:value ((t . jit-lock-mode))
(cons :tag "Instance"
(radio :tag "Mode"
(const :tag "all" t)
(symbol :tag "name"))
(radio :tag "Support"
(const :tag "none" nil)
(const :tag "fast lock" fast-lock-mode)
(const :tag "lazy lock" lazy-lock-mode)
(const :tag "JIT lock" jit-lock-mode)))
))
:version "21.1"
:group 'font-lock)
(defvar fast-lock-mode nil)
(defvar lazy-lock-mode nil)
(defvar jit-lock-mode nil)
(defun font-lock-turn-on-thing-lock ()
(let ((thing-mode (font-lock-value-in-major-mode font-lock-support-mode)))
(cond ((eq thing-mode 'fast-lock-mode)
(fast-lock-mode t))
((eq thing-mode 'lazy-lock-mode)
(lazy-lock-mode t))
((eq thing-mode 'jit-lock-mode)
(remove-hook 'after-change-functions
'font-lock-after-change-function t)
(set (make-local-variable 'font-lock-fontify-buffer-function)
'jit-lock-refontify)
(set (make-local-variable 'font-lock-fontified) t)
(jit-lock-register 'font-lock-fontify-region
(not font-lock-keywords-only))))))
(defun font-lock-turn-off-thing-lock ()
(cond (fast-lock-mode
(fast-lock-mode -1))
(jit-lock-mode
(jit-lock-unregister 'font-lock-fontify-region)
(kill-local-variable 'font-lock-fontify-buffer-function))
(lazy-lock-mode
(lazy-lock-mode -1))))
(defun font-lock-after-fontify-buffer ()
(cond (fast-lock-mode
(fast-lock-after-fontify-buffer))
(lazy-lock-mode
(lazy-lock-after-fontify-buffer))))
(defun font-lock-after-unfontify-buffer ()
(cond (fast-lock-mode
(fast-lock-after-unfontify-buffer))
(lazy-lock-mode
(lazy-lock-after-unfontify-buffer))))
(defun font-lock-fontify-buffer ()
"Fontify the current buffer the way the function `font-lock-mode' would."
(interactive)
(let ((font-lock-verbose (or font-lock-verbose (interactive-p))))
(funcall font-lock-fontify-buffer-function)))
(defun font-lock-unfontify-buffer ()
(funcall font-lock-unfontify-buffer-function))
(defun font-lock-fontify-region (beg end &optional loudly)
(funcall font-lock-fontify-region-function beg end loudly))
(defun font-lock-unfontify-region (beg end)
(funcall font-lock-unfontify-region-function beg end))
(defun font-lock-default-fontify-buffer ()
(let ((verbose (if (numberp font-lock-verbose)
(> (buffer-size) font-lock-verbose)
font-lock-verbose)))
(with-temp-message
(when verbose
(format "Fontifying %s..." (buffer-name)))
(unless font-lock-mode
(font-lock-set-defaults))
(save-restriction
(widen)
(condition-case nil
(save-excursion
(save-match-data
(font-lock-fontify-region (point-min) (point-max) verbose)
(font-lock-after-fontify-buffer)
(setq font-lock-fontified t)))
(quit (font-lock-unfontify-buffer))))
(unless font-lock-mode
(font-lock-unset-defaults)))))
(defun font-lock-default-unfontify-buffer ()
(save-restriction
(widen)
(font-lock-unfontify-region (point-min) (point-max))
(font-lock-after-unfontify-buffer)
(setq font-lock-fontified nil)))
(defun font-lock-default-fontify-region (beg end loudly)
(save-buffer-state
((parse-sexp-lookup-properties font-lock-syntactic-keywords)
(old-syntax-table (syntax-table)))
(unwind-protect
(save-restriction
(widen)
(when font-lock-syntax-table
(set-syntax-table font-lock-syntax-table))
(when (and font-lock-multiline
(> beg (point-min))
(get-text-property (1- beg) 'font-lock-multiline))
(setq beg (or (previous-single-property-change
beg 'font-lock-multiline)
(point-min)))
(goto-char beg)
(setq beg (line-beginning-position)))
(when font-lock-multiline
(setq end (or (text-property-any end (point-max)
'font-lock-multiline nil)
(point-max))))
(goto-char end)
(setq end (line-beginning-position 2))
(font-lock-unfontify-region beg end)
(when font-lock-syntactic-keywords
(font-lock-fontify-syntactic-keywords-region beg end))
(unless font-lock-keywords-only
(font-lock-fontify-syntactically-region beg end loudly))
(font-lock-fontify-keywords-region beg end loudly))
(set-syntax-table old-syntax-table))))
(defun font-lock-default-unfontify-region (beg end)
(save-buffer-state nil
(remove-text-properties beg end
(if font-lock-syntactic-keywords
'(face nil syntax-table nil font-lock-multiline nil)
'(face nil font-lock-multiline nil)))))
(defun font-lock-after-change-function (beg end old-len)
(let ((inhibit-point-motion-hooks t))
(save-excursion
(save-match-data
(font-lock-fontify-region
(progn (goto-char beg) (beginning-of-line) (point))
(progn (goto-char end) (forward-line 1) (point)))))))
(defun font-lock-fontify-block (&optional arg)
"Fontify some lines the way `font-lock-fontify-buffer' would.
The lines could be a function or paragraph, or a specified number of lines.
If ARG is given, fontify that many lines before and after point, or 16 lines if
no ARG is given and `font-lock-mark-block-function' is nil.
If `font-lock-mark-block-function' non-nil and no ARG is given, it is used to
delimit the region to fontify."
(interactive "P")
(let ((inhibit-point-motion-hooks t) font-lock-beginning-of-syntax-function
deactivate-mark)
(if (not font-lock-mode) (font-lock-set-defaults))
(save-excursion
(save-match-data
(condition-case error-data
(if (or arg (not font-lock-mark-block-function))
(let ((lines (if arg (prefix-numeric-value arg) 16)))
(font-lock-fontify-region
(save-excursion (forward-line (- lines)) (point))
(save-excursion (forward-line lines) (point))))
(funcall font-lock-mark-block-function)
(font-lock-fontify-region (point) (mark)))
((error quit) (message "Fontifying block...%s" error-data)))))))
(define-key facemenu-keymap "\M-g" 'font-lock-fontify-block)
(defun font-lock-prepend-text-property (start end prop value &optional object)
"Prepend to one property of the text from START to END.
Arguments PROP and VALUE specify the property and value to prepend to the value
already in place. The resulting property values are always lists.
Optional argument OBJECT is the string or buffer containing the text."
(let ((val (if (listp value) value (list value))) next prev)
(while (/= start end)
(setq next (next-single-property-change start prop object end)
prev (get-text-property start prop object))
(put-text-property start next prop
(append val (if (listp prev) prev (list prev)))
object)
(setq start next))))
(defun font-lock-append-text-property (start end prop value &optional object)
"Append to one property of the text from START to END.
Arguments PROP and VALUE specify the property and value to append to the value
already in place. The resulting property values are always lists.
Optional argument OBJECT is the string or buffer containing the text."
(let ((val (if (listp value) value (list value))) next prev)
(while (/= start end)
(setq next (next-single-property-change start prop object end)
prev (get-text-property start prop object))
(put-text-property start next prop
(append (if (listp prev) prev (list prev)) val)
object)
(setq start next))))
(defun font-lock-fillin-text-property (start end prop value &optional object)
"Fill in one property of the text from START to END.
Arguments PROP and VALUE specify the property and value to put where none are
already in place. Therefore existing property values are not overwritten.
Optional argument OBJECT is the string or buffer containing the text."
(let ((start (text-property-any start end prop nil object)) next)
(while start
(setq next (next-single-property-change start prop object end))
(put-text-property start next prop value object)
(setq start (text-property-any next end prop nil object)))))
(defun font-lock-apply-syntactic-highlight (highlight)
"Apply HIGHLIGHT following a match.
HIGHLIGHT should be of the form MATCH-HIGHLIGHT,
see `font-lock-syntactic-keywords'."
(let* ((match (nth 0 highlight))
(start (match-beginning match)) (end (match-end match))
(value (nth 1 highlight))
(override (nth 2 highlight)))
(when (and (consp value) (not (numberp (car value))))
(setq value (eval value)))
(when (stringp value) (setq value (string-to-syntax value)))
(cond ((not start)
(or (nth 3 highlight)
(error "No match %d in highlight %S" match highlight)))
((not override)
(or (text-property-not-all start end 'syntax-table nil)
(put-text-property start end 'syntax-table value)))
((eq override t)
(put-text-property start end 'syntax-table value))
((eq override 'keep)
(font-lock-fillin-text-property start end 'syntax-table value)))))
(defun font-lock-fontify-syntactic-anchored-keywords (keywords limit)
"Fontify according to KEYWORDS until LIMIT.
KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords',
LIMIT can be modified by the value of its PRE-MATCH-FORM."
(let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights
(pre-match-value (eval (nth 1 keywords))))
(if (and (numberp pre-match-value) (> pre-match-value (point)))
(setq limit pre-match-value)
(setq limit (line-end-position)))
(save-match-data
(while (if (stringp matcher)
(re-search-forward matcher limit t)
(funcall matcher limit))
(setq highlights lowdarks)
(while highlights
(font-lock-apply-syntactic-highlight (car highlights))
(setq highlights (cdr highlights)))))
(eval (nth 2 keywords))))
(defun font-lock-fontify-syntactic-keywords-region (start end)
"Fontify according to `font-lock-syntactic-keywords' between START and END.
START should be at the beginning of a line."
(when (and font-lock-syntactically-fontified
(< font-lock-syntactically-fontified start))
(setq start (max font-lock-syntactically-fontified (point-min)))
(setq font-lock-syntactically-fontified end))
(when (symbolp font-lock-syntactic-keywords)
(setq font-lock-syntactic-keywords (font-lock-eval-keywords
font-lock-syntactic-keywords)))
(unless (eq (car font-lock-syntactic-keywords) t)
(setq font-lock-syntactic-keywords (font-lock-compile-keywords
font-lock-syntactic-keywords)))
(let ((case-fold-search font-lock-keywords-case-fold-search)
(keywords (cdr font-lock-syntactic-keywords))
keyword matcher highlights)
(while keywords
(setq keyword (car keywords) matcher (car keyword))
(goto-char start)
(while (if (stringp matcher)
(re-search-forward matcher end t)
(funcall matcher end))
(setq highlights (cdr keyword))
(while highlights
(if (numberp (car (car highlights)))
(font-lock-apply-syntactic-highlight (car highlights))
(font-lock-fontify-syntactic-anchored-keywords (car highlights)
end))
(setq highlights (cdr highlights))))
(setq keywords (cdr keywords)))))
(defvar font-lock-cache-state nil)
(defvar font-lock-cache-position nil)
(defun font-lock-fontify-syntactically-region (start end &optional loudly)
"Put proper face on each string and comment between START and END.
START should be at the beginning of a line."
(let ((cache (marker-position font-lock-cache-position))
state face beg)
(if loudly (message "Fontifying %s... (syntactically...)" (buffer-name)))
(goto-char start)
(if (eq start cache)
(setq state font-lock-cache-state)
(if (null font-lock-beginning-of-syntax-function)
(if (or (null cache) (< start cache))
(setq state (parse-partial-sexp (point-min) start))
(setq state (parse-partial-sexp cache start nil nil
font-lock-cache-state)))
(funcall font-lock-beginning-of-syntax-function)
(setq state (parse-partial-sexp (point) start)))
(setq font-lock-cache-state state)
(set-marker font-lock-cache-position start))
(when (or (nth 3 state) (nth 4 state))
(setq face (funcall font-lock-syntactic-face-function state) beg (point))
(setq state (parse-partial-sexp (point) end nil nil state 'syntax-table))
(put-text-property beg (point) 'face face))
(while (and (< (point) end)
(progn
(setq state (parse-partial-sexp (point) end nil nil state
'syntax-table))
(or (nth 3 state) (nth 4 state))))
(setq face (funcall font-lock-syntactic-face-function state)
beg (nth 8 state))
(setq state (parse-partial-sexp (point) end nil nil state 'syntax-table))
(put-text-property beg (point) 'face face))))
(defsubst font-lock-apply-highlight (highlight)
"Apply HIGHLIGHT following a match.
HIGHLIGHT should be of the form MATCH-HIGHLIGHT, see `font-lock-keywords'."
(let* ((match (nth 0 highlight))
(start (match-beginning match)) (end (match-end match))
(override (nth 2 highlight)))
(cond ((not start)
(or (nth 3 highlight)
(error "No match %d in highlight %S" match highlight)))
((not override)
(or (text-property-not-all start end 'face nil)
(put-text-property start end 'face (eval (nth 1 highlight)))))
((eq override t)
(put-text-property start end 'face (eval (nth 1 highlight))))
((eq override 'prepend)
(font-lock-prepend-text-property start end 'face (eval (nth 1 highlight))))
((eq override 'append)
(font-lock-append-text-property start end 'face (eval (nth 1 highlight))))
((eq override 'keep)
(font-lock-fillin-text-property start end 'face (eval (nth 1 highlight)))))))
(defsubst font-lock-fontify-anchored-keywords (keywords limit)
"Fontify according to KEYWORDS until LIMIT.
KEYWORDS should be of the form MATCH-ANCHORED, see `font-lock-keywords',
LIMIT can be modified by the value of its PRE-MATCH-FORM."
(let ((matcher (nth 0 keywords)) (lowdarks (nthcdr 3 keywords)) highlights
(lead-start (match-beginning 0))
(pre-match-value (eval (nth 1 keywords))))
(if (not (and (numberp pre-match-value) (> pre-match-value (point))))
(setq limit (line-end-position))
(setq limit pre-match-value)
(when (and font-lock-multiline (>= limit (line-beginning-position 2)))
(put-text-property (if (= limit (line-beginning-position 2))
(1- limit)
(min lead-start (point)))
limit
'font-lock-multiline t)))
(save-match-data
(while (and (< (point) limit)
(if (stringp matcher)
(re-search-forward matcher limit t)
(funcall matcher limit)))
(setq highlights lowdarks)
(while highlights
(font-lock-apply-highlight (car highlights))
(setq highlights (cdr highlights)))))
(eval (nth 2 keywords))))
(defun font-lock-fontify-keywords-region (start end &optional loudly)
"Fontify according to `font-lock-keywords' between START and END.
START should be at the beginning of a line."
(unless (eq (car font-lock-keywords) t)
(setq font-lock-keywords (font-lock-compile-keywords font-lock-keywords)))
(let ((case-fold-search font-lock-keywords-case-fold-search)
(keywords (cdr font-lock-keywords))
(bufname (buffer-name)) (count 0)
keyword matcher highlights)
(while keywords
(if loudly (message "Fontifying %s... (regexps..%s)" bufname
(make-string (incf count) ?.)))
(setq keyword (car keywords) matcher (car keyword))
(goto-char start)
(while (and (< (point) end)
(if (stringp matcher)
(re-search-forward matcher end t)
(funcall matcher end)))
(when (and font-lock-multiline
(>= (point)
(save-excursion (goto-char (match-beginning 0))
(forward-line 1) (point))))
(put-text-property (if (= (point)
(save-excursion
(goto-char (match-beginning 0))
(forward-line 1) (point)))
(1- (point))
(match-beginning 0))
(point)
'font-lock-multiline t))
(setq highlights (cdr keyword))
(while highlights
(if (numberp (car (car highlights)))
(font-lock-apply-highlight (car highlights))
(font-lock-fontify-anchored-keywords (car highlights) end))
(setq highlights (cdr highlights))))
(setq keywords (cdr keywords)))))
(defun font-lock-compile-keywords (keywords)
"Compile KEYWORDS into the form (t KEYWORD ...).
Here KEYWORD is of the form (MATCHER HIGHLIGHT ...) as shown in the
`font-lock-keywords' doc string."
(if (eq (car-safe keywords) t)
keywords
(cons t (mapcar 'font-lock-compile-keyword keywords))))
(defun font-lock-compile-keyword (keyword)
(cond ((nlistp keyword) (list keyword '(0 font-lock-keyword-face)))
((eq (car keyword) 'eval) (font-lock-compile-keyword (eval (cdr keyword))))
((eq (car-safe (cdr keyword)) 'quote) (if (symbolp (nth 2 keyword))
(list (car keyword) (list 0 (cdr keyword)))
(font-lock-compile-keyword (cons (car keyword) (nth 2 keyword)))))
((numberp (cdr keyword)) (list (car keyword) (list (cdr keyword) 'font-lock-keyword-face)))
((symbolp (cdr keyword)) (list (car keyword) (list 0 (cdr keyword))))
((nlistp (nth 1 keyword)) (list (car keyword) (cdr keyword)))
(t keyword)))
(defun font-lock-eval-keywords (keywords)
"Evalulate KEYWORDS if a function (funcall) or variable (eval) name."
(if (listp keywords)
keywords
(font-lock-eval-keywords (if (fboundp keywords)
(funcall keywords)
(eval keywords)))))
(defun font-lock-value-in-major-mode (alist)
"Return value in ALIST for `major-mode', or ALIST if it is not an alist.
Structure is ((MAJOR-MODE . VALUE) ...) where MAJOR-MODE may be t."
(if (consp alist)
(cdr (or (assq major-mode alist) (assq t alist)))
alist))
(defun font-lock-choose-keywords (keywords level)
"Return LEVELth element of KEYWORDS.
A LEVEL of nil is equal to a LEVEL of 0, a LEVEL of t is equal to
\(1- (length KEYWORDS))."
(cond ((not (and (listp keywords) (symbolp (car keywords))))
keywords)
((numberp level)
(or (nth level keywords) (car (reverse keywords))))
((eq level t)
(car (reverse keywords)))
(t
(car keywords))))
(defvar font-lock-set-defaults nil)
(defun font-lock-set-defaults ()
"Set fontification defaults appropriately for this mode.
Sets various variables using `font-lock-defaults' (or, if nil, using
`font-lock-defaults-alist') and `font-lock-maximum-decoration'."
(unless font-lock-set-defaults
(set (make-local-variable 'font-lock-set-defaults) t)
(set (make-local-variable 'font-lock-cache-state) nil)
(set (make-local-variable 'font-lock-cache-position) (make-marker))
(make-local-variable 'font-lock-fontified)
(make-local-variable 'font-lock-multiline)
(let* ((defaults (or font-lock-defaults
(cdr (assq major-mode font-lock-defaults-alist))))
(keywords
(font-lock-choose-keywords (nth 0 defaults)
(font-lock-value-in-major-mode font-lock-maximum-decoration)))
(local (cdr (assq major-mode font-lock-keywords-alist)))
(removed-keywords
(cdr-safe (assq major-mode font-lock-removed-keywords-alist))))
(set (make-local-variable 'font-lock-keywords)
(font-lock-compile-keywords (font-lock-eval-keywords keywords)))
(while local
(font-lock-add-keywords nil (car (car local)) (cdr (car local)))
(setq local (cdr local)))
(when removed-keywords
(font-lock-remove-keywords nil removed-keywords))
(when (nth 1 defaults)
(set (make-local-variable 'font-lock-keywords-only) t))
(when (nth 2 defaults)
(set (make-local-variable 'font-lock-keywords-case-fold-search) t))
(when (nth 3 defaults)
(let ((slist (nth 3 defaults)))
(set (make-local-variable 'font-lock-syntax-table)
(copy-syntax-table (syntax-table)))
(while slist
(let ((chars (if (numberp (car (car slist)))
(list (car (car slist)))
(mapcar 'identity (car (car slist)))))
(syntax (cdr (car slist))))
(while chars
(modify-syntax-entry (car chars) syntax font-lock-syntax-table)
(setq chars (cdr chars)))
(setq slist (cdr slist))))))
(when (nth 4 defaults)
(set (make-local-variable 'font-lock-beginning-of-syntax-function)
(nth 4 defaults)))
(dolist (x (nthcdr 5 defaults))
(let ((variable (car x)) (value (cdr x)))
(unless (boundp variable)
(set variable nil)) (set (make-local-variable variable) value))))))
(defun font-lock-unset-defaults ()
"Unset fontification defaults. See function `font-lock-set-defaults'."
(setq font-lock-set-defaults nil
font-lock-keywords nil
font-lock-keywords-only nil
font-lock-keywords-case-fold-search nil
font-lock-syntax-table nil
font-lock-beginning-of-syntax-function nil)
(let* ((defaults (or font-lock-defaults
(cdr (assq major-mode font-lock-defaults-alist))))
(alist (nthcdr 5 defaults)))
(while alist
(set (car (car alist)) (default-value (car (car alist))))
(setq alist (cdr alist)))))
(when (boundp 'font-lock-face-attributes)
(let ((face-attributes font-lock-face-attributes))
(while face-attributes
(let* ((face-attribute (pop face-attributes))
(face (car face-attribute)))
(unless (get face 'saved-face)
(let ((foreground (nth 1 face-attribute))
(background (nth 2 face-attribute))
(bold-p (nth 3 face-attribute))
(italic-p (nth 4 face-attribute))
(underline-p (nth 5 face-attribute))
face-spec)
(when foreground
(setq face-spec (cons ':foreground (cons foreground face-spec))))
(when background
(setq face-spec (cons ':background (cons background face-spec))))
(when bold-p
(setq face-spec (append '(:bold t) face-spec)))
(when italic-p
(setq face-spec (append '(:italic t) face-spec)))
(when underline-p
(setq face-spec (append '(:underline t) face-spec)))
(custom-declare-face face (list (list t face-spec)) nil)))))))
(defface font-lock-comment-face
'((((type tty pc) (class color) (background light)) (:foreground "red"))
(((type tty pc) (class color) (background dark)) (:foreground "red1"))
(((class grayscale) (background light))
(:foreground "DimGray" :bold t :italic t))
(((class grayscale) (background dark))
(:foreground "LightGray" :bold t :italic t))
(((class color) (background light)) (:foreground "Firebrick"))
(((class color) (background dark)) (:foreground "chocolate1"))
(t (:bold t :italic t)))
"Font Lock mode face used to highlight comments."
:group 'font-lock-highlighting-faces)
(defface font-lock-string-face
'((((type tty) (class color)) (:foreground "green"))
(((class grayscale) (background light)) (:foreground "DimGray" :italic t))
(((class grayscale) (background dark)) (:foreground "LightGray" :italic t))
(((class color) (background light)) (:foreground "RosyBrown"))
(((class color) (background dark)) (:foreground "LightSalmon"))
(t (:italic t)))
"Font Lock mode face used to highlight strings."
:group 'font-lock-highlighting-faces)
(defface font-lock-doc-face
'((t :inherit font-lock-string-face))
"Font Lock mode face used to highlight documentation."
:group 'font-lock-highlighting-faces)
(defface font-lock-keyword-face
'((((type tty) (class color)) (:foreground "cyan" :weight bold))
(((class grayscale) (background light)) (:foreground "LightGray" :bold t))
(((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
(((class color) (background light)) (:foreground "Purple"))
(((class color) (background dark)) (:foreground "Cyan"))
(t (:bold t)))
"Font Lock mode face used to highlight keywords."
:group 'font-lock-highlighting-faces)
(defface font-lock-builtin-face
'((((type tty) (class color)) (:foreground "blue" :weight light))
(((class grayscale) (background light)) (:foreground "LightGray" :bold t))
(((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
(((class color) (background light)) (:foreground "Orchid"))
(((class color) (background dark)) (:foreground "LightSteelBlue"))
(t (:bold t)))
"Font Lock mode face used to highlight builtins."
:group 'font-lock-highlighting-faces)
(defface font-lock-function-name-face
'((((type tty) (class color)) (:foreground "blue" :weight bold))
(((class color) (background light)) (:foreground "Blue"))
(((class color) (background dark)) (:foreground "LightSkyBlue"))
(t (:inverse-video t :bold t)))
"Font Lock mode face used to highlight function names."
:group 'font-lock-highlighting-faces)
(defface font-lock-variable-name-face
'((((type tty) (class color)) (:foreground "yellow" :weight light))
(((class grayscale) (background light))
(:foreground "Gray90" :bold t :italic t))
(((class grayscale) (background dark))
(:foreground "DimGray" :bold t :italic t))
(((class color) (background light)) (:foreground "DarkGoldenrod"))
(((class color) (background dark)) (:foreground "LightGoldenrod"))
(t (:bold t :italic t)))
"Font Lock mode face used to highlight variable names."
:group 'font-lock-highlighting-faces)
(defface font-lock-type-face
'((((type tty) (class color)) (:foreground "green"))
(((class grayscale) (background light)) (:foreground "Gray90" :bold t))
(((class grayscale) (background dark)) (:foreground "DimGray" :bold t))
(((class color) (background light)) (:foreground "ForestGreen"))
(((class color) (background dark)) (:foreground "PaleGreen"))
(t (:bold t :underline t)))
"Font Lock mode face used to highlight type and classes."
:group 'font-lock-highlighting-faces)
(defface font-lock-constant-face
'((((type tty) (class color)) (:foreground "magenta"))
(((class grayscale) (background light))
(:foreground "LightGray" :bold t :underline t))
(((class grayscale) (background dark))
(:foreground "Gray50" :bold t :underline t))
(((class color) (background light)) (:foreground "CadetBlue"))
(((class color) (background dark)) (:foreground "Aquamarine"))
(t (:bold t :underline t)))
"Font Lock mode face used to highlight constants and labels."
:group 'font-lock-highlighting-faces)
(defface font-lock-warning-face
'((((type tty) (class color)) (:foreground "red"))
(((class color) (background light)) (:foreground "Red" :bold t))
(((class color) (background dark)) (:foreground "Pink" :bold t))
(t (:inverse-video t :bold t)))
"Font Lock mode face used to highlight warnings."
:group 'font-lock-highlighting-faces)
(defun font-lock-match-c-style-declaration-item-and-skip-to-next (limit)
"Match, and move over, any declaration/definition item after point.
Matches after point, but ignores leading whitespace and `*' characters.
Does not move further than LIMIT.
The expected syntax of a declaration/definition item is `word' (preceded by
optional whitespace and `*' characters and proceeded by optional whitespace)
optionally followed by a `('. Everything following the item (but belonging to
it) is expected to by skip-able by `scan-sexps', and items are expected to be
separated with a `,' and to be terminated with a `;'.
Thus the regexp matches after point: word (
^^^^ ^
Where the match subexpressions are: 1 2
The item is delimited by (match-beginning 1) and (match-end 1).
If (match-beginning 2) is non-nil, the item is followed by a `('.
This function could be MATCHER in a MATCH-ANCHORED `font-lock-keywords' item."
(when (looking-at "[ \t*]*\\(\\sw+\\)[ \t]*\\((\\)?")
(save-match-data
(condition-case nil
(save-restriction
(narrow-to-region (point-min) limit)
(goto-char (match-end 1))
(while (not (looking-at "[ \t]*\\(\\(,\\)\\|;\\|$\\)"))
(goto-char (or (scan-sexps (point) 1) (point-max))))
(goto-char (match-end 2)))
(error t)))))
(defconst lisp-font-lock-keywords-1
(eval-when-compile
(list
(list (concat "(\\(def\\("
"\\(advice\\|varalias\\|alias\\|generic\\|macro\\*?\\|method\\|"
"setf\\|subst\\*?\\|un\\*?\\|"
"ine-\\(condition\\|\\(?:derived\\|minor\\)-mode\\|"
"method-combination\\|setf-expander\\|skeleton\\|widget\\|"
"function\\|\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|"
"\\(const\\(ant\\)?\\|custom\\|face\\|parameter\\|var\\)\\|"
"\\(class\\|group\\|package\\|struct\\|type\\)"
"\\)\\)\\>"
"[ \t'\(]*"
"\\(setf[ \t]+\\sw+)\\|\\sw+\\)?")
'(1 font-lock-keyword-face)
'(9 (cond ((match-beginning 3) font-lock-function-name-face)
((match-beginning 6) font-lock-variable-name-face)
(t font-lock-type-face))
nil t))
'("^;;;###\\(autoload\\)" 1 font-lock-warning-face prepend)
))
"Subdued level highlighting for Lisp modes.")
(defconst lisp-font-lock-keywords-2
(append lisp-font-lock-keywords-1
(eval-when-compile
(list
(cons (concat
"(" (regexp-opt
'("cond" "if" "while" "let" "let*"
"prog" "progn" "progv" "prog1" "prog2" "prog*"
"inline" "lambda" "save-restriction" "save-excursion"
"save-window-excursion" "save-selected-window"
"save-match-data" "save-current-buffer" "unwind-protect"
"condition-case" "track-mouse"
"eval-after-load" "eval-and-compile" "eval-when-compile"
"eval-when"
"with-current-buffer" "with-electric-help"
"with-output-to-string" "with-output-to-temp-buffer"
"with-temp-buffer" "with-temp-file" "with-temp-message"
"with-timeout") t)
"\\>")
1)
(cons (concat
"(" (regexp-opt
'("when" "unless" "case" "ecase" "typecase" "etypecase"
"ccase" "ctypecase" "handler-case" "handler-bind"
"restart-bind" "restart-case" "in-package"
"cerror" "break" "ignore-errors"
"loop" "do" "do*" "dotimes" "dolist" "the" "locally"
"proclaim" "declaim" "declare" "symbol-macrolet"
"lexical-let" "lexical-let*" "flet" "labels" "compiler-let"
"destructuring-bind" "macrolet" "tagbody" "block"
"return" "return-from") t)
"\\>")
1)
(list (concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\>"
"[ \t']*\\(\\sw+\\)?")
'(1 font-lock-keyword-face)
'(2 font-lock-constant-face nil t))
'("(\\(abort\\|assert\\|error\\|signal\\)\\>" 1 font-lock-warning-face)
'("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-constant-face prepend)
'("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend)
'("\\<:\\sw\\sw+\\>" 0 font-lock-builtin-face)
'("\\&\\sw+\\>" . font-lock-type-face)
'("(\\(\\(do-\\|with-\\)\\(\\s_\\|\\w\\)*\\)" 1 font-lock-keyword-face)
)))
"Gaudy level highlighting for Lisp modes.")
(defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
"Default expressions to highlight in Lisp modes.")
(define-widget 'font-lock-extra-types-widget 'radio
"Widget `:type' for members of the custom group `font-lock-extra-types'.
Members should `:load' the package `font-lock' to use this widget."
:args '((const :tag "none" nil)
(repeat :tag "types" regexp)))
(defcustom c-font-lock-extra-types '("FILE" "\\sw+_t" "Lisp_Object")
"*List of extra types to fontify in C mode.
Each list item should be a regexp not containing word-delimiters.
For example, a value of (\"FILE\" \"\\\\sw+_t\") means the word FILE and words
ending in _t are treated as type names.
The value of this variable is used when Font Lock mode is turned on."
:type 'font-lock-extra-types-widget
:group 'font-lock-extra-types)
(defcustom c++-font-lock-extra-types
'("\\sw+_t"
"\\([iof]\\|str\\)+stream\\(buf\\)?" "ios"
"string" "rope"
"list" "slist"
"deque" "vector" "bit_vector"
"set" "multiset"
"map" "multimap"
"hash\\(_\\(m\\(ap\\|ulti\\(map\\|set\\)\\)\\|set\\)\\)?"
"stack" "queue" "priority_queue"
"type_info"
"iterator" "const_iterator" "reverse_iterator" "const_reverse_iterator"
"reference" "const_reference")
"*List of extra types to fontify in C++ mode.
Each list item should be a regexp not containing word-delimiters.
For example, a value of (\"string\") means the word string is treated as a type
name.
The value of this variable is used when Font Lock mode is turned on."
:type 'font-lock-extra-types-widget
:group 'font-lock-extra-types)
(defcustom objc-font-lock-extra-types '("Class" "BOOL" "IMP" "SEL")
"*List of extra types to fontify in Objective-C mode.
Each list item should be a regexp not containing word-delimiters.
For example, a value of (\"Class\" \"BOOL\" \"IMP\" \"SEL\") means the words
Class, BOOL, IMP and SEL are treated as type names.
The value of this variable is used when Font Lock mode is turned on."
:type 'font-lock-extra-types-widget
:group 'font-lock-extra-types)
(defcustom java-font-lock-extra-types
'("[A-Z\300-\326\330-\337]\\sw*[a-z]\\sw*")
"*List of extra types to fontify in Java mode.
Each list item should be a regexp not containing word-delimiters.
For example, a value of (\"[A-Z\300-\326\330-\337]\\\\sw*[a-z]\\\\sw*\") means capitalised
words (and words conforming to the Java id spec) are treated as type names.
The value of this variable is used when Font Lock mode is turned on."
:type 'font-lock-extra-types-widget
:group 'font-lock-extra-types)
(defconst c-font-lock-keywords-1 nil
"Subdued level highlighting for C mode.")
(defconst c-font-lock-keywords-2 nil
"Medium level highlighting for C mode.
See also `c-font-lock-extra-types'.")
(defconst c-font-lock-keywords-3 nil
"Gaudy level highlighting for C mode.
See also `c-font-lock-extra-types'.")
(let* ((c-keywords
(eval-when-compile
(regexp-opt '("break" "continue" "do" "else" "for" "if" "return"
"switch" "while" "sizeof"
"typedef" "extern" "auto" "register" "static"
"volatile" "const"
"restrict"))))
(c-type-specs
(eval-when-compile
(regexp-opt '("enum" "struct" "union"))))
(c-type-specs-depth
(regexp-opt-depth c-type-specs))
(c-type-names
`(mapconcat 'identity
(cons
,(eval-when-compile
(regexp-opt
'("char" "short" "int" "long" "signed" "unsigned"
"float" "double" "void" "complex")))
c-font-lock-extra-types)
"\\|"))
(c-type-names-depth
`(regexp-opt-depth ,c-type-names))
(c-preprocessor-directives
(eval-when-compile
(regexp-opt
'("define" "elif" "else" "endif" "error" "file" "if" "ifdef"
"ifndef" "include" "line" "pragma" "undef"))))
(c-preprocessor-directives-depth
(regexp-opt-depth c-preprocessor-directives)))
(setq c-font-lock-keywords-1
(list
'("^\\(\\sw+\\)[ \t]*(" 1 font-lock-function-name-face)
'("^#[ \t]*error[ \t]+\\(.+\\)" 1 font-lock-warning-face prepend)
'("^#[ \t]*\\(import\\|include\\)[ \t]*\\(<[^>\"\n]*>?\\)"
2 font-lock-string-face)
'("^#[ \t]*define[ \t]+\\(\\sw+\\)(" 1 font-lock-function-name-face)
'("^#[ \t]*\\(elif\\|if\\)\\>"
("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil
(1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t)))
(list
(concat "^#[ \t]*\\(" c-preprocessor-directives
"\\)\\>[ \t!]*\\(\\sw+\\)?")
'(1 font-lock-builtin-face)
(list (+ 2 c-preprocessor-directives-depth)
'font-lock-variable-name-face nil t))))
(setq c-font-lock-keywords-2
(append c-font-lock-keywords-1
(list
`(eval .
(cons (concat "\\<\\(" ,c-type-names "\\)\\>") 'font-lock-type-face))
(concat "\\<\\(" c-keywords "\\|" c-type-specs "\\)\\>")
'("\\<\\(case\\|goto\\)\\>"
(1 font-lock-keyword-face)
("\\(-[0-9]+\\|\\sw+\\)"
(save-excursion (skip-chars-forward "^:\n") (point))
nil
(1 font-lock-constant-face nil t)))
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"
(beginning-of-line) (end-of-line)
(1 font-lock-constant-face)))
)))
(setq c-font-lock-keywords-3
(append c-font-lock-keywords-2
(list
`(eval .
(list (concat "\\<\\(" ,c-type-names "\\)\\>"
"\\([ \t*&]+\\sw+\\>\\)*")
(list 'font-lock-match-c-style-declaration-item-and-skip-to-next
(list 'goto-char (list 'or
(list 'match-beginning
(+ ,c-type-names-depth 2))
'(match-end 1)))
'(goto-char (match-end 1))
'(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face)))))
`(eval .
(list (concat "\\<\\(" ,c-type-specs "\\)\\>"
"[ \t]*\\(\\sw+\\)?")
(list 1 'font-lock-keyword-face)
(list ,(+ c-type-specs-depth 2) 'font-lock-type-face nil t)
(list 'font-lock-match-c-style-declaration-item-and-skip-to-next
nil
`(if (match-end 2)
(goto-char (match-end 2)))
'(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face) nil t))))
'("\\(}\\)[ \t*]*\\sw"
(font-lock-match-c-style-declaration-item-and-skip-to-next
(goto-char (match-end 1)) nil
(1 font-lock-type-face)))
'("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*"
(1 font-lock-type-face)
(font-lock-match-c-style-declaration-item-and-skip-to-next
(goto-char (or (match-beginning 2) (match-end 1))) nil
(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face))))
)))
)
(defvar c-font-lock-keywords c-font-lock-keywords-1
"Default expressions to highlight in C mode.
See also `c-font-lock-extra-types'.")
(defconst c++-font-lock-keywords-1 nil
"Subdued level highlighting for C++ mode.")
(defconst c++-font-lock-keywords-2 nil
"Medium level highlighting for C++ mode.
See also `c++-font-lock-extra-types'.")
(defconst c++-font-lock-keywords-3 nil
"Gaudy level highlighting for C++ mode.
See also `c++-font-lock-extra-types'.")
(defun font-lock-match-c++-style-declaration-item-and-skip-to-next (limit)
(when (looking-at (eval-when-compile
(concat
"[ \t*&]*"
"\\(\\sw+\\)" "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?" "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*" "[ \t]*\\((\\)?")))
(save-match-data
(condition-case nil
(save-restriction
(narrow-to-region (point-min) limit)
(goto-char (match-end 1))
(while (not (looking-at "[ \t]*\\(\\(,\\)\\|;\\|$\\)"))
(goto-char (or (scan-sexps (point) 1) (point-max))))
(goto-char (match-end 2)))
(error t)))))
(defun font-lock-match-c++-structor-declaration (limit)
(let ((res nil)
(regexp (concat "^\\s-+\\(\\(virtual\\|explicit\\)\\s-+\\)*~?\\(\\<"
(mapconcat 'identity
c++-font-lock-extra-types "\\|")
"\\>\\)\\s-*("
"\\s-*[^*( \t]")))
(while (progn (setq res (re-search-forward regexp limit t))
(and res
(save-excursion
(beginning-of-line)
(save-match-data
(not (vectorp (c-at-toplevel-p))))))))
res))
(let* ((c++-keywords
(eval-when-compile
(regexp-opt
'("break" "continue" "do" "else" "for" "if" "return" "switch"
"while" "asm" "catch" "delete" "new" "sizeof" "this" "throw" "try"
"typeid"
"export"
"mutable" "explicit"
"typedef" "template"
"extern" "auto" "register" "const" "volatile" "static"
"inline" "friend" "virtual"
"and" "and_eq" "bitand" "bitor" "compl" "not" "not_eq"
"or" "or_eq" "xor" "xor_eq"))))
(c++-operators
(eval-when-compile
(regexp-opt
'("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" "+=" "-="
"*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>" ">>=" "<<=" "==" "!="
"<=" ">=" "&&" "||" "++" "--" "->*" "," "->" "[]" "()"))))
(c++-type-specs
(eval-when-compile
(regexp-opt
'("class" "public" "private" "protected" "typename"
"struct" "union" "enum" "namespace" "using"
"static_cast" "dynamic_cast" "const_cast" "reinterpret_cast") t)))
(c++-type-specs-depth
(regexp-opt-depth c++-type-specs))
(c++-type-names
`(mapconcat 'identity
(cons
,(eval-when-compile
(regexp-opt
'("signed" "unsigned" "short" "long"
"int" "char" "float" "double" "void"
"bool" "complex")))
c++-font-lock-extra-types)
"\\|"))
(c++-type-names-depth `(regexp-opt-depth ,c++-type-names))
(c++-type-suffix (concat "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?"
"\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*"))
(c++-type-suffix-depth (regexp-opt-depth c++-type-suffix))
(c++-type-spec (concat "\\(\\sw+\\)\\>" c++-type-suffix))
(c++-type-spec-depth (regexp-opt-depth c++-type-spec))
(c++-type-depth `(regexp-opt-depth
(concat ,c++-type-names ,c++-type-suffix)))
)
(setq c++-font-lock-keywords-1
(append
(cdr c-font-lock-keywords-1)
(list
(list (concat "^" c++-type-spec "[ \t]*(")
'(1 (if (or (match-beginning 2) (match-beginning 4))
font-lock-type-face
font-lock-function-name-face))
'(3 font-lock-type-face nil t)
'(5 font-lock-function-name-face nil t))
)))
(setq c++-font-lock-keywords-2
(append c++-font-lock-keywords-1
(list
`(eval .
(cons (concat "\\<\\(" ,c++-type-names "\\)\\>")
'font-lock-type-face))
(list (concat "\\<\\(operator\\)\\>[ \t]*\\(" c++-operators "\\)?")
'(1 font-lock-keyword-face)
'(2 font-lock-builtin-face nil t))
'("\\<\\(case\\|goto\\)\\>"
(1 font-lock-keyword-face)
("\\(-[0-9]+\\|\\sw+\\)[ \t]*\\(::\\)?"
(save-excursion
(while (progn
(skip-chars-forward "^:\n")
(looking-at "::"))
(forward-char 2))
(point))
nil
(1 (if (match-beginning 2)
font-lock-type-face
font-lock-constant-face) nil t)))
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:\\($\\|[^:]\\)"
(beginning-of-line) (end-of-line)
(1 font-lock-constant-face)))
(concat "\\<\\(" c++-keywords "\\|" c++-type-specs "\\)\\>")
'("\\<\\(false\\|true\\)\\>" . font-lock-constant-face)
)))
(setq c++-font-lock-keywords-3
(append c++-font-lock-keywords-2
(list
`(eval .
(list (concat "\\<\\(" ,c++-type-names "\\)\\>" ,c++-type-suffix
"\\([ \t*&]+" ,c++-type-spec "\\)*")
(list (+ ,c++-type-names-depth 3) 'font-lock-type-face nil t)
(list 'font-lock-match-c++-style-declaration-item-and-skip-to-next
(list 'goto-char (list 'or (list 'match-beginning
(+ ,c++-type-depth 2))
'(match-end 1)))
'(goto-char (match-end 1))
'(1 (cond ((or (match-beginning 2) (match-beginning 4))
font-lock-type-face)
((and (match-beginning 6) (c-at-toplevel-p))
font-lock-function-name-face)
(t
font-lock-variable-name-face)))
'(3 font-lock-type-face nil t)
'(5 (if (match-beginning 6)
font-lock-function-name-face
font-lock-variable-name-face) nil t))))
`(eval .
(list (concat "\\<" ,c++-type-specs "\\>" ,c++-type-suffix
"[ \t]*\\(" ,c++-type-spec "\\)?")
(list ,(+ c++-type-specs-depth 2) 'font-lock-type-face nil t)
(list (+ ,c++-type-specs-depth ,c++-type-suffix-depth 2)
'font-lock-type-face nil t)
(list 'font-lock-match-c++-style-declaration-item-and-skip-to-next
nil
nil
'(1 (cond ((or (match-beginning 2) (match-beginning 4))
font-lock-type-face)
((and (match-beginning 6) (c-at-toplevel-p))
font-lock-function-name-face)
(t
font-lock-variable-name-face)))
'(3 font-lock-type-face nil t)
'(5 (if (match-beginning 6)
font-lock-function-name-face
font-lock-variable-name-face) nil t))
))
'("\\(}\\)[ \t*]*\\sw"
(font-lock-match-c++-style-declaration-item-and-skip-to-next
(goto-char (match-end 1)) nil
(1 font-lock-type-face)))
(list (concat "^\\(" c++-type-spec "[ \t*&]*\\)+")
'(font-lock-match-c++-style-declaration-item-and-skip-to-next
(goto-char (match-beginning 1))
(goto-char (match-end 1))
(1 (cond ((or (match-beginning 2) (match-beginning 4))
font-lock-type-face)
((match-beginning 6) font-lock-function-name-face)
(t font-lock-variable-name-face)))
(3 font-lock-type-face nil t)
(5 (if (match-beginning 6)
font-lock-function-name-face
font-lock-variable-name-face) nil t)))
'(font-lock-match-c++-structor-declaration
(3 font-lock-function-name-face t))
)))
)
(defvar c++-font-lock-keywords c++-font-lock-keywords-1
"Default expressions to highlight in C++ mode.
See also `c++-font-lock-extra-types'.")
(defconst objc-font-lock-keywords-1 nil
"Subdued level highlighting for Objective-C mode.")
(defconst objc-font-lock-keywords-2 nil
"Medium level highlighting for Objective-C mode.
See also `objc-font-lock-extra-types'.")
(defconst objc-font-lock-keywords-3 nil
"Gaudy level highlighting for Objective-C mode.
See also `objc-font-lock-extra-types'.")
(let* ((objc-keywords
(eval-when-compile
(regexp-opt '("break" "continue" "do" "else" "for" "if" "return"
"switch" "while" "sizeof" "self" "super"
"typedef" "auto" "extern" "static"
"volatile" "const"))))
(objc-type-specs
(eval-when-compile
(regexp-opt
'("register" "struct" "union" "enum"
"oneway" "in" "out" "inout" "bycopy" "byref") t)))
(objc-type-specs-depth
(regexp-opt-depth objc-type-specs))
(objc-type-names
`(mapconcat 'identity
(cons
,(eval-when-compile
(regexp-opt
'("signed" "unsigned" "short" "long"
"int" "char" "float" "double" "void"
"id")))
objc-font-lock-extra-types)
"\\|"))
(objc-type-names-depth
`(regexp-opt-depth ,objc-type-names))
)
(setq objc-font-lock-keywords-1
(append
(cdr c-font-lock-keywords-1)
(list
'("@\\(\\sw+\\)\\>"
(1 font-lock-keyword-face)
("\\=[ \t:<,]*\\(\\sw+\\)" nil nil
(1 font-lock-type-face)))
'("^[+-][ \t]*\\(PRIVATE\\>\\)?[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)"
(1 font-lock-keyword-face nil t)
(3 font-lock-function-name-face)
("\\=[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)"
nil nil
(1 font-lock-function-name-face nil t)
(3 font-lock-variable-name-face)))
'(":" ("^[ \t]*\\(\\sw+\\)?:[ \t]*\\(([^)\n]+)\\)?[ \t]*\\(\\sw+\\)"
(beginning-of-line) (end-of-line)
(1 font-lock-function-name-face nil t)
(3 font-lock-variable-name-face)))
)))
(setq objc-font-lock-keywords-2
(append objc-font-lock-keywords-1
(list
`(eval .
(cons (concat "\\<\\(" ,objc-type-names "\\)\\>")
'font-lock-type-face))
(concat "\\<\\(" objc-keywords "\\|" objc-type-specs "\\)\\>")
'("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"
(1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"
(beginning-of-line) (end-of-line)
(1 font-lock-constant-face)))
'("\\<[Nn]il\\>" . font-lock-constant-face)
)))
(setq objc-font-lock-keywords-3
(append objc-font-lock-keywords-2
(list
`(eval .
(list (concat "\\<\\(" ,objc-type-names "\\)\\>"
"\\([ \t*&]+\\sw+\\>\\)*")
(list 'font-lock-match-c-style-declaration-item-and-skip-to-next
(list 'goto-char
(list 'or (list 'match-beginning
(+ ,objc-type-names-depth 2))
'(match-end 1)))
'(goto-char (match-end 1))
'(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face)))))
`(eval .
(list (concat "\\<\\(" ,objc-type-specs "[ \t]*\\)+\\>"
"[ \t]*\\(\\sw+\\)?")
(list ,(+ objc-type-specs-depth 2) 'font-lock-type-face nil t)
(list 'font-lock-match-c++-style-declaration-item-and-skip-to-next
nil nil
'(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face)))
))
'("\\(}\\)[ \t*]*\\sw"
(font-lock-match-c-style-declaration-item-and-skip-to-next
(goto-char (match-end 1)) nil
(1 font-lock-type-face)))
'("^\\(\\sw+\\)\\>\\([ \t*]+\\sw+\\>\\)*"
(1 font-lock-type-face)
(font-lock-match-c-style-declaration-item-and-skip-to-next
(goto-char (or (match-beginning 2) (match-end 1))) nil
(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face))))
)))
)
(defvar objc-font-lock-keywords objc-font-lock-keywords-1
"Default expressions to highlight in Objective-C mode.
See also `objc-font-lock-extra-types'.")
(defconst java-font-lock-keywords-1 nil
"Subdued level highlighting for Java mode.")
(defconst java-font-lock-keywords-2 nil
"Medium level highlighting for Java mode.
See also `java-font-lock-extra-types'.")
(defconst java-font-lock-keywords-3 nil
"Gaudy level highlighting for Java mode.
See also `java-font-lock-extra-types'.")
(let* ((java-keywords
(eval-when-compile
(regexp-opt
'("catch" "do" "else" "super" "this" "finally" "for" "if"
"implements" "extends" "throws" "instanceof" "new"
"interface" "return" "switch" "throw" "try" "while"))))
(java-type-names
`(mapconcat 'identity
(cons
,(eval-when-compile
(regexp-opt '("boolean" "char" "byte" "short" "int" "long"
"float" "double" "void")))
java-font-lock-extra-types)
"\\|"))
(java-type-names-depth `(regexp-opt-depth ,java-type-names))
(java-type-specs
(eval-when-compile
(regexp-opt
'("abstract" "const" "final" "synchronized" "transient" "static"
"volatile" "public" "private" "protected" "native"
"strictfp"))))
)
(setq java-font-lock-keywords-1
(list
'("\\<\\(class\\)\\>[ \t]*\\(\\sw+\\)?"
(1 font-lock-keyword-face) (2 font-lock-type-face nil t))
'("\\<\\(import\\|package\\)\\>[ \t]*\\(\\sw+\\)?"
(1 font-lock-keyword-face)
(2 font-lock-constant-face nil t)
("\\=\\.\\(\\*\\|\\sw+\\)" nil nil
(1 font-lock-constant-face nil t)))
))
(setq java-font-lock-keywords-2
(append java-font-lock-keywords-1
(list
`(eval .
(cons (concat "\\<\\(" ,java-type-names "\\)\\>[^.]")
'(1 font-lock-type-face)))
(concat "\\<\\(" java-keywords "\\|" java-type-specs "\\)\\>")
(list "\\<\\(break\\|case\\|continue\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"
'(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t))
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"
(beginning-of-line) (end-of-line)
(1 font-lock-constant-face)))
'("\\<\\(false\\|null\\|true\\)\\>" . font-lock-constant-face)
(list
(concat "@\\("
"author\\|deprecated\\|exception"
"\\|link\\|return\\|see\\|serial\\|serialData\\|serialField"
"\\|since\\|throws"
"\\|version"
"\\)\\>")
'(1 font-lock-constant-face prepend))
'("@\\(param\\)\\>[ \t]*\\(\\sw+\\)?"
(1 font-lock-constant-face prepend)
(2 font-lock-variable-name-face prepend t))
'("@\\(exception\\|throws\\)\\>[ \t]*\\(\\S-+\\)?"
(1 font-lock-constant-face prepend)
(2 font-lock-type-face prepend t))
)))
(setq java-font-lock-keywords-3
(append java-font-lock-keywords-2
(list
`(eval .
(list (concat "\\<\\(" ,java-type-names "\\)\\>"
"\\([ \t]*\\[[ \t]*\\]\\)*"
"\\([ \t]*\\sw\\)")
(list 'font-lock-match-c-style-declaration-item-and-skip-to-next
(list 'goto-char (list 'match-beginning
(+ ,java-type-names-depth 3)))
(list 'goto-char (list 'match-beginning
(+ ,java-type-names-depth 3)))
'(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face)))))
(list (concat "\\<\\(" java-type-specs "\\)\\>"
"\\([ \t]+\\sw+\\>"
"\\([ \t]*\\[[ \t]*\\]\\)*"
"\\)*")
'(font-lock-match-c-style-declaration-item-and-skip-to-next
(goto-char (or (match-beginning 5) (match-end 1)))
(goto-char (match-end 1))
(1 (if (match-beginning 2)
font-lock-function-name-face
font-lock-variable-name-face))))
)))
)
(defvar java-font-lock-keywords java-font-lock-keywords-1
"Default expressions to highlight in Java mode.
See also `java-font-lock-extra-types'.")
(provide 'font-lock)
(when (eq font-lock-support-mode 'jit-lock-mode)
(require 'jit-lock))