;;; font-lock.el --- Electric font lock mode
-;; Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1992, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
-;; Author: jwz, then rms, then sm <simon@gnu.ai.mit.edu>
+;; Author: jwz, then rms, then sm <simon@gnu.org>
;; Maintainer: FSF
;; Keywords: languages, faces
;; properties appropriately.
;;
;; Fontification normally involves syntactic (i.e., strings and comments) and
-;; regexp (i.e., keywords and everything else) passes. The syntactic pass
-;; involves a syntax table and a syntax parsing function to determine the
-;; context of different parts of a region of text. It is necessary because
-;; generally strings and/or comments can span lines, and so the context of a
-;; given region is not necessarily apparent from the content of that region.
-;; Because the regexp pass only works within a given region, it is not
-;; generally appropriate for syntactic fontification. The regexp pass involves
-;; searching for given regexps (or calling given functions) within the given
-;; region. For each match of the regexp (or non-nil value of the called
-;; function), `face' text properties are added appropriately.
+;; regexp (i.e., keywords and everything else) passes. There are actually
+;; three passes; (a) the syntactic keyword pass, (b) the syntactic pass and (c)
+;; the keyword pass. Confused?
+;;
+;; The syntactic keyword pass places `syntax-table' text properties in the
+;; buffer according to the variable `font-lock-syntactic-keywords'. It is
+;; necessary because Emacs' syntax table is not powerful enough to describe all
+;; the different syntactic constructs required by the sort of people who decide
+;; that a single quote can be syntactic or not depending on the time of day.
+;; (What sort of person could decide to overload the meaning of a quote?)
+;; Obviously the syntactic keyword pass must occur before the syntactic pass.
+;;
+;; The syntactic pass places `face' text properties in the buffer according to
+;; syntactic context, i.e., according to the buffer's syntax table and buffer
+;; text's `syntax-table' text properties. It involves using a syntax parsing
+;; function to determine the context of different parts of a region of text. A
+;; syntax parsing function is necessary because generally strings and/or
+;; comments can span lines, and so the context of a given region is not
+;; necessarily apparent from the content of that region. Because the keyword
+;; pass only works within a given region, it is not generally appropriate for
+;; syntactic fontification. This is the first fontification pass that makes
+;; changes visible to the user; it fontifies strings and comments.
+;;
+;; The keyword pass places `face' text properties in the buffer according to
+;; the variable `font-lock-keywords'. It involves searching for given regexps
+;; (or calling given search functions) within the given region. This is the
+;; second fontification pass that makes changes visible to the user; it
+;; fontifies language reserved words, etc.
+;;
+;; Oh, and the answer is, "Yes, obviously just about everything should be done
+;; in a single syntactic pass, but the only syntactic parser available
+;; understands only strings and comments." Perhaps one day someone will write
+;; some syntactic parsers for common languages and a son-of-font-lock.el could
+;; use them rather then relying so heavily on the keyword (regexp) pass.
;;; How Font Lock mode supports modes or is supported by modes:
;; See the documentation for the variable `font-lock-keywords'.
;;
-;; Nasty regexps of the form "bar\\(\\|lo\\)\\|f\\(oo\\|u\\(\\|bar\\)\\)\\|lo"
-;; are made thusly: (make-regexp '("foo" "fu" "fubar" "bar" "barlo" "lo")) for
-;; efficiency. See /pub/gnu/emacs/elisp-archive/functions/make-regexp.el.Z on
-;; archive.cis.ohio-state.edu for this and other functions not just by sm.
+;; Efficient regexps for use as MATCHERs for `font-lock-keywords' and
+;; `font-lock-syntactic-keywords' can be generated via the function
+;; `regexp-opt', and their depth counted via the function `regexp-opt-depth'.
;;; Adding patterns for modes that already support Font Lock:
\f
;;; Code:
+;; Define core `font-lock' group.
(defgroup font-lock nil
"Font Lock mode text highlighting package."
:link '(custom-manual "(emacs)Font Lock")
:group 'faces)
-(defgroup font-lock-faces nil
- "Font Lock mode faces."
+(defgroup font-lock-highlighting-faces nil
+ "Faces for highlighting text."
:prefix "font-lock-"
- :link '(custom-manual "(emacs)Font Lock")
+ :group 'font-lock)
+
+(defgroup font-lock-extra-types nil
+ "Extra mode-specific type names for highlighting declarations."
+ :group 'font-lock)
+
+;; Define support mode groups here to impose `font-lock' group order.
+(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)
\f
;; User variables.
-(defcustom font-lock-verbose (* 0 1024)
- "*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)
- (const :tag "always" t)
- (integer :tag "size"))
+(defcustom font-lock-maximum-size (* 250 1024)
+ "*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
(integer :tag "level" 1)))))
:group 'font-lock)
-(defcustom font-lock-maximum-size (* 250 1024)
- "*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)
+(defcustom font-lock-verbose (* 0 1024)
+ "*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)
(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")))))
+ (other :tag "always" t))
:group 'font-lock)
\f
;; Fontification variables:
(defvar font-lock-keywords nil
- "*A list of the keywords to highlight.
-Each element should be of the form:
+ "A list of the keywords to highlight.
+Each element should have one of these forms:
MATCHER
(MATCHER . MATCH)
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, typically only MATCH-HIGHLIGHT is required.
+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) then MATCH-ANCHORED may be required.
+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).
-MATCH is the subexpression of MATCHER to be highlighted. MATCH can be
-calculated via the function `font-lock-keyword-depth'. FACENAME is an
-expression whose value is the face name to use. FACENAME's default attributes
-can be defined via the variable `font-lock-face-attributes'.
+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.
For example, an element of the form highlights (if not already highlighted):
- \"\\\\\\=<foo\\\\\\=>\" Discrete occurrences of \"foo\" in the value of the
+ \"\\\\\\=<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
+ (\"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
+ 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 as for MATCH-HIGHLIGHT with one exception; see below.
+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,
(\"\\\\\\=<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 \"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
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.
-Note that the MATCH-ANCHORED feature is experimental; in the future, we may
-replace it with other ways of providing this functionality.
-
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.
'((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
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+ ;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(font-lock-comment-start-regexp . "/[*/]")
(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
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+ ;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(font-lock-comment-start-regexp . "/[*/]")
(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
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+ ;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(font-lock-comment-start-regexp . "/[*/]")
(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") (?. . "w")) nil
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+ ;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(font-lock-comment-start-regexp . "/[*/]")
(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
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
- ;(font-lock-comment-start-regexp . ";")
- (font-lock-mark-block-function . mark-defun)))
- (scheme-mode-defaults
- '(scheme-font-lock-keywords
- nil t (("+-*/.<>=!?$%_&~^:" . "w")) beginning-of-defun
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+ ;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(font-lock-comment-start-regexp . ";")
(font-lock-mark-block-function . mark-defun)))
;; For TeX modes we could use `backward-paragraph' for the same reason.
;; However, we do specify a MARK-BLOCK function as that cannot result
;; in a mis-fontification even if it might not fontify enough. --sm.
(tex-mode-defaults
- '(tex-font-lock-keywords nil nil ((?$ . "\"")) nil
- ;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+ '((tex-font-lock-keywords
+ tex-font-lock-keywords-1 tex-font-lock-keywords-2)
+ nil nil ((?$ . "\"")) nil
+ ;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(font-lock-comment-start-regexp . "%")
(font-lock-mark-block-function . mark-paragraph)))
)
(cons 'objc-mode objc-mode-defaults)
(cons 'java-mode java-mode-defaults)
(cons 'emacs-lisp-mode lisp-mode-defaults)
- (cons 'inferior-scheme-mode scheme-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 'scheme-mode scheme-mode-defaults)
- (cons 'scheme-interaction-mode scheme-mode-defaults)
(cons 'slitex-mode tex-mode-defaults)
(cons 'tex-mode tex-mode-defaults)))
"Alist of fall-back Font Lock defaults for major modes.
"*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.
enclosing textual block and mark at the end.
This is normally set via `font-lock-defaults'.")
-;; Obsoleted by Emacs 19.35 parse-partial-sexp's COMMENTSTOP.
+;; Obsoleted by Emacs 20 parse-partial-sexp's COMMENTSTOP.
;(defvar font-lock-comment-start-regexp nil
; "*Regexp to match the start of a comment.
;This need not discriminate between genuine comments and quoted comment
(,@ body)
(when (and (not modified) (buffer-modified-p))
(set-buffer-modified-p nil)))))
- (put 'save-buffer-state 'lisp-indent-function 1))
+ (put 'save-buffer-state 'lisp-indent-function 1)
+ ;;
+ ;; Shut up the byte compiler.
+ (defvar global-font-lock-mode) ; Now a defcustom.
+ (defvar font-lock-face-attributes) ; Obsolete but respected if set.
+ (defvar font-lock-string-face) ; Used in syntactic fontification.
+ (defvar font-lock-comment-face))
;;;###autoload
(defun font-lock-mode (&optional arg)
lines around point), perhaps because modification on the current line caused
syntactic change on other lines, you can use \\[font-lock-fontify-block].
-The default Font Lock mode faces and their attributes are defined in the
-variable `font-lock-face-attributes', and Font Lock mode default settings in
-the variable `font-lock-defaults-alist'. You can set your own default settings
-for some mode, by setting a buffer local value for `font-lock-defaults', via
-its mode hook."
+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")
;; Don't turn on Font Lock mode if we don't have a display (we're running a
;; batch job) or if the buffer is invisible (the name starts with a space).
;; would also be contrary to the Principle of Least Surprise. sm.
(defvar font-lock-buffers nil) ; For remembering buffers.
-(defvar global-font-lock-mode nil)
+
+;;;###autoload
+(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)))
+
+;; Naughty hack. This variable was originally a `defvar' to keep track of
+;; whether Global Font Lock mode was turned on or not. As a `defcustom' with
+;; special `:set' and `:require' forms, we can provide custom mode control.
+(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'.
+You must modify via \\[customize] for this variable to have an effect."
+ :set (lambda (symbol value)
+ (global-font-lock-mode (or value 0)))
+ :type 'boolean
+ :group 'font-lock
+ :require 'font-lock)
(defcustom font-lock-global-modes t
"*Modes for which Font Lock mode is automagically turned on.
(repeat :inline t (symbol :tag "mode"))))
:group 'font-lock)
-;;;###autoload
-(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 ((off-p (if arg
- (<= (prefix-numeric-value arg) 0)
- global-font-lock-mode)))
- (if off-p
- (remove-hook 'find-file-hooks 'turn-on-font-lock-if-enabled)
- (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)))
- (when message
- (message "Global Font Lock mode is now %s." (if off-p "OFF" "ON")))
- (setq global-font-lock-mode (not off-p))))
-
(defun font-lock-change-major-mode ()
;; Turn off Font Lock mode if it's on.
(when font-lock-mode
(setq font-lock-fontified nil)))
(defun font-lock-default-fontify-region (beg end loudly)
- (save-buffer-state ((old-syntax-table (syntax-table)))
+ (save-buffer-state
+ ((parse-sexp-lookup-properties font-lock-syntactic-keywords)
+ (old-syntax-table (syntax-table)))
(unwind-protect
(save-restriction
(widen)
(set-syntax-table font-lock-syntax-table))
;; Now do the fontification.
(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))
(defun font-lock-default-unfontify-region (beg end)
(save-buffer-state nil
- (remove-text-properties beg end '(face nil))))
+ (remove-text-properties beg end '(face nil syntax-table nil))))
;; Called when any modification is made to buffer text.
(defun font-lock-after-change-function (beg end old-len)
- (save-excursion
- (save-match-data
- ;; Rescan between start of lines enclosing the region.
- (font-lock-fontify-region
- (progn (goto-char beg) (beginning-of-line) (point))
- (progn (goto-char end) (forward-line 1) (point))))))
+ (let ((inhibit-point-motion-hooks t))
+ (save-excursion
+ (save-match-data
+ ;; Rescan between start of lines enclosing the region.
+ (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.
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 (font-lock-beginning-of-syntax-function deactivate-mark)
+ (let ((inhibit-point-motion-hooks t) font-lock-beginning-of-syntax-function
+ deactivate-mark)
;; Make sure we have the right `font-lock-keywords' etc.
(if (not font-lock-mode) (font-lock-set-defaults))
(save-excursion
;;; End of Fontification functions.
\f
-;;; Syntactic fontification functions.
-
-;; These record the parse state at a particular position, always the start of a
-;; line. Used to make `font-lock-fontify-syntactically-region' faster.
-;; Previously, `font-lock-cache-position' was just a buffer position. However,
-;; under certain situations, this occasionally resulted in mis-fontification.
-;; I think the "situations" were deletion with Lazy Lock mode's deferral. sm.
-(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)
- ;;
- ;; Find the state at the `beginning-of-line' before `start'.
- (if (eq start cache)
- ;; Use the cache for the state of `start'.
- (setq state font-lock-cache-state)
- ;; Find the state of `start'.
- (if (null font-lock-beginning-of-syntax-function)
- ;; Use the state at the previous cache position, if any, or
- ;; otherwise calculate from `point-min'.
- (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)))
- ;; Call the function to move outside any syntactic block.
- (funcall font-lock-beginning-of-syntax-function)
- (setq state (parse-partial-sexp (point) start)))
- ;; Cache the state and position of `start'.
- (setq font-lock-cache-state state)
- (set-marker font-lock-cache-position start))
- ;;
- ;; If the region starts inside a string or comment, show the extent of it.
- (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)))
- ;;
- ;; Find each interesting place between here and `end'.
- (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)))))
-
-;;; End of Syntactic fontification functions.
-\f
;;; Additional text property functions.
;; The following text property functions should be builtins. This means they
;;; End of Additional text property functions.
\f
-;;; Regexp fontification functions.
+;;; Syntactic regexp fontification functions.
+
+;; These syntactic keyword pass functions are identical to those keyword pass
+;; functions below, with the following exceptions; (a) they operate on
+;; `font-lock-syntactic-keywords' of course, (b) they are all `defun' as speed
+;; is less of an issue, (c) eval of property value does not occur JIT as speed
+;; is less of an issue, (d) OVERRIDE cannot be `prepend' or `append' as it
+;; makes no sense for `syntax-table' property values, (e) they do not do it
+;; LOUDLY as it is not likely to be intensive.
+
+(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 value))
+ (setq value (eval value)))
+ (cond ((not start)
+ ;; No match but we might not signal an error.
+ (or (nth 3 highlight)
+ (error "No match %d in highlight %S" match highlight)))
+ ((not override)
+ ;; Cannot override existing fontification.
+ (or (text-property-not-all start end 'syntax-table nil)
+ (put-text-property start end 'syntax-table value)))
+ ((eq override t)
+ ;; Override existing fontification.
+ (put-text-property start end 'syntax-table value))
+ ((eq override 'keep)
+ ;; Keep existing fontification.
+ (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
+ ;; Evaluate PRE-MATCH-FORM.
+ (pre-match-value (eval (nth 1 keywords))))
+ ;; Set LIMIT to value of PRE-MATCH-FORM or the end of line.
+ (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
+ ;; Find an occurrence of `matcher' before `limit'.
+ (while (if (stringp matcher)
+ (re-search-forward matcher limit t)
+ (funcall matcher limit))
+ ;; Apply each highlight to this instance of `matcher'.
+ (setq highlights lowdarks)
+ (while highlights
+ (font-lock-apply-syntactic-highlight (car highlights))
+ (setq highlights (cdr highlights)))))
+ ;; Evaluate POST-MATCH-FORM.
+ (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."
+ ;; If `font-lock-syntactic-keywords' is a symbol, get the real keywords.
+ (when (symbolp font-lock-syntactic-keywords)
+ (setq font-lock-syntactic-keywords (font-lock-eval-keywords
+ font-lock-syntactic-keywords)))
+ ;; If `font-lock-syntactic-keywords' is not compiled, compile it.
+ (unless (eq (car font-lock-syntactic-keywords) t)
+ (setq font-lock-syntactic-keywords (font-lock-compile-keywords
+ font-lock-syntactic-keywords)))
+ ;; Get down to business.
+ (let ((case-fold-search font-lock-keywords-case-fold-search)
+ (keywords (cdr font-lock-syntactic-keywords))
+ keyword matcher highlights)
+ (while keywords
+ ;; Find an occurrence of `matcher' from `start' to `end'.
+ (setq keyword (car keywords) matcher (car keyword))
+ (goto-char start)
+ (while (if (stringp matcher)
+ (re-search-forward matcher end t)
+ (funcall matcher end))
+ ;; Apply each highlight to this instance of `matcher', which may be
+ ;; specific highlights or more keywords anchored to `matcher'.
+ (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)))))
+
+;;; End of Syntactic regexp fontification functions.
+\f
+;;; Syntactic fontification functions.
+
+;; These record the parse state at a particular position, always the start of a
+;; line. Used to make `font-lock-fontify-syntactically-region' faster.
+;; Previously, `font-lock-cache-position' was just a buffer position. However,
+;; under certain situations, this occasionally resulted in mis-fontification.
+;; I think the "situations" were deletion with Lazy Lock mode's deferral. sm.
+(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)
+ ;;
+ ;; Find the state at the `beginning-of-line' before `start'.
+ (if (eq start cache)
+ ;; Use the cache for the state of `start'.
+ (setq state font-lock-cache-state)
+ ;; Find the state of `start'.
+ (if (null font-lock-beginning-of-syntax-function)
+ ;; Use the state at the previous cache position, if any, or
+ ;; otherwise calculate from `point-min'.
+ (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)))
+ ;; Call the function to move outside any syntactic block.
+ (funcall font-lock-beginning-of-syntax-function)
+ (setq state (parse-partial-sexp (point) start)))
+ ;; Cache the state and position of `start'.
+ (setq font-lock-cache-state state)
+ (set-marker font-lock-cache-position start))
+ ;;
+ ;; If the region starts inside a string or comment, show the extent of it.
+ (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)))
+ ;;
+ ;; Find each interesting place between here and `end'.
+ (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)))))
+
+;;; End of Syntactic fontification functions.
+\f
+;;; Keyword regexp fontification functions.
(defsubst font-lock-apply-highlight (highlight)
"Apply HIGHLIGHT following a match.
(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-safe font-lock-keywords) t)
+ (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))
(setq highlights (cdr highlights))))
(setq keywords (cdr keywords)))))
-;;; End of Regexp fontification functions.
+;;; End of Keyword regexp fontification functions.
\f
;; Various functions.
(t ; (MATCHER HIGHLIGHT ...)
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.
(local (cdr (assq major-mode font-lock-keywords-alist))))
;; Regexp fontification?
(set (make-local-variable 'font-lock-keywords)
- (if (fboundp keywords) (funcall keywords) (eval keywords)))
+ (font-lock-compile-keywords (font-lock-eval-keywords keywords)))
;; Local fontification?
(while local
(font-lock-add-keywords nil (car (car local)) (cdr (car local)))
(while alist
(let ((variable (car (car alist))) (value (cdr (car alist))))
(unless (boundp variable)
- (setq variable nil))
+ (set variable nil))
(set (make-local-variable variable) value)
(setq alist (cdr alist))))))))
"Face name to use for variable names.")
(defvar font-lock-type-face 'font-lock-type-face
- "Face name to use for type names.")
+ "Face name to use for type and class names.")
-(defvar font-lock-reference-face 'font-lock-reference-face
- "Face name to use for reference 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.")
+
+;; Originally face attributes were specified via `font-lock-face-attributes'.
+;; Users then changed the default face attributes by setting that variable.
+;; However, we try and be back-compatible and respect its value if set except
+;; for faces where M-x customize has been used to save changes for the 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)))
+ ;; Rustle up a `defface' SPEC from a `font-lock-face-attributes' entry.
+ (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)))))))
+
+;; But now we do it the custom way. Note that `defface' will not overwrite any
+;; faces declared above via `custom-declare-face'.
(defface font-lock-comment-face
'((((class grayscale) (background light))
(:foreground "DimGray" :bold t :italic t))
(((class color) (background dark)) (:foreground "OrangeRed"))
(t (:bold t :italic t)))
"Font Lock mode face used to highlight comments."
- :group 'font-lock-faces)
+ :group 'font-lock-highlighting-faces)
(defface font-lock-string-face
'((((class grayscale) (background light)) (:foreground "DimGray" :italic t))
(((class color) (background dark)) (:foreground "LightSalmon"))
(t (:italic t)))
"Font Lock mode face used to highlight strings."
- :group 'font-lock-faces)
+ :group 'font-lock-highlighting-faces)
(defface font-lock-keyword-face
'((((class grayscale) (background light)) (:foreground "LightGray" :bold t))
(((class color) (background dark)) (:foreground "Cyan"))
(t (:bold t)))
"Font Lock mode face used to highlight keywords."
- :group 'font-lock-faces)
+ :group 'font-lock-highlighting-faces)
(defface font-lock-builtin-face
'((((class grayscale) (background light)) (:foreground "LightGray" :bold t))
(((class color) (background dark)) (:foreground "LightSteelBlue"))
(t (:bold t)))
"Font Lock mode face used to highlight builtins."
- :group 'font-lock-faces)
+ :group 'font-lock-highlighting-faces)
(defface font-lock-function-name-face
- ;; Currently, Emacs/Custom does not support a :reverse or :invert spec.
'((((class color) (background light)) (:foreground "Blue"))
(((class color) (background dark)) (:foreground "LightSkyBlue"))
- (t ;(:reverse t :bold t)
- (:italic t :bold t)))
+ (t (:inverse-video t :bold t)))
"Font Lock mode face used to highlight function names."
- :group 'font-lock-faces)
+ :group 'font-lock-highlighting-faces)
(defface font-lock-variable-name-face
'((((class grayscale) (background light))
(((class color) (background dark)) (:foreground "LightGoldenrod"))
(t (:bold t :italic t)))
"Font Lock mode face used to highlight variable names."
- :group 'font-lock-faces)
+ :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 "DarkOliveGreen"))
+ (((class color) (background light)) (:foreground "ForestGreen"))
(((class color) (background dark)) (:foreground "PaleGreen"))
(t (:bold t :underline t)))
- "Font Lock mode face used to highlight types."
- :group 'font-lock-faces)
+ "Font Lock mode face used to highlight type and classes."
+ :group 'font-lock-highlighting-faces)
-(defface font-lock-reference-face
+(defface font-lock-constant-face
'((((class grayscale) (background light))
(:foreground "LightGray" :bold t :underline t))
(((class grayscale) (background dark))
(((class color) (background light)) (:foreground "CadetBlue"))
(((class color) (background dark)) (:foreground "Aquamarine"))
(t (:bold t :underline t)))
- "Font Lock mode face used to highlight references."
- :group 'font-lock-faces)
+ "Font Lock mode face used to highlight constants and labels."
+ :group 'font-lock-highlighting-faces)
(defface font-lock-warning-face
- ;; Currently, Emacs/Custom does not support a :reverse or :invert spec.
'((((class color) (background light)) (:foreground "Red" :bold t))
(((class color) (background dark)) (:foreground "Pink" :bold t))
- (t ;(:reverse t :bold t)
- (:italic t :bold t)))
+ (t (:inverse-video t :bold t)))
"Font Lock mode face used to highlight warnings."
- :group 'font-lock-faces)
+ :group 'font-lock-highlighting-faces)
;;; End of Colour etc. support.
\f
;; the entry for "Text Properties" something like:
;;
;; (define-key menu-bar-edit-menu [font-lock]
-;; '("Syntax Highlighting" . font-lock-menu))
+;; (cons "Syntax Highlighting" font-lock-menu))
;;
;; and remove a single ";" from the beginning of each line in the rest of this
;; section. Probably the mechanism for telling the menu code what are menu
; (put 'font-lock-fontify-less 'menu-enable '(identity)))
;
;;; Put the appropriate symbol property values on now. See above.
-;(put 'global-font-lock-mode 'menu-selected 'global-font-lock-mode))
+;(put 'global-font-lock-mode 'menu-selected 'global-font-lock-mode)
;(put 'font-lock-mode 'menu-selected 'font-lock-mode)
;(put 'font-lock-fontify-more 'menu-enable '(nth 2 font-lock-fontify-level))
;(put 'font-lock-fontify-less 'menu-enable '(nth 1 font-lock-fontify-level))
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', possibly ending
-with optional whitespace and 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 `;'.
+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 (
^^^^ ^
(goto-char (or (scan-sexps (point) 1) (point-max))))
(goto-char (match-end 2)))
(error t)))))
-
-(defun font-lock-keyword-depth (keyword)
- "Return the depth of KEYWORD regexp.
-This means the number of parenthesized expressions."
- (let ((count 0) start)
- (while (string-match "\\\\(" keyword start)
- (setq count (1+ count) start (match-end 0)))
- count))
-
+\f
+;; Lisp.
(defconst lisp-font-lock-keywords-1
(eval-when-compile
;; Definitions.
(list (concat "(\\(def\\("
;; Function declarations.
- "\\(advice\\|alias\\|"
- "ine-\\(derived-mode\\|function\\|skeleton\\)\\|"
- "macro\\|subst\\|un\\)\\|"
+ "\\(advice\\|alias\\|generic\\|macro\\*?\\|method\\|"
+ "setf\\|subst\\*?\\|un\\*?\\|"
+ "ine-\\(derived-mode\\|function\\|condition\\|"
+ "skeleton\\|widget\\|setf-expander\\|method-combination\\|"
+ "\\(symbol\\|compiler\\|modify\\)-macro\\)\\)\\|"
;; Variable declarations.
"\\(const\\|custom\\|face\\|var\\)\\|"
;; Structure declarations.
- "\\(class\\|group\\|struct\\|type\\)"
+ "\\(class\\|group\\|package\\|struct\\|type\\)"
"\\)\\)\\>"
;; Any whitespace and defined object.
"[ \t'\(]*"
"\\(\\sw+\\)?")
'(1 font-lock-keyword-face)
- '(7 (cond ((match-beginning 3) font-lock-function-name-face)
- ((match-beginning 5) font-lock-variable-name-face)
+ '(8 (cond ((match-beginning 3) font-lock-function-name-face)
+ ((match-beginning 4) font-lock-function-name-face)
+ ((match-beginning 6) font-lock-variable-name-face)
(t font-lock-type-face))
nil t))
;;
;; Emacs Lisp autoload cookies.
- '("^;;;\\(###\\)\\(autoload\\)\\>"
- (1 font-lock-reference-face prepend)
- (2 font-lock-warning-face prepend))
+ '("^;;;###\\(autoload\\)\\>" 1 font-lock-warning-face prepend)
))
"Subdued level highlighting for Lisp modes.")
(list
;;
;; Control structures. Emacs Lisp forms.
- (cons (concat "(\\("
-; (make-regexp
-; '("cond" "if" "while" "let\\*?" "prog[nv12*]?" "catch" "throw"
-; "inline" "save-restriction" "save-excursion" "save-window-excursion"
-; "save-selected-window" "save-match-data" "save-current-buffer"
-; "unwind-protect" "condition-case" "track-mouse" "dont-compile"
-; "eval-after-load" "eval-and-compile" "eval-when" "eval-when-compile"
-; "with-output-to-temp-buffer" "with-timeout" "with-current-buffer"
-; "with-temp-buffer" "with-temp-file"))
- "c\\(atch\\|ond\\(\\|ition-case\\)\\)\\|dont-compile\\|"
- "eval-\\(a\\(fter-load\\|nd-compile\\)\\|"
- "when\\(\\|-compile\\)\\)\\|"
- "i\\(f\\|nline\\)\\|let\\*?\\|prog[nv12*]?\\|"
- "save-\\(current-buffer\\|excursion\\|match-data\\|"
- "restriction\\|selected-window\\|window-excursion\\)\\|"
- "t\\(hrow\\|rack-mouse\\)\\|unwind-protect\\|"
- "w\\(hile\\|ith-\\(current-buffer\\|"
- "output-to-temp-buffer\\|"
- "t\\(emp-\\(buffer\\|file\\)\\|imeout\\)\\)\\)"
- "\\)\\>")
+ (cons (concat
+ "(" (regexp-opt
+ '("cond" "if" "while" "catch" "throw" "let" "let*"
+ "prog" "progn" "progv" "prog1" "prog2" "prog*"
+ "inline" "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-timeout") t)
+ "\\>")
1)
;;
;; Control structures. Common Lisp forms.
- (cons (concat "(\\("
-; (make-regexp
-; '("when" "unless" "case" "ecase" "typecase" "etypecase"
-; "loop" "do\\*?" "dotimes" "dolist"
-; "proclaim" "declaim" "declare"
-; "lexical-let\\*?" "flet" "labels" "return" "return-from"))
- "case\\|d\\(ecla\\(im\\|re\\)\\|o\\(\\*?\\|"
- "list\\|times\\)\\)\\|e\\(case\\|typecase\\)\\|flet\\|"
- "l\\(abels\\|exical-let\\*?\\|oop\\)\\|proclaim\\|"
- "return\\(\\|-from\\)\\|typecase\\|unless\\|when"
- "\\)\\>")
+ (cons (concat
+ "(" (regexp-opt
+ '("when" "unless" "case" "ecase" "typecase" "etypecase"
+ "ccase" "ctypecase" "handler-case" "handler-bind"
+ "restart-bind" "restart-case"
+ "assert" "abort" "error" "cerror" "break" "ignore-errors"
+ "loop" "do" "do*" "dotimes" "dolist" "the"
+ "proclaim" "declaim" "declare" "symbol-macrolet"
+ "lexical-let" "lexical-let*" "flet" "labels" "compiler-let"
+ "destructuring-bind" "macrolet" "tagbody" "block"
+ "return" "return-from") t)
+ "\\>")
1)
;;
- ;; Feature symbols as references.
+ ;; Feature symbols as constants.
'("(\\(featurep\\|provide\\|require\\)\\>[ \t']*\\(\\sw+\\)?"
- (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
+ (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
;;
;; Words inside \\[] tend to be for `substitute-command-keys'.
- '("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-reference-face prepend)
+ '("\\\\\\\\\\[\\(\\sw+\\)]" 1 font-lock-constant-face prepend)
;;
;; Words inside `' tend to be symbol names.
- '("`\\(\\sw\\sw+\\)'" 1 font-lock-reference-face prepend)
+ '("`\\(\\sw\\sw+\\)'" 1 font-lock-constant-face prepend)
;;
- ;; CLisp `:' keywords as builtins.
+ ;; Constant values.
'("\\<:\\sw\\sw+\\>" 0 font-lock-builtin-face)
;;
;; ELisp and CLisp `&' keywords as types.
)))
"Gaudy level highlighting for Lisp modes.")
-
(defvar lisp-font-lock-keywords lisp-font-lock-keywords-1
"Default expressions to highlight in Lisp modes.")
+\f
+;; TeX.
-
-(defvar scheme-font-lock-keywords
- (eval-when-compile
- (list
- ;;
- ;; Declarations. Hannes Haug <hannes.haug@student.uni-tuebingen.de> says
- ;; this works for SOS, STklos, SCOOPS, Meroon and Tiny CLOS.
- (list (concat "(\\(define\\("
- ;; Function names.
- "\\(\\|-\\(generic\\(\\|-procedure\\)\\|method\\)\\)\\|"
- ;; Macro names, as variable names. A bit dubious, this.
- "\\(-syntax\\)\\|"
- ;; Class names.
- "-class"
- "\\)\\)\\>"
- ;; Any whitespace and declared object.
- "[ \t]*(?"
- "\\(\\sw+\\)?")
- '(1 font-lock-keyword-face)
- '(7 (cond ((match-beginning 3) font-lock-function-name-face)
- ((match-beginning 6) font-lock-variable-name-face)
- (t font-lock-type-face))
- nil t))
- ;;
- ;; Control structures.
-;(make-regexp '("begin" "call-with-current-continuation" "call/cc"
-; "call-with-input-file" "call-with-output-file" "case" "cond"
-; "do" "else" "for-each" "if" "lambda"
-; "let\\*?" "let-syntax" "letrec" "letrec-syntax"
-; ;; Hannes Haug <hannes.haug@student.uni-tuebingen.de> wants:
-; "and" "or" "delay"
-; ;; Stefan Monnier <stefan.monnier@epfl.ch> says don't bother:
-; ;;"quasiquote" "quote" "unquote" "unquote-splicing"
-; "map" "syntax" "syntax-rules"))
- (cons
- (concat "(\\("
- "and\\|begin\\|c\\(a\\(ll\\(-with-\\(current-continuation\\|"
- "input-file\\|output-file\\)\\|/cc\\)\\|se\\)\\|ond\\)\\|"
- "d\\(elay\\|o\\)\\|else\\|for-each\\|if\\|"
- "l\\(ambda\\|et\\(-syntax\\|\\*?\\|rec\\(\\|-syntax\\)\\)\\)\\|"
- "map\\|or\\|syntax\\(\\|-rules\\)"
- "\\)\\>") 1)
- ;;
- ;; David Fox <fox@graphics.cs.nyu.edu> for SOS/STklos class specifiers.
- '("\\<<\\sw+>\\>" . font-lock-type-face)
- ;;
- ;; Scheme `:' keywords as references.
- '("\\<:\\sw+\\>" . font-lock-reference-face)
- ))
- "Default expressions to highlight in Scheme modes.")
-
-
-(defvar tex-font-lock-keywords
+;(defvar tex-font-lock-keywords
; ;; Regexps updated with help from Ulrik Dickow <dickow@nbi.dk>.
; '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
; 2 font-lock-function-name-face)
; ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
-; 2 font-lock-reference-face)
+; 2 font-lock-constant-face)
; ;; It seems a bit dubious to use `bold' and `italic' faces since we might
; ;; not be able to display those fonts.
; ("{\\\\bf\\([^}]+\\)}" 1 'bold keep)
; ("{\\\\\\(em\\|it\\|sl\\)\\([^}]+\\)}" 2 'italic keep)
; ("\\\\\\([a-zA-Z@]+\\|.\\)" . font-lock-keyword-face)
; ("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face keep))
- ;; Rewritten and extended for LaTeX2e by Ulrik Dickow <dickow@nbi.dk>.
- '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
- 2 font-lock-function-name-face)
- ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
- 2 font-lock-reference-face)
- ("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)" 1 font-lock-function-name-face)
- "\\\\\\([a-zA-Z@]+\\|.\\)"
- ;; It seems a bit dubious to use `bold' and `italic' faces since we might
- ;; not be able to display those fonts.
- ;; LaTeX2e: \emph{This is emphasized}.
- ("\\\\emph{\\([^}]+\\)}" 1 'italic keep)
- ;; LaTeX2e: \textbf{This is bold}, \textit{...}, \textsl{...}
- ("\\\\text\\(\\(bf\\)\\|it\\|sl\\){\\([^}]+\\)}"
- 3 (if (match-beginning 2) 'bold 'italic) keep)
- ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for good tables.
- ("\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)"
- 3 (if (match-beginning 2) 'bold 'italic) keep))
+; ;; Rewritten and extended for LaTeX2e by Ulrik Dickow <dickow@nbi.dk>.
+; '(("\\\\\\(begin\\|end\\|newcommand\\){\\([a-zA-Z0-9\\*]+\\)}"
+; 2 font-lock-function-name-face)
+; ("\\\\\\(cite\\|label\\|pageref\\|ref\\){\\([^} \t\n]+\\)}"
+; 2 font-lock-constant-face)
+; ("^[ \t]*\\\\def\\\\\\(\\(\\w\\|@\\)+\\)" 1 font-lock-function-name-face)
+; "\\\\\\([a-zA-Z@]+\\|.\\)"
+; ;; It seems a bit dubious to use `bold' and `italic' faces since we might
+; ;; not be able to display those fonts.
+; ;; LaTeX2e: \emph{This is emphasized}.
+; ("\\\\emph{\\([^}]+\\)}" 1 'italic keep)
+; ;; LaTeX2e: \textbf{This is bold}, \textit{...}, \textsl{...}
+; ("\\\\text\\(\\(bf\\)\\|it\\|sl\\){\\([^}]+\\)}"
+; 3 (if (match-beginning 2) 'bold 'italic) keep)
+; ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for tables.
+; ("\\\\\\(\\(bf\\)\\|em\\|it\\|sl\\)\\>\\(\\([^}&\\]\\|\\\\[^\\]\\)+\\)"
+; 3 (if (match-beginning 2) 'bold 'italic) keep))
+
+;; Rewritten with the help of Alexandra Bac <abac@welcome.disi.unige.it>.
+(defconst tex-font-lock-keywords-1
+ (eval-when-compile
+ (let* (;;
+ ;; Names of commands whose arg should be fontified as heading, etc.
+ (headings (regexp-opt '("title" "begin" "end") t))
+ ;; These commands have optional args.
+ (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))
+ ;; Miscellany.
+ (slash "\\\\")
+ (opt "\\(\\[[^]]*\\]\\)?")
+ (arg "{\\([^}]+\\)")
+ (opt-depth (regexp-opt-depth opt))
+ (arg-depth (regexp-opt-depth arg))
+ )
+ (list
+ ;;
+ ;; Heading args.
+ (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)
+ ;;
+ ;; Variable args.
+ (list (concat slash variables arg)
+ (+ (regexp-opt-depth variables) arg-depth)
+ 'font-lock-variable-name-face)
+ ;;
+ ;; Include args.
+ (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)
+ ;;
+ ;; Definitions. I think.
+ '("^[ \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* (;;
+ ;; Names of commands whose arg should be fontified with fonts.
+ (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))
+ ;;
+ ;; Names of commands whose arg should be fontified as a citation.
+ (citations (regexp-opt
+ '("label" "ref" "pageref" "vref" "eqref")
+ t))
+ (citations-opt (regexp-opt
+ '("cite" "caption" "index" "glossary"
+ "footnote" "footnotemark" "footnotetext")
+ t))
+ ;;
+ ;; Names of commands that should be fontified.
+ (specials (regexp-opt
+ '("\\"
+ "linebreak" "nolinebreak" "pagebreak" "nopagebreak"
+ "newline" "newpage" "clearpage" "cleardoublepage"
+ "displaybreak" "allowdisplaybreaks" "enlargethispage")
+ t))
+ (general "\\([a-zA-Z@]+\\**\\|[^ \t\n]\\)")
+ ;;
+ ;; Miscellany.
+ (slash "\\\\")
+ (opt "\\(\\[[^]]*\\]\\)?")
+ (arg "{\\([^}]+\\)")
+ (opt-depth (regexp-opt-depth opt))
+ (arg-depth (regexp-opt-depth arg))
+ )
+ (list
+ ;;
+ ;; Citation args.
+ (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)
+ ;;
+ ;; Command names, special and general.
+ (cons (concat slash specials) 'font-lock-warning-face)
+ (concat slash general)
+ ;;
+ ;; Font environments. It seems a bit dubious to use `bold' etc. faces
+ ;; since we might not be able to display those fonts.
+ (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)
+ ;;
+ ;; Old-style bf/em/it/sl. Stop at `\\' and un-escaped `&', for tables.
+ (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.")
\f
;;; User choices.
;; types might be the user's own or they might be generally accepted and used.
;; Generally accepted types are used to provide default variable values.
-(defvar c-font-lock-extra-types '("FILE" "\\sw+_t")
+(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.")
-
-(defvar c++-font-lock-extra-types '("string")
+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
+ '("\\([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")
"*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.")
+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)
-(defvar objc-font-lock-extra-types '("Class" "BOOL" "IMP" "SEL")
+(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.")
+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)
-(defvar java-font-lock-extra-types '("[A-Z\300-\326\330-\337]\\sw+")
+(defcustom java-font-lock-extra-types '("[A-Z\300-\326\330-\337]\\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+\") 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.")
+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)
\f
;;; C.
See also `c-font-lock-extra-types'.")
(let* ((c-keywords
-; ("break" "continue" "do" "else" "for" "if" "return" "switch" "while")
- "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|switch\\|while")
+ (eval-when-compile
+ (regexp-opt '("break" "continue" "do" "else" "for" "if" "return"
+ "switch" "while" "sizeof") t)))
(c-type-types
-; ("auto" "extern" "register" "static" "typedef" "struct" "union" "enum"
-; "signed" "unsigned" "short" "long" "int" "char" "float" "double"
-; "void" "volatile" "const")
`(mapconcat 'identity
(cons
- (,@ (concat "auto\\|c\\(har\\|onst\\)\\|double\\|"
- "e\\(num\\|xtern\\)\\|float\\|int\\|long\\|register\\|"
- "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|typedef\\|"
- "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)"))
+ (,@ (eval-when-compile
+ (regexp-opt
+ '("auto" "extern" "register" "static" "typedef" "struct"
+ "union" "enum" "signed" "unsigned" "short" "long"
+ "int" "char" "float" "double" "void" "volatile" "const"))))
c-font-lock-extra-types)
"\\|"))
- (c-type-depth `(font-lock-keyword-depth (,@ c-type-types)))
+ (c-type-depth `(regexp-opt-depth (,@ c-type-types)))
)
(setq c-font-lock-keywords-1
(list
'("^#[ \t]*error[ \t]+\\(.+\\)" 1 font-lock-warning-face prepend)
;;
;; Fontify filenames in #include <...> preprocessor directives as strings.
- '("^#[ \t]*\\(import\\|include\\)[ \t]+\\(<[^>\"\n]*>?\\)"
+ '("^#[ \t]*\\(import\\|include\\)[ \t]*\\(<[^>\"\n]*>?\\)"
2 font-lock-string-face)
;;
;; Fontify function macro names.
;; Fontify symbol names in #elif or #if ... defined preprocessor directives.
'("^#[ \t]*\\(elif\\|if\\)\\>"
("\\<\\(defined\\)\\>[ \t]*(?\\(\\sw+\\)?" nil nil
- (1 font-lock-reference-face) (2 font-lock-variable-name-face nil t)))
+ (1 font-lock-builtin-face) (2 font-lock-variable-name-face nil t)))
;;
;; Fontify otherwise as symbol names, and the preprocessor directive names.
- '("^#[ \t]*\\(\\sw+\\)\\>[ \t]*\\(\\sw+\\)?"
- (1 font-lock-reference-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
(cons (concat "\\<\\(" (,@ c-type-types) "\\)\\>") 'font-lock-type-face))
;;
;; Fontify all builtin keywords (except case, default and goto; see below).
- (concat "\\<\\(" c-keywords "\\)\\>")
+ (concat "\\<" c-keywords "\\>")
;;
;; Fontify case/goto keywords and targets, and case default/goto tags.
'("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"
- (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
+ (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
;; Anders Lindgren <andersl@csd.uu.se> points out that it is quicker to use
;; MATCH-ANCHORED to effectively anchor the regexp on the left.
+ ;; This must come after the one for keywords and targets.
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:"
(beginning-of-line) (end-of-line)
- (1 font-lock-reference-face)))
+ (1 font-lock-constant-face)))
)))
(setq c-font-lock-keywords-3
"[ \t*&]*"
;; This is `c++-type-spec' from below. (Hint hint!)
"\\(\\sw+\\)" ; The instance?
- "\\(<\\(\\sw+\\)[ \t*&]*>\\)?" ; Or template?
- "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)?" ; Or member?
+ "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?" ; Or template?
+ "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*" ; Or member?
;; Match any trailing parenthesis.
"[ \t]*\\((\\)?")))
(save-match-data
(error t)))))
(let* ((c++-keywords
-; ("break" "continue" "do" "else" "for" "if" "return" "switch" "while"
-; "asm" "catch" "delete" "new" "operator" "sizeof" "this" "throw" "try"
-; ;; Eric Hopper <hopper@omnifarious.mn.org> says these are new.
-; "static_cast" "dynamic_cast" "const_cast" "reinterpret_cast")
- (concat "asm\\|break\\|c\\(atch\\|on\\(st_cast\\|tinue\\)\\)\\|"
- "d\\(elete\\|o\\|ynamic_cast\\)\\|else\\|for\\|if\\|new\\|"
- "operator\\|re\\(interpret_cast\\|turn\\)\\|"
- "s\\(izeof\\|tatic_cast\\|"
- "witch\\)\\|t\\(h\\(is\\|row\\)\\|ry\\)\\|while"))
+ (eval-when-compile
+ (regexp-opt
+ '("break" "continue" "do" "else" "for" "if" "return" "switch"
+ "while" "asm" "catch" "delete" "new" "sizeof" "this" "throw" "try"
+ ;; Eric Hopper <hopper@omnifarious.mn.org> says these are new.
+ "static_cast" "dynamic_cast" "const_cast" "reinterpret_cast") t)))
(c++-operators
- (mapconcat 'identity
- (mapcar 'regexp-quote
- ;; Taken from Stroustrup, minus keywords otherwise fontified.
- (sort '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">"
- "+=" "-=" "*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>"
- ">>=" "<<=" "==" "!=" "<=" ">=" "&&" "||" "++" "--"
- "->*" "," "->" "[]" "()")
- #'(lambda (a b) (> (length a) (length b)))))
- "\\|"))
+ (eval-when-compile
+ (regexp-opt
+ ;; Taken from Stroustrup, minus keywords otherwise fontified.
+ '("+" "-" "*" "/" "%" "^" "&" "|" "~" "!" "=" "<" ">" "+=" "-="
+ "*=" "/=" "%=" "^=" "&=" "|=" "<<" ">>" ">>=" "<<=" "==" "!="
+ "<=" ">=" "&&" "||" "++" "--" "->*" "," "->" "[]" "()"))))
(c++-type-types
-; ("auto" "extern" "register" "static" "typedef" "struct" "union" "enum"
-; "signed" "unsigned" "short" "long" "int" "char" "float" "double"
-; "void" "volatile" "const" "inline" "friend" "bool"
-; "virtual" "complex" "template"
-; ;; Eric Hopper <hopper@omnifarious.mn.org> says these are new.
-; "namespace" "using")
`(mapconcat 'identity
(cons
- (,@ (concat "auto\\|bool\\|c\\(har\\|o\\(mplex\\|nst\\)\\)\\|"
- "double\\|e\\(num\\|xtern\\)\\|f\\(loat\\|riend\\)\\|"
- "in\\(line\\|t\\)\\|long\\|namespace\\|register\\|"
- "s\\(hort\\|igned\\|t\\(atic\\|ruct\\)\\)\\|"
- "t\\(emplate\\|ypedef\\)\\|"
- "u\\(n\\(ion\\|signed\\)\\|sing\\)\\|"
- "v\\(irtual\\|o\\(id\\|latile\\)\\)")) ; 12 ()s deep.
+ (,@ (eval-when-compile
+ (regexp-opt
+ '("extern" "auto" "register" "static" "typedef" "struct"
+ "union" "enum" "signed" "unsigned" "short" "long"
+ "int" "char" "float" "double" "void" "volatile" "const"
+ "inline" "friend" "bool" "virtual" "complex" "template"
+ "namespace" "using"
+ ;; Mark Mitchell <mmitchell@usa.net> says these are new.
+ "explicit" "mutable"
+ ;; Branko Cibej <branko.cibej@hermes.si> suggests this.
+ "export"))))
c++-font-lock-extra-types)
"\\|"))
;;
;; A brave attempt to match templates following a type and/or match
;; class membership. See and sync the above function
;; `font-lock-match-c++-style-declaration-item-and-skip-to-next'.
- (c++-type-suffix (concat "\\(<\\(\\sw+\\)[ \t*&]*>\\)?"
- "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)?"))
+ (c++-type-suffix (concat "\\([ \t]*<\\([^>\n]+\\)[ \t*&]*>\\)?"
+ "\\([ \t]*::[ \t*~]*\\(\\sw+\\)\\)*"))
;; If the string is a type, it may be followed by the cruft above.
(c++-type-spec (concat "\\(\\sw+\\)\\>" c++-type-suffix))
;;
;; Parenthesis depth of user-defined types not forgetting their cruft.
- (c++-type-depth `(font-lock-keyword-depth
+ (c++-type-depth `(regexp-opt-depth
(concat (,@ c++-type-types) (,@ c++-type-suffix))))
)
(setq c++-font-lock-keywords-1
(list
;;
;; Class names etc.
- (list (concat "\\<\\(class\\|public\\|private\\|protected\\)\\>[ \t]*"
+ (list (concat "\\<\\(class\\|public\\|private\\|protected\\|typename\\)\\>"
+ "[ \t]*"
"\\(" c++-type-spec "\\)?")
'(1 font-lock-type-face)
'(3 (if (match-beginning 6)
;;
;; Fontify case/goto keywords and targets, and case default/goto tags.
'("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"
- (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
+ (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
+ ;; This must come after the one for keywords and targets.
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:\\($\\|[^:]\\)"
(beginning-of-line) (end-of-line)
- (1 font-lock-reference-face)))
+ (1 font-lock-constant-face)))
;;
;; Fontify other builtin keywords.
- (cons (concat "\\<\\(" c++-keywords "\\)\\>") 'font-lock-keyword-face)
+ (concat "\\<" c++-keywords "\\>")
;;
;; Eric Hopper <hopper@omnifarious.mn.org> says `true' and `false' are new.
- '("\\<\\(false\\|true\\)\\>" . font-lock-reference-face)
+ '("\\<\\(false\\|true\\)\\>" . font-lock-constant-face)
)))
(setq c++-font-lock-keywords-3
;; Regexps written with help from Stephen Peters <speters@us.oracle.com> and
;; Jacques Duthen Prestataire <duthen@cegelec-red.fr>.
(let* ((objc-keywords
-; '("break" "continue" "do" "else" "for" "if" "return" "switch" "while"
-; "sizeof" "self" "super")
- (concat "break\\|continue\\|do\\|else\\|for\\|if\\|return\\|"
- "s\\(elf\\|izeof\\|uper\\|witch\\)\\|while"))
+ (eval-when-compile
+ (regexp-opt '("break" "continue" "do" "else" "for" "if" "return"
+ "switch" "while" "sizeof" "self" "super") t)))
(objc-type-types
`(mapconcat 'identity
(cons
-; '("auto" "extern" "register" "static" "typedef" "struct" "union"
-; "enum" "signed" "unsigned" "short" "long" "int" "char"
-; "float" "double" "void" "volatile" "const"
-; "id" "oneway" "in" "out" "inout" "bycopy" "byref")
- (,@ (concat "auto\\|by\\(copy\\|ref\\)\\|c\\(har\\|onst\\)\\|"
- "double\\|e\\(num\\|xtern\\)\\|float\\|"
- "i\\([dn]\\|n\\(out\\|t\\)\\)\\|long\\|"
- "o\\(neway\\|ut\\)\\|register\\|s\\(hort\\|igned\\|"
- "t\\(atic\\|ruct\\)\\)\\|typedef\\|"
- "un\\(ion\\|signed\\)\\|vo\\(id\\|latile\\)"))
+ (,@ (eval-when-compile
+ (regexp-opt
+ '("auto" "extern" "register" "static" "typedef" "struct"
+ "union" "enum" "signed" "unsigned" "short" "long"
+ "int" "char" "float" "double" "void" "volatile" "const"
+ "id" "oneway" "in" "out" "inout" "bycopy" "byref"))))
objc-font-lock-extra-types)
"\\|"))
- (objc-type-depth `(font-lock-keyword-depth (,@ objc-type-types)))
+ (objc-type-depth `(regexp-opt-depth (,@ objc-type-types)))
)
(setq objc-font-lock-keywords-1
(append
'font-lock-type-face))
;;
;; Fontify all builtin keywords (except case, default and goto; see below).
- (concat "\\<\\(" objc-keywords "\\)\\>")
+ (concat "\\<" objc-keywords "\\>")
;;
;; Fontify case/goto keywords and targets, and case default/goto tags.
'("\\<\\(case\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"
- (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
+ (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
;; Fontify tags iff sole statement on line, otherwise we detect selectors.
+ ;; This must come after the one for keywords and targets.
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:[ \t]*$"
(beginning-of-line) (end-of-line)
- (1 font-lock-reference-face)))
+ (1 font-lock-constant-face)))
;;
;; Fontify null object pointers.
- '("\\<\\(Nil\\|nil\\)\\>" 1 font-lock-reference-face)
+ '("\\<[Nn]il\\>" . font-lock-constant-face)
)))
(setq objc-font-lock-keywords-3
;; Regexps written with help from Fred White <fwhite@bbn.com> and
;; Anders Lindgren <andersl@csd.uu.se>.
(let* ((java-keywords
- (concat "\\<\\("
-; '("catch" "do" "else" "super" "this" "finally" "for" "if"
-;; ;; Anders Lindgren <andersl@csd.uu.se> says these have gone.
-;; "cast" "byvalue" "future" "generic" "operator" "var"
-;; "inner" "outer" "rest"
-; "interface" "return" "switch" "throw" "try" "while")
- "catch\\|do\\|else\\|f\\(inally\\|or\\)\\|"
- "i\\(f\\|nterface\\)\\|return\\|s\\(uper\\|witch\\)\\|"
- "t\\(h\\(is\\|row\\)\\|ry\\)\\|while"
- "\\)\\>"))
+ (eval-when-compile
+ (regexp-opt
+ '("catch" "do" "else" "super" "this" "finally" "for" "if"
+ ;; Anders Lindgren <andersl@csd.uu.se> says these have gone.
+ ;; "cast" "byvalue" "future" "generic" "operator" "var"
+ ;; "inner" "outer" "rest"
+ "interface" "return" "switch" "throw" "try" "while") t)))
;;
;; These are immediately followed by an object name.
(java-minor-types
- (mapconcat 'identity
- '("boolean" "char" "byte" "short" "int" "long"
- "float" "double" "void")
- "\\|"))
+ (eval-when-compile
+ (regexp-opt '("boolean" "char" "byte" "short" "int" "long"
+ "float" "double" "void"))))
;;
;; These are eventually followed by an object name.
(java-major-types
-; '("abstract" "const" "final" "synchronized" "transient" "static"
-;; ;; Anders Lindgren <andersl@csd.uu.se> says this has gone.
-;; "threadsafe"
-; "volatile" "public" "private" "protected" "native")
- (concat "abstract\\|const\\|final\\|native\\|"
- "p\\(r\\(ivate\\|otected\\)\\|ublic\\)\\|"
- "s\\(tatic\\|ynchronized\\)\\|transient\\|volatile"))
+ (eval-when-compile
+ (regexp-opt
+ '("abstract" "const" "final" "synchronized" "transient" "static"
+ ;; Anders Lindgren <andersl@csd.uu.se> says this has gone.
+ ;; "threadsafe"
+ "volatile" "public" "private" "protected" "native"))))
;;
;; Random types immediately followed by an object name.
(java-other-types
'(mapconcat 'identity (cons "\\sw+\\.\\sw+" java-font-lock-extra-types)
"\\|"))
- (java-other-depth `(font-lock-keyword-depth (,@ java-other-types)))
- )
+ (java-other-depth `(regexp-opt-depth (,@ java-other-types)))
+ )
(setq java-font-lock-keywords-1
(list
;;
;;
;; Fontify package names in import directives.
'("\\<\\(import\\|package\\)\\>[ \t]*\\(\\sw+\\)?"
- (1 font-lock-keyword-face) (2 font-lock-reference-face nil t))
+ (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
))
(setq java-font-lock-keywords-2
'font-lock-type-face)
;;
;; Fontify all builtin keywords (except below).
- (concat "\\<\\(" java-keywords "\\)\\>")
+ (concat "\\<" java-keywords "\\>")
;;
;; Fontify keywords and targets, and case default/goto tags.
(list "\\<\\(break\\|case\\|continue\\|goto\\)\\>[ \t]*\\(-?\\sw+\\)?"
- '(1 font-lock-keyword-face) '(2 font-lock-reference-face nil t))
+ '(1 font-lock-keyword-face) '(2 font-lock-constant-face nil t))
+ ;; This must come after the one for keywords and targets.
'(":" ("^[ \t]*\\(\\sw+\\)[ \t]*:"
(beginning-of-line) (end-of-line)
- (1 font-lock-reference-face)))
+ (1 font-lock-constant-face)))
;;
;; Fontify keywords and types; the first can be followed by a type list.
(list (concat "\\<\\("
(1 font-lock-type-face)))
;;
;; Fontify all constants.
- '("\\<\\(false\\|null\\|true\\)\\>" . font-lock-reference-face)
+ '("\\<\\(false\\|null\\|true\\)\\>" . font-lock-constant-face)
;;
;; Javadoc tags within comments.
'("@\\(author\\|exception\\|return\\|see\\|version\\)\\>"
- (1 font-lock-reference-face prepend))
+ (1 font-lock-constant-face prepend))
'("@\\(param\\)\\>[ \t]*\\(\\sw+\\)?"
- (1 font-lock-reference-face prepend)
+ (1 font-lock-constant-face prepend)
(2 font-lock-variable-name-face prepend t))
)))
;; Install ourselves:
(unless (assq 'font-lock-mode minor-mode-alist)
- (push '(font-lock-mode " Font") minor-mode-alist))
+ (push '(font-lock-mode nil) minor-mode-alist))
;; Provide ourselves:
HCoop / bpt / emacs.git / blobdiff