1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
|
;;; font-core.el --- Core interface to font-lock
;; Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
;; 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
;; Maintainer: FSF
;; Keywords: languages, faces
;; This file is part of GNU Emacs.
;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;; Code:
;; This variable is used by mode packages that support Font Lock mode by
;; defining their own keywords to use for `font-lock-keywords'. (The mode
;; command should make it buffer-local and set it to provide the set up.)
(defvar font-lock-defaults nil
"Defaults for Font Lock mode specified by the major mode.
Defaults should be of the form:
(KEYWORDS [KEYWORDS-ONLY [CASE-FOLD [SYNTAX-ALIST [SYNTAX-BEGIN ...]]]])
KEYWORDS may be a symbol (a variable or function whose value is the keywords to
use for fontification) or a list of symbols. If KEYWORDS-ONLY is non-nil,
syntactic fontification (strings and comments) is not performed.
If CASE-FOLD is non-nil, the case of the keywords is ignored when fontifying.
If SYNTAX-ALIST is non-nil, it should be a list of cons pairs of the form
\(CHAR-OR-STRING . STRING) used to set the local Font Lock syntax table, for
keyword and syntactic fontification (see `modify-syntax-entry').
If SYNTAX-BEGIN is non-nil, it should be a function with no args used to move
backwards outside any enclosing syntactic block, for syntactic fontification.
Typical values are `beginning-of-line' (i.e., the start of the line is known to
be outside a syntactic block), or `beginning-of-defun' for programming modes or
`backward-paragraph' for textual modes (i.e., the mode-dependent function is
known to move outside a syntactic block). If nil, the beginning of the buffer
is used as a position outside of a syntactic block, in the worst case.
These item elements are used by Font Lock mode to set the variables
`font-lock-keywords', `font-lock-keywords-only',
`font-lock-keywords-case-fold-search', `font-lock-syntax-table' and
`font-lock-beginning-of-syntax-function', respectively.
Further item elements are alists of the form (VARIABLE . VALUE) and are in no
particular order. Each VARIABLE is made buffer-local before set to VALUE.
Currently, appropriate variables include `font-lock-mark-block-function'.
If this is non-nil, it should be a function with no args used to mark any
enclosing block of text, for fontification via \\[font-lock-fontify-block].
Typical values are `mark-defun' for programming modes or `mark-paragraph' for
textual modes (i.e., the mode-dependent function is known to put point and mark
around a text block relevant to that mode).
Other variables include that for syntactic keyword fontification,
`font-lock-syntactic-keywords' and those for buffer-specialized fontification
functions, `font-lock-fontify-buffer-function',
`font-lock-unfontify-buffer-function', `font-lock-fontify-region-function',
`font-lock-unfontify-region-function', and `font-lock-inhibit-thing-lock'.")
(make-variable-buffer-local 'font-lock-defaults)
(defvar font-lock-defaults-alist nil
"Alist of fall-back Font Lock defaults for major modes.
Each item should be a list of the form:
(MAJOR-MODE . FONT-LOCK-DEFAULTS)
where MAJOR-MODE is a symbol and FONT-LOCK-DEFAULTS is a list of default
settings. See the variable `font-lock-defaults', which takes precedence.")
(make-obsolete-variable 'font-lock-defaults-alist 'font-lock-defaults)
(defvar font-lock-extend-region-function nil
"A function that determines the region to fontify after a change.
This buffer-local variable is either nil, or is a function that determines the
region to fontify. It is usually set by the major mode. The currently active
font-lock after-change function calls this function after each buffer change.
The function is given three parameters, the standard BEG, END, and OLD-LEN
from after-change-functions. It should return either a cons of the beginning
and end buffer positions \(in that order) of the region to fontify, or nil
\(which directs the caller to fontify a default region). This function need
not preserve point or the match-data, but must preserve the current
restriction. The region it returns may start or end in the middle of a
line.")
(make-variable-buffer-local 'font-lock-extend-region-function)
(defun font-lock-extend-region (beg end old-len)
"Determine the region to fontify after a buffer change.
BEG END and OLD-LEN are the standard parameters from after-change-functions.
The return value is either nil \(which directs the caller to chose the region
itself), or a cons of the beginning and end \(in that order) of the region.
The region returned may start or end in the middle of a line."
(if font-lock-extend-region-function
(save-match-data
(save-excursion
(funcall font-lock-extend-region-function beg end old-len)))))
(defvar font-lock-function 'font-lock-default-function
"A function which is called when `font-lock-mode' is toggled.
It will be passed one argument, which is the current value of
`font-lock-mode'.")
;; The mode for which font-lock was initialized, or nil if none.
(defvar font-lock-mode-major-mode)
(define-minor-mode font-lock-mode
"Toggle Font Lock mode.
With arg, turn Font Lock mode off if and only if arg is a non-positive
number; if arg is nil, toggle Font Lock mode; anything else turns Font
Lock on.
\(Font Lock is also known as \"syntax highlighting\".)
When Font Lock mode is enabled, text is fontified as you type it:
- Comments are displayed in `font-lock-comment-face';
- Strings are displayed in `font-lock-string-face';
- Certain other expressions are displayed in other faces according to the
value of the variable `font-lock-keywords'.
To customize the faces (colors, fonts, etc.) used by Font Lock for
fontifying different parts of buffer text, use \\[customize-face].
You can enable Font Lock mode in any major mode automatically by turning on in
the major mode's hook. For example, put in your ~/.emacs:
(add-hook 'c-mode-hook 'turn-on-font-lock)
Alternatively, you can use Global Font Lock mode to automagically turn on Font
Lock mode in buffers whose major mode supports it and whose major mode is one
of `font-lock-global-modes'. For example, put in your ~/.emacs:
(global-font-lock-mode t)
Where major modes support different levels of fontification, you can use
the variable `font-lock-maximum-decoration' to specify which level you
generally prefer. When you turn Font Lock mode on/off the buffer is
fontified/defontified, though fontification occurs only if the buffer is
less than `font-lock-maximum-size'.
For example, to use maximum levels of fontification, put in your ~/.emacs:
(setq font-lock-maximum-decoration t)
To add your own highlighting for some major mode, and modify the highlighting
selected automatically via the variable `font-lock-maximum-decoration', you can
use `font-lock-add-keywords'.
To fontify a buffer, without turning on Font Lock mode and regardless of buffer
size, you can use \\[font-lock-fontify-buffer].
To fontify a block (the function or paragraph containing point, or a number of
lines around point), perhaps because modification on the current line caused
syntactic change on other lines, you can use \\[font-lock-fontify-block].
See the variable `font-lock-defaults-alist' for the Font Lock mode default
settings. You can set your own default settings for some mode, by setting a
buffer local value for `font-lock-defaults', via its mode hook.
The above is the default behavior of `font-lock-mode'; you may specify
your own function which is called when `font-lock-mode' is toggled via
`font-lock-function'. "
nil nil nil
;; 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).
(when (or noninteractive (eq (aref (buffer-name) 0) ?\ ))
(setq font-lock-mode nil))
(funcall font-lock-function font-lock-mode)
;; Arrange to unfontify this buffer if we change major mode later.
(if font-lock-mode
(add-hook 'change-major-mode-hook 'font-lock-change-mode nil t)
(remove-hook 'change-major-mode-hook 'font-lock-change-mode t))
(when font-lock-mode
(setq font-lock-mode-major-mode major-mode)))
;; Get rid of fontification for the old major mode.
;; We do this when changing major modes.
(defun font-lock-change-mode ()
(font-lock-mode -1))
(defun font-lock-defontify ()
"Clear out all `font-lock-face' properties in current buffer.
A major mode that uses `font-lock-face' properties might want to put
this function onto `change-major-mode-hook'."
(let ((modp (buffer-modified-p))
(inhibit-read-only t))
(save-restriction
(widen)
(remove-list-of-text-properties (point-min) (point-max)
'(font-lock-face)))
(restore-buffer-modified-p modp)))
(defvar font-lock-set-defaults)
(defun font-lock-default-function (mode)
;; Turn on Font Lock mode.
(when mode
(set (make-local-variable 'char-property-alias-alist)
(copy-tree char-property-alias-alist))
;; Add `font-lock-face' as an alias for the `face' property.
(let ((elt (assq 'face char-property-alias-alist)))
(if elt
(unless (memq 'font-lock-face (cdr elt))
(setcdr elt (nconc (cdr elt) (list 'font-lock-face))))
(push (list 'face 'font-lock-face) char-property-alias-alist))))
;; Turn off Font Lock mode.
(unless mode
;; Remove `font-lock-face' as an alias for the `face' property.
(set (make-local-variable 'char-property-alias-alist)
(copy-tree char-property-alias-alist))
(let ((elt (assq 'face char-property-alias-alist)))
(when elt
(setcdr elt (remq 'font-lock-face (cdr elt)))
(when (null (cdr elt))
(setq char-property-alias-alist
(delq elt char-property-alias-alist))))))
;; Only do hard work if the mode has specified stuff in
;; `font-lock-defaults'.
(when (or font-lock-defaults
(if (boundp 'font-lock-keywords) font-lock-keywords)
(with-no-warnings
(cdr (assq major-mode font-lock-defaults-alist)))
(and mode
(boundp 'font-lock-set-defaults)
font-lock-set-defaults
font-lock-mode-major-mode
(not (eq font-lock-mode-major-mode major-mode))))
(font-lock-mode-internal mode)))
(defun turn-on-font-lock ()
"Turn on Font Lock mode (only if the terminal can display it)."
(unless font-lock-mode
(font-lock-mode)))
;;; Global Font Lock mode.
;; A few people have hassled in the past for a way to make it easier to turn on
;; Font Lock mode, without the user needing to know for which modes s/he has to
;; turn it on, perhaps the same way hilit19.el/hl319.el does. I've always
;; balked at that way, as I see it as just re-moulding the same problem in
;; another form. That is; some person would still have to keep track of which
;; modes (which may not even be distributed with Emacs) support Font Lock mode.
;; The list would always be out of date. And that person might have to be me.
;; Implementation.
;;
;; In a previous discussion the following hack came to mind. It is a gross
;; hack, but it generally works. We use the convention that major modes start
;; by calling the function `kill-all-local-variables', which in turn runs
;; functions on the hook variable `change-major-mode-hook'. We attach our
;; function `font-lock-change-major-mode' to that hook. Of course, when this
;; hook is run, the major mode is in the process of being changed and we do not
;; know what the final major mode will be. So, `font-lock-change-major-mode'
;; only (a) notes the name of the current buffer, and (b) adds our function
;; `turn-on-font-lock-if-enabled' to the hook variables
;; `after-change-major-mode-hook' and `post-command-hook' (for modes
;; that do not yet run `after-change-major-mode-hook'). By the time
;; the functions on the first of these hooks to be run are run, the new major
;; mode is assumed to be in place. This way we get a Font Lock function run
;; when a major mode is turned on, without knowing major modes or their hooks.
;;
;; Naturally this requires that major modes run `kill-all-local-variables'
;; and `after-change-major-mode-hook', as they are supposed to. For modes
;; that do not run `after-change-major-mode-hook' yet, `post-command-hook'
;; takes care of things if the mode is set directly or indirectly by
;; an interactive command; however, problems can occur if the mode is
;; set by a timer or process: in that case, proper handling of Font Lock mode
;; may be delayed until the next interactive command.
;; User interface.
;;
;; Although Global Font Lock mode is a pseudo-mode, I think that the user
;; interface should conform to the usual Emacs convention for modes, i.e., a
;; command to toggle the feature (`global-font-lock-mode') with a variable for
;; finer control of the mode's behaviour (`font-lock-global-modes').
;;
;; The feature should not be enabled by loading font-lock.el, since other
;; mechanisms for turning on Font Lock mode, such as M-x font-lock-mode RET or
;; (add-hook 'c-mode-hook 'turn-on-font-lock), would cause Font Lock mode to be
;; turned on everywhere. That would not be intuitive or informative because
;; loading a file tells you nothing about the feature or how to control it. It
;; would also be contrary to the Principle of Least Surprise. sm.
(defcustom font-lock-global-modes t
"*Modes for which Font Lock mode is automagically turned on.
Global Font Lock mode is controlled by the command `global-font-lock-mode'.
If nil, means no modes have Font Lock mode automatically turned on.
If t, all modes that support Font Lock mode have it automatically turned on.
If a list, it should be a list of `major-mode' symbol names for which Font Lock
mode should be automatically turned on. The sense of the list is negated if it
begins with `not'. For example:
(c-mode c++-mode)
means that Font Lock mode is turned on for buffers in C and C++ modes only."
:type '(choice (const :tag "none" nil)
(const :tag "all" t)
(set :menu-tag "mode specific" :tag "modes"
:value (not)
(const :tag "Except" not)
(repeat :inline t (symbol :tag "mode"))))
:group 'font-lock)
(defun turn-on-font-lock-if-enabled ()
(unless (and (eq (car-safe font-lock-global-modes) 'not)
(memq major-mode (cdr font-lock-global-modes)))
(let (inhibit-quit)
(turn-on-font-lock))))
(define-global-minor-mode global-font-lock-mode
font-lock-mode turn-on-font-lock-if-enabled
:extra-args (dummy)
:initialize 'custom-initialize-safe-default
:init-value (not (or noninteractive emacs-basic-display))
:group 'font-lock
:version "22.1")
;;; End of Global Font Lock mode.
(provide 'font-core)
;; arch-tag: f8c286e1-02f7-41d9-b89b-1b67780aed71
;;; font-core.el ends here
|