;;; font-lock.el --- Electric font lock mode
;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-;; 2000, 2001, 2002, 2003, 2004 2005 Free Software Foundation, Inc.
+;; 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
;; Author: jwz, then rms, then sm
;; Maintainer: FSF
;;
;; (add-hook 'foo-mode-hook
;; (lambda ()
-;; (make-local-variable 'font-lock-defaults)
-;; (setq font-lock-defaults '(foo-font-lock-keywords t))))
+;; (set (make-local-variable 'font-lock-defaults)
+;; '(foo-font-lock-keywords t))))
;;; Adding Font Lock support for modes:
;;
;; and within `bar-mode' there could be:
;;
-;; (make-local-variable 'font-lock-defaults)
-;; (setq font-lock-defaults '(bar-font-lock-keywords nil t))
+;; (set (make-local-variable 'font-lock-defaults)
+;; '(bar-font-lock-keywords nil t))
\f
;; What is fontification for? You might say, "It's to make my code look nice."
;; I think it should be for adding information in the form of cues. These cues
;; Define core `font-lock' group.
(defgroup font-lock '((jit-lock custom-group))
"Font Lock mode text highlighting package."
- :link '(custom-manual "(emacs)Font Lock")
- :link '(custom-manual "(elisp)Font Lock Mode")
+ :link '(custom-manual :tag "Emacs Manual" "(emacs)Font Lock")
+ :link '(custom-manual :tag "Elisp Manual" "(elisp)Font Lock Mode")
:group 'faces)
-(defgroup font-lock-highlighting-faces nil
+(defgroup font-lock-faces nil
"Faces for highlighting text."
:prefix "font-lock-"
:group 'font-lock)
;; Fontification variables:
-;;;###autoload
(defvar font-lock-keywords nil
"A list of the keywords to highlight.
There are two kinds of values: user-level, and compiled.
(defvar font-lock-keywords-alist nil
"Alist of additional `font-lock-keywords' elements for major modes.
-Each element has the form (MODE KEYWORDS . APPEND).
+Each element has the form (MODE KEYWORDS . HOW).
`font-lock-set-defaults' adds the elements in the list KEYWORDS to
`font-lock-keywords' when Font Lock is turned on in major mode MODE.
-If APPEND is nil, KEYWORDS are added at the beginning of
+If HOW is nil, KEYWORDS are added at the beginning of
`font-lock-keywords'. If it is `set', they are used to replace the
-value of `font-lock-keywords'. If APPEND is any other non-nil value,
+value of `font-lock-keywords'. If HOW is any other non-nil value,
they are added at the end.
This is normally set via `font-lock-add-keywords' and
;; Shut up the byte compiler.
(defvar font-lock-face-attributes)) ; Obsolete but respected if set.
-;;;###autoload
(defun font-lock-mode-internal (arg)
;; Turn on Font Lock mode.
(when arg
(font-lock-unfontify-buffer)
(font-lock-turn-off-thing-lock)))
-;;;###autoload
-(defun font-lock-add-keywords (mode keywords &optional append)
+(defun font-lock-add-keywords (mode keywords &optional how)
"Add highlighting KEYWORDS for MODE.
MODE should be a symbol, the major mode command name, such as `c-mode'
or nil. If nil, highlighting keywords are added for the current buffer.
KEYWORDS should be a list; see the variable `font-lock-keywords'.
By default they are added at the beginning of the current highlighting list.
-If optional argument APPEND is `set', they are used to replace the current
-highlighting list. If APPEND is any other non-nil value, they are added at the
+If optional argument HOW is `set', they are used to replace the current
+highlighting list. If HOW is any other non-nil value, they are added at the
end of the current highlighting list.
For example:
see the variables `c-font-lock-extra-types', `c++-font-lock-extra-types',
`objc-font-lock-extra-types' and `java-font-lock-extra-types'."
(cond (mode
- ;; If MODE is non-nil, add the KEYWORDS and APPEND spec to
+ ;; If MODE is non-nil, add the KEYWORDS and HOW spec to
;; `font-lock-keywords-alist' so `font-lock-set-defaults' uses them.
- (let ((spec (cons keywords append)) cell)
+ (let ((spec (cons keywords how)) cell)
(if (setq cell (assq mode font-lock-keywords-alist))
- (if (eq append 'set)
+ (if (eq how 'set)
(setcdr cell (list spec))
(setcdr cell (append (cdr cell) (list spec))))
(push (list mode spec) font-lock-keywords-alist)))
;; Make sure that `font-lock-removed-keywords-alist' does not
;; contain the new keywords.
- (font-lock-update-removed-keyword-alist mode keywords append))
+ (font-lock-update-removed-keyword-alist mode keywords how))
(t
;; Otherwise set or add the keywords now.
;; This is a no-op if it has been done already in this buffer
(if was-compiled
(setq font-lock-keywords (cadr font-lock-keywords)))
;; Now modify or replace them.
- (if (eq append 'set)
+ (if (eq how 'set)
(setq font-lock-keywords keywords)
(font-lock-remove-keywords nil keywords) ;to avoid duplicates
(let ((old (if (eq (car-safe font-lock-keywords) t)
(cdr font-lock-keywords)
font-lock-keywords)))
- (setq font-lock-keywords (if append
+ (setq font-lock-keywords (if how
(append old keywords)
(append keywords old)))))
;; If the keywords were compiled before, compile them again.
(if was-compiled
- (set (make-local-variable 'font-lock-keywords)
- (font-lock-compile-keywords font-lock-keywords t)))))))
+ (setq font-lock-keywords
+ (font-lock-compile-keywords font-lock-keywords t)))))))
-(defun font-lock-update-removed-keyword-alist (mode keywords append)
+(defun font-lock-update-removed-keyword-alist (mode keywords how)
"Update `font-lock-removed-keywords-alist' when adding new KEYWORDS to MODE."
;; When font-lock is enabled first all keywords in the list
;; `font-lock-keywords-alist' are added, then all keywords in the
;; will not take effect.
(let ((cell (assq mode font-lock-removed-keywords-alist)))
(if cell
- (if (eq append 'set)
+ (if (eq how 'set)
;; A new set of keywords is defined. Forget all about
;; our old keywords that should be removed.
(setq font-lock-removed-keywords-alist
;; is added and removed several times.
;;
;; (II) The keywords are removed from the current buffer.
-;;;###autoload
(defun font-lock-remove-keywords (mode keywords)
"Remove highlighting KEYWORDS for MODE.
;; If MODE is non-nil, remove the KEYWORD from
;; `font-lock-keywords-alist'.
(when top-cell
- (dolist (keyword-list-append-pair (cdr top-cell))
- ;; `keywords-list-append-pair' is a cons with a list of
- ;; keywords in the car top-cell and the original append
+ (dolist (keyword-list-how-pair (cdr top-cell))
+ ;; `keywords-list-how-pair' is a cons with a list of
+ ;; keywords in the car top-cell and the original how
;; argument in the cdr top-cell.
- (setcar keyword-list-append-pair
- (delete keyword (car keyword-list-append-pair))))
- ;; Remove keyword list/append pair when the keyword list
- ;; is empty and append doesn't specify `set'. (If it
+ (setcar keyword-list-how-pair
+ (delete keyword (car keyword-list-how-pair))))
+ ;; Remove keyword list/how pair when the keyword list
+ ;; is empty and how doesn't specify `set'. (If it
;; should be deleted then previously deleted keywords
;; would appear again.)
(let ((cell top-cell))
;; If the keywords were compiled before, compile them again.
(if was-compiled
- (set (make-local-variable 'font-lock-keywords)
- (font-lock-compile-keywords font-lock-keywords t)))))))
+ (setq font-lock-keywords
+ (font-lock-compile-keywords font-lock-keywords t)))))))
\f
;;; Font Lock Support mode.
;; directives correctly and cleanly. (It is the same problem as fontifying
;; multi-line strings and comments; regexps are not appropriate for the job.)
-;;;###autoload
(defun font-lock-fontify-buffer ()
"Fontify the current buffer the way the function `font-lock-mode' would."
(interactive)
+ (font-lock-set-defaults)
(let ((font-lock-verbose (or font-lock-verbose (interactive-p))))
(funcall font-lock-fontify-buffer-function)))
(funcall font-lock-unfontify-buffer-function))
(defun font-lock-fontify-region (beg end &optional loudly)
+ (font-lock-set-defaults)
(funcall font-lock-fontify-region-function beg end loudly))
(defun font-lock-unfontify-region (beg end)
(with-temp-message
(when verbose
(format "Fontifying %s..." (buffer-name)))
- ;; Make sure we have the right `font-lock-keywords' etc.
- (unless font-lock-mode
- (font-lock-set-defaults))
;; Make sure we fontify etc. in the whole buffer.
(save-restriction
(widen)
(font-lock-fontify-region (point) (mark)))
((error quit) (message "Fontifying block...%s" error-data)))))))
-(if (boundp 'facemenu-keymap)
- (define-key facemenu-keymap "\M-o" 'font-lock-fontify-block))
+(unless (featurep 'facemenu)
+ (error "facemenu must be loaded before font-lock"))
+(define-key facemenu-keymap "\M-o" 'font-lock-fontify-block)
;;; End of Fontification functions.
\f
`font-lock-keywords' doc string.
If REGEXP is non-nil, it means these keywords are used for
`font-lock-keywords' rather than for `font-lock-syntactic-keywords'."
+ (if (not font-lock-set-defaults)
+ ;; This should never happen. But some external packages sometimes
+ ;; call font-lock in unexpected and incorrect ways. It's important to
+ ;; stop processing at this point, otherwise we may end up changing the
+ ;; global value of font-lock-keywords and break highlighting in many
+ ;; other buffers.
+ (error "Font-lock trying to use keywords before setting them up"))
(if (eq (car-safe keywords) t)
keywords
(setq keywords
(cond ((not (and (listp keywords) (symbolp (car keywords))))
keywords)
((numberp level)
- (or (nth level keywords) (car (reverse keywords))))
+ (or (nth level keywords) (car (last keywords))))
((eq level t)
- (car (reverse keywords)))
+ (car (last keywords)))
(t
(car keywords))))
(font-lock-remove-keywords nil removed-keywords))
;; Now compile the keywords.
(unless (eq (car font-lock-keywords) t)
- (set (make-local-variable 'font-lock-keywords)
- (font-lock-compile-keywords font-lock-keywords t))))))
+ (setq font-lock-keywords
+ (font-lock-compile-keywords font-lock-keywords t))))))
\f
;;; Colour etc. support.
-;; 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 '(:weight bold) face-spec)))
- (when italic-p
- (setq face-spec (append '(:slant italic) 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'.
+;; 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" :weight bold :slant italic))
)
(t (:weight bold :slant italic)))
"Font Lock mode face used to highlight comments."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-comment-delimiter-face
'((default :inherit font-lock-comment-face)
(((class color) (min-colors 8) (background dark))
:foreground "red1"))
"Font Lock mode face used to highlight comment delimiters."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-string-face
'((((class grayscale) (background light)) (:foreground "DimGray" :slant italic))
(((class color) (min-colors 8)) (:foreground "green"))
(t (:slant italic)))
"Font Lock mode face used to highlight strings."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-doc-face
'((t :inherit font-lock-string-face))
"Font Lock mode face used to highlight documentation."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-keyword-face
'((((class grayscale) (background light)) (:foreground "LightGray" :weight bold))
(((class color) (min-colors 8)) (:foreground "cyan" :weight bold))
(t (:weight bold)))
"Font Lock mode face used to highlight keywords."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-builtin-face
'((((class grayscale) (background light)) (:foreground "LightGray" :weight bold))
(((class color) (min-colors 8)) (:foreground "blue" :weight bold))
(t (:weight bold)))
"Font Lock mode face used to highlight builtins."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-function-name-face
'((((class color) (min-colors 88) (background light)) (:foreground "Blue1"))
(((class color) (min-colors 8)) (:foreground "blue" :weight bold))
(t (:inverse-video t :weight bold)))
"Font Lock mode face used to highlight function names."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-variable-name-face
'((((class grayscale) (background light))
(((class color) (min-colors 8)) (:foreground "yellow" :weight light))
(t (:weight bold :slant italic)))
"Font Lock mode face used to highlight variable names."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-type-face
'((((class grayscale) (background light)) (:foreground "Gray90" :weight bold))
(((class color) (min-colors 8)) (:foreground "green"))
(t (:weight bold :underline t)))
"Font Lock mode face used to highlight type and classes."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-constant-face
'((((class grayscale) (background light))
(((class color) (min-colors 8)) (:foreground "magenta"))
(t (:weight bold :underline t)))
"Font Lock mode face used to highlight constants and labels."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-warning-face
'((((class color) (min-colors 88) (background light)) (:foreground "Red1" :weight bold))
(((class color) (min-colors 88) (background dark)) (:foreground "Pink" :weight bold))
- (((class color) (min-colors 16) (background light)) (:foreground "Red" :weight bold))
+ (((class color) (min-colors 16) (background light)) (:foreground "Red1" :weight bold))
(((class color) (min-colors 16) (background dark)) (:foreground "Pink" :weight bold))
(((class color) (min-colors 8)) (:foreground "red"))
(t (:inverse-video t :weight bold)))
"Font Lock mode face used to highlight warnings."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-negation-char-face
'((t nil))
"Font Lock mode face used to highlight easy to overlook negation."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-preprocessor-face
'((t :inherit font-lock-builtin-face))
"Font Lock mode face used to highlight preprocessor directives."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-regexp-grouping-backslash
'((t :inherit bold))
"Font Lock mode face for backslashes in Lisp regexp grouping constructs."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
(defface font-lock-regexp-grouping-construct
'((t :inherit bold))
"Font Lock mode face used to highlight grouping constructs in Lisp regexps."
- :group 'font-lock-highlighting-faces)
+ :group 'font-lock-faces)
;;; End of Colour etc. support.
\f
;; Function declarations.
"\\(advice\\|varalias\\|alias\\|generic\\|macro\\*?\\|method\\|"
"setf\\|subst\\*?\\|un\\*?\\|"
- "ine-\\(condition\\|\\(?:derived\\|minor\\|generic\\)-mode\\|"
+ "ine-\\(condition\\|"
+ "\\(?:derived\\|\\(?:global-\\)?minor\\|generic\\)-mode\\|"
"method-combination\\|setf-expander\\|skeleton\\|widget\\|"
"function\\|\\(compiler\\|modify\\|symbol\\)-macro\\)\\)\\|"
;; Variable declarations.