(defgroup font-lock nil
"Font Lock mode text highlighting package."
:link '(custom-manual "(emacs)Font Lock")
: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)
(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-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 HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED.
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.
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)
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'. MATCH is the
subexpression of MATCHER to be highlighted. MATCH can be calculated via the
function `regexp-opt-depth'. FACENAME is an expression whose value is the face
name to use. Face default attributes can be modified via \\[customize].
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 should not match text which spans lines. While
\\[font-lock-fontify-buffer] handles multi-line patterns correctly, updating
when you edit the buffer does not, since it considers text one line at a time.
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'.")
(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)))
(tex-mode-defaults
'((tex-font-lock-keywords
tex-font-lock-keywords-1 tex-font-lock-keywords-2)
nil nil ((?$ . "\"")) nil
(font-lock-mark-block-function . mark-paragraph)))
)
(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 'latex-mode tex-mode-defaults)
(cons 'lisp-mode lisp-mode-defaults)
(cons 'lisp-interaction-mode lisp-mode-defaults)
(cons 'plain-tex-mode tex-mode-defaults)
(cons 'slitex-mode tex-mode-defaults)
(cons 'tex-mode tex-mode-defaults)))
"Alist of fall-back Font Lock defaults for major modes.
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.")
(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'.")
(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'.")
(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 of the form (SYNTAX-CODE . MATCHING-CHAR), the name of a
syntax table, or an expression whose value is such a form or a syntax table.
OVERRIDE cannot be `prepend' or `append'.
For example, an element of the form highlights syntactically:
(\"\\\\$\\\\(#\\\\)\" 1 (1 . nil))
a hash character when following a dollar character, with a SYNTAX-CODE of
1 (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 (7 . ?'))
(2 (7 . ?')))
both single quotes which surround a single character, with a SYNTAX-CODE of
7 (meaning string quote syntax) and a MATCHING-CHAR of a single quote (meaning
a single quote matches a single quote). 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 as `fast-lock-mode' and `lazy-lock-mode'.
This is normally set via `font-lock-defaults'.")
(defvar font-lock-mode nil) (defvar font-lock-fontified nil)
(defvar font-lock-mode-hook nil
"Function or functions to run on entry to Font Lock mode.")
(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)
before-change-functions after-change-functions
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)
(defvar global-font-lock-mode) (defvar font-lock-face-attributes) (defvar font-lock-string-face) (defvar font-lock-comment-face))
(defun font-lock-mode (&optional arg)
"Toggle Font Lock mode.
With arg, turn Font Lock mode on if and only if arg is positive.
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'.
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."
(interactive "P")
(let ((on-p (and (not noninteractive)
(not (eq (aref (buffer-name) 0) ?\ ))
(if arg
(> (prefix-numeric-value arg) 0)
(not font-lock-mode)))))
(set (make-local-variable 'font-lock-mode) on-p)
(when on-p
(make-local-hook 'after-change-functions)
(add-hook 'after-change-functions 'font-lock-after-change-function nil t)
(font-lock-set-defaults)
(font-lock-turn-on-thing-lock)
(run-hooks 'font-lock-mode-hook)
(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 too big" (buffer-name))))))
(unless on-p
(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))
(force-mode-line-update)))
(defun turn-on-font-lock ()
"Turn on Font Lock mode conditionally.
Turn on only if the terminal can display it."
(when (and (not font-lock-mode) window-system)
(font-lock-mode)))
(defun font-lock-add-keywords (major-mode keywords &optional append)
"Add highlighting KEYWORDS for MAJOR-MODE.
MAJOR-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.
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 (major-mode
(let ((spec (cons keywords append)) cell)
(if (setq cell (assq major-mode font-lock-keywords-alist))
(setcdr cell (append (cdr cell) (list spec)))
(push (list major-mode spec) font-lock-keywords-alist))))
(font-lock-mode
(if (eq append 'set)
(setq font-lock-keywords 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))))))))
(defvar font-lock-buffers nil)
(defun global-font-lock-mode (&optional arg message)
"Toggle Global Font Lock mode.
With prefix ARG, turn Global Font Lock mode on if and only if ARG is positive.
Displays a message saying whether the mode is on or off if MESSAGE is non-nil.
Returns the new status of Global Font Lock mode (non-nil means on).
When Global Font Lock mode is enabled, Font Lock mode is automagically
turned on in a buffer if its major mode is one of `font-lock-global-modes'."
(interactive "P\np")
(let ((on-p (if arg
(> (prefix-numeric-value arg) 0)
(not global-font-lock-mode))))
(cond (on-p
(add-hook 'find-file-hooks 'turn-on-font-lock-if-enabled)
(add-hook 'post-command-hook 'turn-on-font-lock-if-enabled)
(setq font-lock-buffers (buffer-list)))
(t
(remove-hook 'find-file-hooks 'turn-on-font-lock-if-enabled)
(mapcar (function (lambda (buffer)
(with-current-buffer buffer
(when font-lock-mode
(font-lock-mode)))))
(buffer-list))))
(when message
(message "Global Font Lock mode %s." (if on-p "enabled" "disabled")))
(setq global-font-lock-mode on-p)))
(defcustom global-font-lock-mode nil
"Toggle Global Font Lock mode.
When Global Font Lock mode is enabled, Font Lock mode is automagically
turned on in a buffer if its major mode is one of `font-lock-global-modes'.
Setting this variable directly does not take effect;
use either \\[customize] or the function `global-font-lock-mode'."
:set (lambda (symbol value)
(global-font-lock-mode (or value 0)))
:initialize 'custom-initialize-default
:type 'boolean
:group 'font-lock
:require 'font-lock)
(defcustom font-lock-global-modes t
"*Modes for which Font Lock mode is automagically turned on.
Global Font Lock mode is controlled by the `global-font-lock-mode' command.
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 font-lock-change-major-mode ()
(when font-lock-mode
(font-lock-mode))
(when global-font-lock-mode
(add-hook 'post-command-hook 'turn-on-font-lock-if-enabled)
(add-to-list 'font-lock-buffers (current-buffer))))
(defun turn-on-font-lock-if-enabled ()
(remove-hook 'post-command-hook 'turn-on-font-lock-if-enabled)
(while font-lock-buffers
(when (buffer-live-p (car font-lock-buffers))
(save-excursion
(set-buffer (car font-lock-buffers))
(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)))))
(setq font-lock-buffers (cdr font-lock-buffers))))
(add-hook 'change-major-mode-hook 'font-lock-change-major-mode)
(defcustom font-lock-support-mode nil
"*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') and
Lazy Lock mode (symbol `lazy-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)
(repeat :menu-tag "mode specific" :tag "mode specific"
:value ((t . lazy-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)))
))
:group 'font-lock)
(defvar fast-lock-mode nil)
(defvar lazy-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)))))
(defun font-lock-turn-off-thing-lock ()
(cond (fast-lock-mode
(fast-lock-mode nil))
(lazy-lock-mode
(lazy-lock-mode nil))))
(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 `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))
(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
(if font-lock-syntactic-keywords
(remove-text-properties beg end '(face nil syntax-table nil))
(remove-text-properties beg end '(face 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)))
(unless (numberp (car-safe value))
(setq value (eval 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)
(save-excursion (end-of-line) (setq limit (point))))
(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 (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 string 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 string (nth 3 state) beg (point))
(setq state (parse-partial-sexp (point) end nil nil state 'syntax-table))
(put-text-property beg (point) 'face
(if string
font-lock-string-face
font-lock-comment-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 string (nth 3 state) beg (nth 8 state))
(setq state (parse-partial-sexp (point) end nil nil state 'syntax-table))
(put-text-property beg (point) 'face
(if string
font-lock-string-face
font-lock-comment-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
(pre-match-value (eval (nth 1 keywords))))
(if (and (numberp pre-match-value) (> pre-match-value (point)))
(setq limit pre-match-value)
(save-excursion (end-of-line) (setq limit (point))))
(save-match-data
(while (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 (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-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)
(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)
(if (listp keywords)
keywords
(font-lock-eval-keywords (if (fboundp keywords)
(funcall keywords)
(eval keywords)))))
(defun font-lock-value-in-major-mode (alist)
(if (consp alist)
(cdr (or (assq major-mode alist) (assq t alist)))
alist))
(defun font-lock-choose-keywords (keywords level)
(cond ((symbolp 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'."
(make-local-variable 'font-lock-fontified)
(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))
(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))))
(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 (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)))
(let ((alist (nthcdr 5 defaults)))
(while alist
(let ((variable (car (car alist))) (value (cdr (car alist))))
(unless (boundp variable)
(set variable nil))
(set (make-local-variable variable) value)
(setq alist (cdr alist))))))))
(defun font-lock-unset-defaults ()
"Unset fontification defaults. See `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)))))
(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-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.")
(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
'((((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 "OrangeRed"))
(t (:bold t :italic t)))
"Font Lock mode face used to highlight comments."
:group 'font-lock-highlighting-faces)
(defface font-lock-string-face
'((((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-keyword-face
'((((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
'((((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
'((((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
'((((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
'((((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
'((((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
'((((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\\|alias\\|generic\\|macro\\*?\\|method\\|"
"setf\\|subst\\*?\\|un\\*?\\|"
"ine-\\(condition\\|derived-mode\\|function\\|"
"method-combination\\|setf-expander\\|skeleton\\|widget\\|"
"\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|"
"\\(const\\(ant\\)?\\|custom\\|face\\|parameter\\|var\\)\\|"
"\\(class\\|group\\|package\\|struct\\|type\\)"
"\\)\\)\\>"
"[ \t'\(]*"
"\\(\\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)
)))
"Gaudy level highlighting for Lisp modes.")
(defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
"Default expressions to highlight in Lisp modes.")
(defconst tex-font-lock-keywords-1
(eval-when-compile
(let* ( (headings (regexp-opt '("title" "begin" "end") t))
(headings-opt (regexp-opt
'("chapter" "part"
"section" "subsection" "subsubsection"
"section*" "subsection*" "subsubsection*"
"paragraph" "subparagraph" "subsubparagraph"
"paragraph*" "subparagraph*" "subsubparagraph*"
"newcommand" "renewcommand" "newenvironment"
"newtheorem"
"newcommand*" "renewcommand*" "newenvironment*"
"newtheorem*")
t))
(variables (regexp-opt
'("newcounter" "newcounter*" "setcounter" "addtocounter"
"setlength" "addtolength" "settowidth")
t))
(includes (regexp-opt
'("input" "include" "includeonly" "bibliography"
"epsfig" "psfig" "epsf")
t))
(includes-opt (regexp-opt
'("nofiles" "usepackage"
"includegraphics" "includegraphics*")
t))
(slash "\\\\")
(opt "\\(\\[[^]]*\\]\\)?")
(arg "{\\([^}]+\\)")
(opt-depth (regexp-opt-depth opt))
(arg-depth (regexp-opt-depth arg))
)
(list
(list (concat slash headings arg)
(+ (regexp-opt-depth headings) arg-depth)
'font-lock-function-name-face)
(list (concat slash headings-opt opt arg)
(+ (regexp-opt-depth headings-opt) opt-depth arg-depth)
'font-lock-function-name-face)
(list (concat slash variables arg)
(+ (regexp-opt-depth variables) arg-depth)
'font-lock-variable-name-face)
(list (concat slash includes arg)
(+ (regexp-opt-depth includes) arg-depth)
'font-lock-builtin-face)
(list (concat slash includes-opt opt arg)
(+ (regexp-opt-depth includes-opt) opt-depth arg-depth)
'font-lock-builtin-face)
'("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)"
1 font-lock-function-name-face)
)))
"Subdued expressions to highlight in TeX modes.")
(defconst tex-font-lock-keywords-2
(append tex-font-lock-keywords-1
(eval-when-compile
(let* ( (bold (regexp-opt '("bf" "textbf" "textsc" "textup"
"boldsymbol" "pmb") t))
(italic (regexp-opt '("it" "textit" "textsl" "emph") t))
(type (regexp-opt '("texttt" "textmd" "textrm" "textsf") t))
(citations (regexp-opt
'("label" "ref" "pageref" "vref" "eqref")
t))
(citations-opt (regexp-opt
'("cite" "nocite" "caption" "index" "glossary"
"footnote" "footnotemark" "footnotetext")
t))
(specials (regexp-opt
'("\\"
"linebreak" "nolinebreak" "pagebreak" "nopagebreak"
"newline" "newpage" "clearpage" "cleardoublepage"
"displaybreak" "allowdisplaybreaks" "enlargethispage")
t))
(general "\\([a-zA-Z@]+\\**\\|[^ \t\n]\\)")
(slash "\\\\")
(opt "\\(\\[[^]]*\\]\\)?")
(arg "{\\([^}]+\\)")
(opt-depth (regexp-opt-depth opt))
(arg-depth (regexp-opt-depth arg))
)
(list
(list (concat slash citations arg)
(+ (regexp-opt-depth citations) arg-depth)
'font-lock-constant-face)
(list (concat slash citations-opt opt arg)
(+ (regexp-opt-depth citations-opt) opt-depth arg-depth)
'font-lock-constant-face)
(cons (concat slash specials) 'font-lock-warning-face)
(concat slash general)
(list (concat slash bold arg)
(+ (regexp-opt-depth bold) arg-depth)
'(quote bold) 'keep)
(list (concat slash italic arg)
(+ (regexp-opt-depth italic) arg-depth)
'(quote italic) 'keep)
(list (concat slash type arg)
(+ (regexp-opt-depth type) arg-depth)
'(quote bold-italic) 'keep)
(list (concat "\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>"
"\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)")
3 '(if (match-beginning 2) 'bold 'italic) 'keep)
))))
"Gaudy expressions to highlight in TeX modes.")
(defvar tex-font-lock-keywords tex-font-lock-keywords-1
"Default expressions to highlight in TeX 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")
"*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"
"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") t)))
(c-type-specs
(eval-when-compile
(regexp-opt '("enum" "struct" "union") t)))
(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)))
)
(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)))
'("^#[ \t]*\\(\\sw+\\)\\>[ \t!]*\\(\\sw+\\)?"
(1 font-lock-builtin-face) (2 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\\)\\>[ \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)))
)))
(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 nil
'(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)))))
(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"
"export"
"mutable" "explicit"
"typedef" "template"
"extern" "auto" "register" "const" "volatile" "static"
"inline" "friend" "virtual") t)))
(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\\)\\>[ \t]*\\(-?\\sw+\\)?"
(1 font-lock-keyword-face) (2 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)))
)))
)
(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") t)))
(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") t)))
(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)
'("@\\(author\\|exception\\|return\\|see\\|version\\)\\>"
(1 font-lock-constant-face prepend))
'("@\\(param\\)\\>[ \t]*\\(\\sw+\\)?"
(1 font-lock-constant-face prepend)
(2 font-lock-variable-name-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'.")
(unless (assq 'font-lock-mode minor-mode-alist)
(push '(font-lock-mode nil) minor-mode-alist))
(provide 'font-lock)