;;
;; To turn Font Lock mode on automatically, add this to your init file:
;;
-;; (add-hook 'emacs-lisp-mode-hook 'turn-on-font-lock)
+;; (add-hook 'emacs-lisp-mode-hook #'turn-on-font-lock)
;;
;; Or if you want to turn Font Lock mode on in many modes:
;;
(MATCHER HIGHLIGHT ...)
(eval . FORM)
-where MATCHER can be either the regexp to search for, or the function name to
-call to make the search (called with one argument, the limit of the search;
-it should return non-nil, move point, and set `match-data' appropriately if
-it succeeds; like `re-search-forward' would).
-MATCHER regexps can be generated via the function `regexp-opt'.
+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; it should return non-nil, move
+point, and set `match-data' appropriately if it succeeds; like
+`re-search-forward' would). MATCHER regexps can be generated via
+the function `regexp-opt'.
-FORM is an expression, whose value should be a keyword element, evaluated when
-the keyword is (first) used in a buffer. This feature can be used to provide a
-keyword that can only be generated when Font Lock mode is actually turned on.
+FORM is an expression, whose value should be a keyword element,
+evaluated when the keyword is (first) used in a buffer. This
+feature can be used to provide a keyword that can only be
+generated when Font Lock mode is actually turned on.
HIGHLIGHT should be either MATCH-HIGHLIGHT or MATCH-ANCHORED.
-For highlighting single items, for example each instance of the word \"foo\",
-typically only MATCH-HIGHLIGHT is required.
-However, if an item or (typically) items are to be highlighted following the
-instance of another item (the anchor), for example each instance of the
-word \"bar\" following the word \"anchor\" then MATCH-ANCHORED may be required.
+For highlighting single items, for example each instance of the
+word \"foo\", typically only MATCH-HIGHLIGHT is required.
+However, if an item or (typically) items are to be highlighted
+following the instance of another item (the anchor), for example
+each instance of the word \"bar\" following the word \"anchor\"
+then MATCH-ANCHORED may be required.
MATCH-HIGHLIGHT should be of the form:
(SUBEXP FACENAME [OVERRIDE [LAXMATCH]])
-SUBEXP is the number of the subexpression of MATCHER to be highlighted.
+SUBEXP is the number of the subexpression of MATCHER to be
+highlighted.
FACENAME is an expression whose value is the face name to use.
-Instead of a face, FACENAME can evaluate to a property list
-of the form (face FACE PROP1 VAL1 PROP2 VAL2 ...)
-in which case all the listed text-properties will be set rather than
-just FACE. In such a case, you will most likely want to put those
-properties in `font-lock-extra-managed-props' or to override
+Instead of a face, FACENAME can evaluate to a property list of
+the form (face FACE PROP1 VAL1 PROP2 VAL2 ...) in which case all
+the listed text-properties will be set rather than just FACE. In
+such a case, you will most likely want to put those properties in
+`font-lock-extra-managed-props' or to override
`font-lock-unfontify-region-function'.
-OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing fontification can
-be overwritten. If `keep', only parts not already fontified are highlighted.
-If `prepend' or `append', existing fontification is merged with the new, in
-which the new or existing fontification, respectively, takes precedence.
-If LAXMATCH is non-nil, that means don't signal an error if there is
+OVERRIDE and LAXMATCH are flags. If OVERRIDE is t, existing
+fontification can be overwritten. If `keep', only parts not
+already fontified are highlighted. If `prepend' or `append',
+existing fontification is merged with the new, in which the new
+or existing fontification, respectively, takes precedence. If
+LAXMATCH is non-nil, that means don't signal an error if there is
no match for SUBEXP in MATCHER.
-For example, an element of the form highlights (if not already highlighted):
+For example, an element of the form highlights (if not already
+highlighted):
+
+ \"\\\\\\=<foo\\\\\\=>\"
+ Discrete occurrences of \"foo\" in the value of the variable
+ `font-lock-keyword-face'.
+
+ (\"fu\\\\(bar\\\\)\" . 1)
+ Substring \"bar\" within all occurrences of \"fubar\" in the
+ value of `font-lock-keyword-face'.
+
+ (\"fubar\" . fubar-face)
+ Occurrences of \"fubar\" in the value of `fubar-face'.
- \"\\\\\\=<foo\\\\\\=>\" discrete occurrences of \"foo\" in the value of the
- variable `font-lock-keyword-face'.
- (\"fu\\\\(bar\\\\)\" . 1) substring \"bar\" within all occurrences of \"fubar\" in
- the value of `font-lock-keyword-face'.
- (\"fubar\" . fubar-face) Occurrences of \"fubar\" in the value of `fubar-face'.
(\"foo\\\\|bar\" 0 foo-bar-face t)
- occurrences of either \"foo\" or \"bar\" in the value
- of `foo-bar-face', even if already highlighted.
+ 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'.
+ The first subexpression within all occurrences of whatever the
+ function `fubar-match' finds and matches in the value of
+ `fubar-face'.
MATCH-ANCHORED should be of the form:
(MATCHER PRE-MATCH-FORM POST-MATCH-FORM MATCH-HIGHLIGHT ...)
-where MATCHER is a regexp to search for or the function name to call to make
-the search, as for MATCH-HIGHLIGHT above, but with one exception; see below.
-PRE-MATCH-FORM and POST-MATCH-FORM are evaluated before the first, and after
-the last, instance MATCH-ANCHORED's MATCHER is used. Therefore they can be
-used to initialize before, and cleanup after, MATCHER is used. Typically,
-PRE-MATCH-FORM is used to move to some position relative to the original
-MATCHER, before starting with MATCH-ANCHORED's MATCHER. POST-MATCH-FORM might
-be used to move back, before resuming with MATCH-ANCHORED's parent's MATCHER.
-
-For example, an element of the form highlights (if not already highlighted):
-
- (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face) (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
-
- discrete occurrences of \"anchor\" in the value of `anchor-face', and subsequent
- discrete occurrences of \"item\" (on the same line) in the value of `item-face'.
- (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore \"item\" is
- initially searched for starting from the end of the match of \"anchor\", and
- searching for subsequent instances of \"anchor\" resumes from where searching
- for \"item\" concluded.)
-
-The above-mentioned exception is as follows. The limit of the MATCHER search
-defaults to the end of the line after PRE-MATCH-FORM is evaluated.
-However, if PRE-MATCH-FORM returns a position greater than the position after
-PRE-MATCH-FORM is evaluated, that position is used as the limit of the search.
-It is generally a bad idea to return a position greater than the end of the
-line, i.e., cause the MATCHER search to span lines.
-
-These regular expressions can match text which spans lines, although
-it is better to avoid it if possible since updating them while editing
-text is slower, and it is not guaranteed to be always correct when using
-support modes like jit-lock or lazy-lock.
-
-This variable is set by major modes via the variable `font-lock-defaults'.
-Be careful when composing regexps for this list; a poorly written pattern can
-dramatically slow things down!
-
-A compiled keywords list starts with t. It is produced internally
-by `font-lock-compile-keywords' from a user-level keywords list.
-Its second element is the user-level keywords list that was
-compiled. The remaining elements have the same form as
-user-level keywords, but normally their values have been
+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
+initialize before, and cleanup after, MATCHER is used.
+Typically, PRE-MATCH-FORM is used to move to some position
+relative to the original MATCHER, before starting with
+MATCH-ANCHORED's MATCHER. POST-MATCH-FORM might be used to move
+back, before resuming with MATCH-ANCHORED's parent's MATCHER.
+
+For example, an element of the form highlights (if not already
+highlighted):
+
+ (\"\\\\\\=<anchor\\\\\\=>\" (0 anchor-face)
+ (\"\\\\\\=<item\\\\\\=>\" nil nil (0 item-face)))
+
+ Discrete occurrences of \"anchor\" in the value of
+ `anchor-face', and subsequent discrete occurrences of
+ \"item\" (on the same line) in the value of `item-face'.
+ (Here PRE-MATCH-FORM and POST-MATCH-FORM are nil. Therefore
+ \"item\" is initially searched for starting from the end of the
+ match of \"anchor\", and searching for subsequent instances of
+ \"anchor\" resumes from where searching for \"item\" concluded.)
+
+The above-mentioned exception is as follows. The limit of the
+MATCHER search defaults to the end of the line after
+PRE-MATCH-FORM is evaluated. However, if PRE-MATCH-FORM returns
+a position greater than the position after PRE-MATCH-FORM is
+evaluated, that position is used as the limit of the search. It
+is generally a bad idea to return a position greater than the end
+of the line, i.e., cause the MATCHER search to span lines.
+
+These regular expressions can match text which spans lines,
+although it is better to avoid it if possible since updating them
+while editing text is slower, and it is not guaranteed to be
+always correct when using support modes like jit-lock or
+lazy-lock.
+
+This variable is set by major modes via the variable
+`font-lock-defaults'. Be careful when composing regexps for this
+list; a poorly written pattern can dramatically slow things down!
+
+A compiled keywords list starts with t. It is produced
+internally by `font-lock-compile-keywords' from a user-level
+keywords list. Its second element is the user-level keywords
+list that was compiled. The remaining elements have the same
+form as user-level keywords, but normally their values have been
optimized.")
(defvar font-lock-keywords-alist nil
enclosing textual block and mark at the end.
This is normally set via `font-lock-defaults'.")
-(defvar font-lock-fontify-buffer-function 'font-lock-default-fontify-buffer
+(defvar font-lock-fontify-buffer-function #'font-lock-default-fontify-buffer
"Function to use for fontifying the buffer.
This is normally set via `font-lock-defaults'.")
-(defvar font-lock-unfontify-buffer-function 'font-lock-default-unfontify-buffer
+(defvar font-lock-unfontify-buffer-function #'font-lock-default-unfontify-buffer
"Function to use for unfontifying the buffer.
This is used when turning off Font Lock mode.
This is normally set via `font-lock-defaults'.")
\(jit-lock-bounds BEG . END) indicating the bounds of the region actually
fontified.")
-(defvar font-lock-unfontify-region-function 'font-lock-default-unfontify-region
+(defvar font-lock-unfontify-region-function #'font-lock-default-unfontify-region
"Function to use for unfontifying a region.
It should take two args, the beginning and end of the region.
This is normally set via `font-lock-defaults'.")
(defun font-lock-mode-internal (arg)
;; Turn on Font Lock mode.
(when arg
- (add-hook 'after-change-functions 'font-lock-after-change-function t t)
+ (add-hook 'after-change-functions #'font-lock-after-change-function t t)
(font-lock-set-defaults)
(font-lock-turn-on-thing-lock))
;; Turn off Font Lock mode.
(unless font-lock-mode
- (remove-hook 'after-change-functions 'font-lock-after-change-function t)
+ (remove-hook 'after-change-functions #'font-lock-after-change-function t)
(font-lock-unfontify-buffer)
(font-lock-turn-off-thing-lock)))
(`jit-lock-mode
;; Prepare for jit-lock
(remove-hook 'after-change-functions
- 'font-lock-after-change-function t)
+ #'font-lock-after-change-function t)
(set (make-local-variable 'font-lock-flush-function)
- 'jit-lock-refontify)
+ #'jit-lock-refontify)
(set (make-local-variable 'font-lock-ensure-function)
- 'jit-lock-fontify-now)
+ #'jit-lock-fontify-now)
;; Prevent font-lock-fontify-buffer from fontifying eagerly the whole
;; buffer. This is important for things like CWarn mode which
;; adds/removes a few keywords and does a refontify (which takes ages on
;; large files).
(set (make-local-variable 'font-lock-fontify-buffer-function)
- 'jit-lock-refontify)
+ #'jit-lock-refontify)
;; Don't fontify eagerly (and don't abort if the buffer is large).
(set (make-local-variable 'font-lock-fontified) t)
;; Use jit-lock.
(not font-lock-keywords-only))
;; Tell jit-lock how we extend the region to refontify.
(add-hook 'jit-lock-after-change-extend-region-functions
- 'font-lock-extend-jit-lock-region-after-change
+ #'font-lock-extend-jit-lock-region-after-change
nil t))))
(defun font-lock-turn-off-thing-lock ()
"Put proper face on each string and comment between START and END.
START should be at the beginning of a line."
(syntax-propertize end) ; Apply any needed syntax-table properties.
+ (with-syntax-table (or syntax-ppss-table (syntax-table))
(let ((comment-end-regexp
(or font-lock-comment-end-skip
(regexp-quote
font-lock-comment-delimiter-face))))
(< (point) end))
(setq state (parse-partial-sexp (point) end nil nil state
- 'syntax-table)))))
+ 'syntax-table))))))
;;; End of Syntactic fontification functions.
\f
(mapcar #'font-lock-compile-keyword keywords))))
(if (and (not syntactic-keywords)
(let ((beg-function syntax-begin-function))
- (or (eq beg-function 'beginning-of-defun)
+ (or (eq beg-function #'beginning-of-defun)
(if (symbolp beg-function)
(get beg-function 'font-lock-syntax-paren-check))))
(not beginning-of-defun-function))
(let ((syntax (cdr selem)))
(dolist (char (if (numberp (car selem))
(list (car selem))
- (mapcar 'identity (car selem))))
+ (mapcar #'identity (car selem))))
(modify-syntax-entry char syntax font-lock-syntax-table)))))
;; (nth 4 defaults) used to hold `font-lock-beginning-of-syntax-function',
;; but that was removed in 25.1, so if it's a cons cell, we assume that
;; ;; The default level is usually, but not necessarily, level 1.
;; (setq level (- (length keywords)
;; (length (member (eval (car keywords))
-;; (mapcar 'eval (cdr keywords))))))))
+;; (mapcar #'eval (cdr keywords))))))))
;; (setq font-lock-fontify-level (list level (> level 1)
;; (< level (1- (length keywords))))))))
;;