Variable: lisp-el-font-lock-keywords-2
lisp-el-font-lock-keywords-2 is a variable defined in lisp-mode.el.gz.
Value
Large value
(("(\\(cl-def\\(?:generic\\|m\\(?:acro\\|ethod\\)\\|s\\(?:\\(?:truc\\|ubs\\)t\\)\\|type\\|un\\)\\|def\\(?:a\\(?:dvice\\|lias\\)\\|c\\(?:lass\\|onst\\|ustom\\)\\|face\\|g\\(?:eneric\\|roup\\)\\|ine-\\(?:advice\\|derived-mode\\|error\\|g\\(?:\\(?:eneric\\|lobalized-minor\\)-mode\\)\\|inline\\|minor-mode\\|skeleton\\|widget\\)\\|m\\(?:acro\\|ethod\\)\\|subst\\|theme\\|un\\|var\\(?:-local\\|alias\\)?\\)\\|ert-deftest\\)\\_>[ ']*\\(([ ']*\\)?\\(\\(setf\\)[ ]+\\(?:\\w\\|\\s_\\|\\\\.\\)+\\|\\(?:\\w\\|\\s_\\|\\\\.\\)+\\)?"
(1 font-lock-keyword-face)
(3
(let
((type (get (intern-soft (match-string 1)) 'lisp-define-type)))
(cond ((eq type 'var) font-lock-variable-name-face)
((eq type 'type) font-lock-type-face)
((or (not (match-string 2))
(and (match-string 2) (match-string 4)))
font-lock-function-name-face)))
nil t))
("^;;;###\\(\\([-[:alnum:]]+?\\)-\\)?\\(autoload\\)"
(3 font-lock-warning-face prepend)
(2 font-lock-function-name-face prepend t))
("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend)
("(\\(cl-\\(?:assert\\|check-type\\)\\|error\\|signal\\|user-error\\|warn\\)\\_>"
(1 font-lock-warning-face))
(lisp--el-match-keyword . 1)
("(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\_>[ ']*\\(\\(?:\\w\\|\\s_\\|\\\\.\\)+\\)?"
(1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
("\\\\\\\\\\(?:\\[\\(?1:\\(?:\\w\\|\\s_\\|\\\\.\\)+[^\\]\\)]\\|`\\(?1:\\(?:\\w\\|\\s_\\|\\\\.\\)+\\(?: \\(?:\\w\\|\\s_\\|\\\\.\\)+\\)*\\)'\\)"
(1 font-lock-constant-face prepend))
("\\\\\\\\\\(?:<\\(?1:\\(?:\\w\\|\\s_\\|\\\\.\\)+[^\\]\\)>\\|{\\(?1:\\(?:\\w\\|\\s_\\|\\\\.\\)+[^\\]\\)}\\)"
(1 font-lock-variable-name-face prepend))
("\\(\\\\\\)\\([^\"\\]\\)" (1 (elisp--font-lock-backslash) prepend))
("[`‘']\\(\\(?:\\w\\|\\s_\\|\\\\.\\)+\\)['’]"
(1 font-lock-constant-face prepend))
("\\\\\\\\=" (0 font-lock-builtin-face prepend))
(#[257 "\300\301\"\207" [lisp-mode--search-key ":"] 4
("emacs-lisp/lisp-mode.elc" . 7671)]
(0 font-lock-builtin-face))
(#[257 "\300\301\"\207" [lisp-mode--search-key "&"] 4
("emacs-lisp/lisp-mode.elc" . 7671)]
(0 font-lock-type-face))
(#[257
"\30021�\301\302\303#\2050�\304\224\204�\305`S\306\"\211<\203!�\307>\204'�\211\307=\203,�\310\300\303\"\210\210\202�0\207"
[found re-search-forward
"\\(\\\\\\\\\\)\\(?:\\(\\\\\\\\\\)\\|\\((\\(?:\\?[0-9]*:\\)?\\|[|)]\\)\\)"
t 2 get-text-property face font-lock-string-face throw]
5 ("emacs-lisp/lisp-mode.elc" . 7671)]
(1 'font-lock-regexp-grouping-backslash prepend)
(3 'font-lock-regexp-grouping-construct prepend))
(lisp--match-hidden-arg
(0
'(face font-lock-warning-face help-echo
"Easy to misread; consider moving the element to the next line")
prepend))
(lisp--match-confusable-symbol-character 0
'(face
font-lock-warning-face
help-echo
"Confusable character")))
Documentation
Gaudy level highlighting for Emacs Lisp mode.
Aliases
lisp-font-lock-keywords-2 (obsolete since 24.4)
Source Code
;; Defined in /usr/src/emacs/lisp/emacs-lisp/lisp-mode.el.gz
(let-when-compile
((lisp-fdefs '("defmacro" "defun"))
(lisp-vdefs '("defvar"))
(lisp-kw '("cond" "if" "while" "let" "let*" "progn" "prog1"
"prog2" "lambda" "unwind-protect" "condition-case"
"when" "unless" "with-output-to-string" "handler-bind"
"ignore-errors" "dotimes" "dolist" "declare"))
(lisp-errs '("warn" "error" "signal"))
;; Elisp constructs. Now they are update dynamically
;; from obarray but they are also used for setting up
;; the keywords for Common Lisp.
(el-fdefs '("defsubst" "cl-defsubst" "define-inline"
"define-advice" "defadvice" "defalias"
"define-derived-mode" "define-minor-mode"
"define-generic-mode"
"define-globalized-minor-mode" "define-skeleton"
"define-widget" "ert-deftest"))
(el-vdefs '("defconst" "defcustom" "defvaralias" "defvar-local"
"defface" "define-error"))
(el-tdefs '("defgroup" "deftheme"))
(el-errs '("user-error"))
;; Common-Lisp constructs supported by EIEIO. FIXME: namespace.
(eieio-fdefs '("defgeneric" "defmethod"))
(eieio-tdefs '("defclass"))
;; Common-Lisp constructs supported by cl-lib.
(cl-lib-fdefs '("defmacro" "defsubst" "defun" "defmethod" "defgeneric"))
(cl-lib-tdefs '("defstruct" "deftype"))
(cl-lib-errs '("assert" "check-type"))
;; Common-Lisp constructs not supported by cl-lib.
(cl-fdefs '("defsetf" "define-method-combination"
"define-condition" "define-setf-expander"
;; "define-function"??
"define-compiler-macro" "define-modify-macro"))
(cl-vdefs '("define-symbol-macro" "defconstant" "defparameter"))
(cl-tdefs '("defpackage" "defstruct" "deftype"))
(cl-kw '("block" "break" "case" "ccase" "compiler-let" "ctypecase"
"declaim" "destructuring-bind" "do" "do*"
"ecase" "etypecase" "eval-when" "flet" "flet*"
"go" "handler-case" "in-package" ;; "inline"
"labels" "letf" "locally" "loop"
"macrolet" "multiple-value-bind" "multiple-value-prog1"
"proclaim" "prog" "prog*" "progv"
"restart-case" "restart-bind" "return" "return-from"
"symbol-macrolet" "tagbody" "the" "typecase"
"with-accessors" "with-compilation-unit"
"with-condition-restarts" "with-hash-table-iterator"
"with-input-from-string" "with-open-file"
"with-open-stream" "with-package-iterator"
"with-simple-restart" "with-slots" "with-standard-io-syntax"))
(cl-errs '("abort" "cerror")))
(let ((vdefs (eval-when-compile
(append lisp-vdefs el-vdefs cl-vdefs)))
(tdefs (eval-when-compile
(append el-tdefs eieio-tdefs cl-tdefs cl-lib-tdefs
(mapcar (lambda (s) (concat "cl-" s)) cl-lib-tdefs))))
;; Elisp and Common Lisp definers.
(el-defs-re (eval-when-compile
(regexp-opt (append lisp-fdefs lisp-vdefs
el-fdefs el-vdefs el-tdefs
(mapcar (lambda (s) (concat "cl-" s))
(append cl-lib-fdefs cl-lib-tdefs))
eieio-fdefs eieio-tdefs)
t)))
(cl-defs-re (eval-when-compile
(regexp-opt (append lisp-fdefs lisp-vdefs
cl-lib-fdefs cl-lib-tdefs
eieio-fdefs eieio-tdefs
cl-fdefs cl-vdefs cl-tdefs)
t)))
;; Common Lisp keywords (Elisp keywords are handled dynamically).
(cl-kws-re (eval-when-compile
(regexp-opt (append lisp-kw cl-kw) t)))
;; Elisp and Common Lisp "errors".
(el-errs-re (eval-when-compile
(regexp-opt (append (mapcar (lambda (s) (concat "cl-" s))
cl-lib-errs)
lisp-errs el-errs)
t)))
(cl-errs-re (eval-when-compile
(regexp-opt (append lisp-errs cl-lib-errs cl-errs) t))))
(dolist (v vdefs)
(put (intern v) 'lisp-define-type 'var))
(dolist (v tdefs)
(put (intern v) 'lisp-define-type 'type))
(define-obsolete-variable-alias 'lisp-font-lock-keywords-1
'lisp-el-font-lock-keywords-1 "24.4")
(defconst lisp-el-font-lock-keywords-1
`( ;; Definitions.
(,(concat "(" el-defs-re "\\_>"
;; Any whitespace and defined object.
"[ \t']*"
"\\(([ \t']*\\)?" ;; An opening paren.
"\\(\\(setf\\)[ \t]+" (rx lisp-mode-symbol)
"\\|" (rx lisp-mode-symbol) "\\)?")
(1 font-lock-keyword-face)
(3 (let ((type (get (intern-soft (match-string 1)) 'lisp-define-type)))
(cond ((eq type 'var) font-lock-variable-name-face)
((eq type 'type) font-lock-type-face)
;; If match-string 2 is non-nil, we encountered a
;; form like (defalias (intern (concat s "-p"))),
;; unless match-string 4 is also there. Then its a
;; defmethod with (setf foo) as name.
((or (not (match-string 2)) ;; Normal defun.
(and (match-string 2) ;; Setf method.
(match-string 4)))
font-lock-function-name-face)))
nil t))
;; Emacs Lisp autoload cookies. Supports the slightly different
;; forms used by mh-e, calendar, etc.
(,lisp-mode-autoload-regexp (3 font-lock-warning-face prepend)
(2 font-lock-function-name-face prepend t)))
"Subdued level highlighting for Emacs Lisp mode.")
(defconst lisp-cl-font-lock-keywords-1
`( ;; Definitions.
(,(concat "(" cl-defs-re "\\_>"
;; Any whitespace and defined object.
"[ \t']*"
"\\(([ \t']*\\)?" ;; An opening paren.
"\\(\\(setf\\)[ \t]+" (rx lisp-mode-symbol)
"\\|" (rx lisp-mode-symbol) "\\)?")
(1 font-lock-keyword-face)
(3 (let ((type (get (intern-soft (match-string 1)) 'lisp-define-type)))
(cond ((eq type 'var) font-lock-variable-name-face)
((eq type 'type) font-lock-type-face)
((or (not (match-string 2)) ;; Normal defun.
(and (match-string 2) ;; Setf function.
(match-string 4)))
font-lock-function-name-face)))
nil t)))
"Subdued level highlighting for Lisp modes.")
(define-obsolete-variable-alias 'lisp-font-lock-keywords-2
'lisp-el-font-lock-keywords-2 "24.4")
(defconst lisp-el-font-lock-keywords-2
(append
lisp-el-font-lock-keywords-1
`( ;; Regexp negated char group.
("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend)
;; Erroneous structures.
(,(concat "(" el-errs-re "\\_>")
(1 font-lock-warning-face))
;; Control structures. Common Lisp forms.
(lisp--el-match-keyword . 1)
;; Exit/Feature symbols as constants.
(,(concat "(\\(catch\\|throw\\|featurep\\|provide\\|require\\)\\_>"
"[ \t']*\\(" (rx lisp-mode-symbol) "\\)?")
(1 font-lock-keyword-face)
(2 font-lock-constant-face nil t))
;; Words inside \\[], \\<>, \\{} or \\`' tend to be for
;; `substitute-command-keys'.
(,(rx "\\\\" (or (seq "["
(group-n 1 (seq lisp-mode-symbol (not "\\"))) "]")
(seq "`" (group-n 1
;; allow multiple words, e.g. "C-x a"
lisp-mode-symbol (* " " lisp-mode-symbol))
"'")))
(1 font-lock-constant-face prepend))
(,(rx "\\\\" (or (seq "<"
(group-n 1 (seq lisp-mode-symbol (not "\\"))) ">")
(seq "{"
(group-n 1 (seq lisp-mode-symbol (not "\\"))) "}")))
(1 font-lock-variable-name-face prepend))
;; Ineffective backslashes (typically in need of doubling).
("\\(\\\\\\)\\([^\"\\]\\)"
(1 (elisp--font-lock-backslash) prepend))
;; Words inside ‘’, '' and `' tend to be symbol names.
(,(concat "[`‘']\\(" (rx lisp-mode-symbol) "\\)['’]")
(1 font-lock-constant-face prepend))
;; \\= tends to be an escape in doc strings.
(,(rx "\\\\=")
(0 font-lock-builtin-face prepend))
;; Constant values.
(,(lambda (bound) (lisp-mode--search-key ":" bound))
(0 font-lock-builtin-face))
;; Elisp and Common Lisp `&' keywords as types.
(,(lambda (bound) (lisp-mode--search-key "&" bound))
(0 font-lock-type-face))
;; Elisp regexp grouping constructs
(,(lambda (bound)
(catch 'found
;; The following loop is needed to continue searching after matches
;; that do not occur in strings. The associated regexp matches one
;; of `\\\\' `\\(' `\\(?:' `\\|' `\\)'. `\\\\' has been included to
;; avoid highlighting, for example, `\\(' in `\\\\('.
(while (re-search-forward "\\(\\\\\\\\\\)\\(?:\\(\\\\\\\\\\)\\|\\((\\(?:\\?[0-9]*:\\)?\\|[|)]\\)\\)" bound t)
(unless (match-beginning 2)
(let ((face (get-text-property (1- (point)) 'face)))
(when (or (and (listp face)
(memq 'font-lock-string-face face))
(eq 'font-lock-string-face face))
(throw 'found t)))))))
(1 'font-lock-regexp-grouping-backslash prepend)
(3 'font-lock-regexp-grouping-construct prepend))
(lisp--match-hidden-arg
(0 '(face font-lock-warning-face
help-echo "Easy to misread; consider moving the element to the next line")
prepend))
(lisp--match-confusable-symbol-character
0 '(face font-lock-warning-face
help-echo "Confusable character"))
))
"Gaudy level highlighting for Emacs Lisp mode.")
(defconst lisp-cl-font-lock-keywords-2
(append
lisp-cl-font-lock-keywords-1
`( ;; Regexp negated char group.
("\\[\\(\\^\\)" 1 font-lock-negation-char-face prepend)
;; Control structures. Common Lisp forms.
(,(concat "(" cl-kws-re "\\_>") . 1)
;; Exit/Feature symbols as constants.
(,(concat "(\\(catch\\|throw\\|provide\\|require\\)\\_>"
"[ \t']*\\(" (rx lisp-mode-symbol) "\\)?")
(1 font-lock-keyword-face)
(2 font-lock-constant-face nil t))
;; Erroneous structures.
(,(concat "(" cl-errs-re "\\_>")
(1 font-lock-warning-face))
;; Words inside ‘’ and `' tend to be symbol names.
(,(concat "[`‘]\\("
(rx (* lisp-mode-symbol (+ space)) lisp-mode-symbol)
"\\)['’]")
(1 font-lock-constant-face prepend))
;; Uninterned symbols, e.g., (defpackage #:my-package ...)
;; must come before keywords below to have effect
(,(concat "#:" (rx lisp-mode-symbol) "") 0 font-lock-builtin-face)
;; Constant values.
(,(lambda (bound) (lisp-mode--search-key ":" bound))
(0 font-lock-builtin-face))
;; Elisp and Common Lisp `&' keywords as types.
(,(lambda (bound) (lisp-mode--search-key "&" bound))
(0 font-lock-type-face))
;; Elisp regexp grouping constructs
;; This is too general -- rms.
;; A user complained that he has functions whose names start with `do'
;; and that they get the wrong color.
;; That user has violated the https://www.cliki.net/Naming+conventions:
;; CL (but not EL!) `with-' (context) and `do-' (iteration)
(,(concat "(\\(\\(do-\\|with-\\)" (rx lisp-mode-symbol) "\\)")
(1 font-lock-keyword-face))
(lisp--match-hidden-arg
(0 '(face font-lock-warning-face
help-echo "Easy to misread; consider moving the element to the next line")
prepend))
))
"Gaudy level highlighting for Lisp modes.")))