Commit | Line | Data |
---|---|---|
030f4a35 | 1 | ;; Electric Font Lock Mode |
d733c5ec | 2 | ;; Copyright (C) 1992, 1993, 1994 Free Software Foundation, Inc. |
030f4a35 RS |
3 | |
4 | ;; Author: jwz, then rms | |
5 | ;; Maintainer: FSF | |
6 | ;; Keywords: languages, faces | |
7 | ||
8 | ;; This file is part of GNU Emacs. | |
9 | ||
10 | ;; GNU Emacs is free software; you can redistribute it and/or modify | |
11 | ;; it under the terms of the GNU General Public License as published by | |
12 | ;; the Free Software Foundation; either version 2, or (at your option) | |
13 | ;; any later version. | |
14 | ||
15 | ;; GNU Emacs is distributed in the hope that it will be useful, | |
16 | ;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | ;; GNU General Public License for more details. | |
19 | ||
20 | ;; You should have received a copy of the GNU General Public License | |
21 | ;; along with GNU Emacs; see the file COPYING. If not, write to | |
22 | ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
23 | ||
24 | ||
25 | ;;; Commentary: | |
26 | ||
27 | ;; Font-lock-mode is a minor mode that causes your comments to be | |
28 | ;; displayed in one face, strings in another, reserved words in another, | |
29 | ;; documentation strings in another, and so on. | |
30 | ;; | |
31 | ;; Comments will be displayed in `font-lock-comment-face'. | |
32 | ;; Strings will be displayed in `font-lock-string-face'. | |
33 | ;; Doc strings will be displayed in `font-lock-doc-string-face'. | |
34 | ;; Function and variable names (in their defining forms) will be | |
35 | ;; displayed in `font-lock-function-name-face'. | |
36 | ;; Reserved words will be displayed in `font-lock-keyword-face'. | |
37 | ;; | |
38 | ;; To make the text you type be fontified, use M-x font-lock-mode. | |
39 | ;; When this minor mode is on, the fonts of the current line are | |
40 | ;; updated with every insertion or deletion. | |
41 | ;; | |
42 | ;; To define new reserved words or other patterns to highlight, use | |
43 | ;; the `font-lock-keywords' variable. This should be mode-local. | |
44 | ;; | |
45 | ;; To turn this on automatically, add this to your .emacs file: | |
46 | ;; | |
47 | ;; (setq emacs-lisp-mode-hook '(lambda () (font-lock-mode 1))) | |
48 | ;; | |
49 | ;; On a Sparc2, the initial fontification takes about 12 seconds for a 120k | |
50 | ;; file of C code, using the default configuration. You can speed this up | |
51 | ;; substantially by removing some of the patterns that are highlighted by | |
52 | ;; default. Fontifying Lisp code is significantly faster, because Lisp has a | |
53 | ;; more regular syntax than C, so the expressions don't have to be as hairy. | |
54 | ||
55 | ;;; Code: | |
56 | ||
030f4a35 RS |
57 | (defvar font-lock-comment-face |
58 | 'italic | |
59 | "Face to use for comments.") | |
60 | ||
61 | (defvar font-lock-doc-string-face | |
62 | 'italic | |
63 | "Face to use for documentation strings.") | |
64 | ||
65 | (defvar font-lock-string-face | |
66 | 'underline | |
67 | "Face to use for string constants.") | |
68 | ||
313d590c | 69 | (defvar font-lock-function-name-face |
030f4a35 RS |
70 | 'bold-italic |
71 | "Face to use for function names.") | |
72 | ||
73 | (defvar font-lock-keyword-face | |
74 | 'bold | |
75 | "Face to use for keywords.") | |
76 | ||
77 | (defvar font-lock-type-face | |
78 | 'italic | |
79 | "Face to use for data types.") | |
80 | ||
8f261d40 RS |
81 | (defvar font-lock-no-comments nil |
82 | "Non-nil means Font-Lock shouldn't check for comments or strings.") | |
83 | ||
030f4a35 RS |
84 | (make-variable-buffer-local 'font-lock-keywords) |
85 | (defvar font-lock-keywords nil | |
86 | "*The keywords to highlight. | |
87 | If this is a list, then elements may be of the forms: | |
88 | ||
214507c7 | 89 | \"string\" ; A regexp to highlight in the |
030f4a35 | 90 | ; `font-lock-keyword-face'. |
214507c7 RS |
91 | (\"string\" . N) ; Highlight subexpression N of the regexp. |
92 | (\"string\" . face-name) ; Use the named face | |
93 | (\"string\" N face-name) ; Both of the above | |
94 | (\"string\" N face-name t) ; This allows highlighting to override | |
95 | ; already-highlighted regions. | |
96 | (\"string\" N face-name keep) ; This allows highlighting to occur | |
97 | ; even if some parts of what STRING matches | |
98 | ; are already highlighted--but does not alter | |
99 | ; the existing highlighting of those parts. | |
030f4a35 RS |
100 | |
101 | These regular expressions should not match text which spans lines. | |
102 | While \\[font-lock-fontify-buffer] handles multi-line patterns correctly, | |
103 | updating when you edit the buffer does not, | |
104 | since it considers text one line at a time. | |
105 | ||
106 | Be careful composing regexps for this list; the wrong pattern can dramatically | |
107 | slow things down!") | |
108 | ||
109 | (defvar font-lock-keywords-case-fold-search nil | |
110 | "*Non-nil means the patterns in `font-lock-keywords' are case-insensitive.") | |
111 | ||
b056da51 RS |
112 | (defvar font-lock-syntax-table nil |
113 | "*Non-nil means use this syntax table for fontifying. | |
114 | If this is nil, the major mode's syntax table is used.") | |
115 | ||
030f4a35 RS |
116 | (defvar font-lock-verbose t |
117 | "*Non-nil means `font-lock-fontify-buffer' should print status messages.") | |
118 | ||
60b691e2 | 119 | ;;;###autoload |
030f4a35 RS |
120 | (defvar font-lock-mode-hook nil |
121 | "Function or functions to run on entry to Font Lock mode.") | |
122 | ||
123 | ;;; These variables record, for each buffer, | |
124 | ;;; the parse state at a particular position, always the start of a line. | |
125 | ;;; This is used to make font-lock-fontify-region faster. | |
126 | (defvar font-lock-cache-position nil) | |
127 | (defvar font-lock-cache-state nil) | |
128 | (make-variable-buffer-local 'font-lock-cache-position) | |
129 | (make-variable-buffer-local 'font-lock-cache-state) | |
130 | ||
131 | (defun font-lock-fontify-region (start end) | |
132 | "Put proper face on each string and comment between START and END." | |
133 | (save-excursion | |
134 | (goto-char start) | |
135 | (beginning-of-line) | |
136 | (setq end (min end (point-max))) | |
313d590c RS |
137 | (let ((buffer-read-only nil) |
138 | state startline prev prevstate | |
139 | (modified (buffer-modified-p))) | |
030f4a35 RS |
140 | ;; Find the state at the line-beginning before START. |
141 | (setq startline (point)) | |
142 | (if (eq (point) font-lock-cache-position) | |
143 | (setq state font-lock-cache-state) | |
144 | ;; Find outermost containing sexp. | |
145 | (beginning-of-defun) | |
146 | ;; Find the state at STARTLINE. | |
147 | (while (< (point) startline) | |
148 | (setq state (parse-partial-sexp (point) startline 0))) | |
149 | (setq font-lock-cache-state state | |
150 | font-lock-cache-position (point))) | |
151 | ;; Now find the state precisely at START. | |
152 | (setq state (parse-partial-sexp (point) start nil nil state)) | |
153 | ;; If the region starts inside a string, show the extent of it. | |
154 | (if (nth 3 state) | |
155 | (let ((beg (point))) | |
156 | (while (and (re-search-forward "\\s\"" end 'move) | |
157 | (nth 3 (parse-partial-sexp beg (point) | |
158 | nil nil state)))) | |
159 | (put-text-property beg (point) 'face font-lock-string-face) | |
160 | (setq state (parse-partial-sexp beg (point) nil nil state)))) | |
161 | ;; Likewise for a comment. | |
162 | (if (or (nth 4 state) (nth 7 state)) | |
163 | (let ((beg (point))) | |
164 | (while (and (re-search-forward (if comment-end | |
165 | (concat "\\s>\\|" | |
166 | (regexp-quote comment-end)) | |
167 | "\\s>") | |
168 | end 'move) | |
169 | (nth 3 (parse-partial-sexp beg (point) | |
170 | nil nil state)))) | |
171 | (put-text-property beg (point) 'face font-lock-comment-face) | |
172 | (setq state (parse-partial-sexp beg (point) nil nil state)))) | |
173 | ;; Find each interesting place between here and END. | |
174 | (while (and (< (point) end) | |
175 | (setq prev (point) prevstate state) | |
d5d9ce91 RS |
176 | (re-search-forward (if comment-start-skip |
177 | (concat "\\s\"\\|" comment-start-skip) | |
178 | "\\s\"") | |
179 | end t) | |
030f4a35 RS |
180 | ;; Clear out the fonts of what we skip over. |
181 | (progn (remove-text-properties prev (point) '(face nil)) t) | |
182 | ;; Verify the state at that place | |
183 | ;; so we don't get fooled by \" or \;. | |
184 | (setq state (parse-partial-sexp prev (point) | |
185 | nil nil state))) | |
186 | (let ((here (point))) | |
187 | (if (or (nth 4 state) (nth 7 state)) | |
188 | ;; We found a real comment start. | |
189 | (let ((beg (match-beginning 0))) | |
190 | (goto-char beg) | |
191 | (save-restriction | |
192 | (narrow-to-region (point-min) end) | |
193 | (condition-case nil | |
194 | (progn | |
195 | (forward-comment 1) | |
196 | ;; forward-comment skips all whitespace, | |
197 | ;; so go back to the real end of the comment. | |
198 | (skip-chars-backward " \t")) | |
199 | (error (goto-char end)))) | |
200 | (put-text-property beg (point) 'face font-lock-comment-face) | |
201 | (setq state (parse-partial-sexp here (point) nil nil state))) | |
202 | (if (nth 3 state) | |
203 | (let ((beg (match-beginning 0))) | |
204 | (while (and (re-search-forward "\\s\"" end 'move) | |
205 | (nth 3 (parse-partial-sexp here (point) | |
206 | nil nil state)))) | |
207 | (put-text-property beg (point) 'face font-lock-string-face) | |
208 | (setq state (parse-partial-sexp here (point) nil nil state)))) | |
209 | )) | |
210 | ;; Make sure PREV is non-nil after the loop | |
211 | ;; only if it was set on the very last iteration. | |
212 | (setq prev nil)) | |
213 | (and prev | |
313d590c | 214 | (remove-text-properties prev end '(face nil))) |
65df0851 RS |
215 | (and (buffer-modified-p) |
216 | (not modified) | |
217 | (set-buffer-modified-p nil))))) | |
030f4a35 RS |
218 | |
219 | ;; This code used to be used to show a string on reaching the end of it. | |
220 | ;; It is probably not needed due to later changes to handle strings | |
221 | ;; starting before the region in question. | |
222 | ;; (if (and (null (nth 3 state)) | |
223 | ;; (eq (char-syntax (preceding-char)) ?\") | |
224 | ;; (save-excursion | |
225 | ;; (nth 3 (parse-partial-sexp prev (1- (point)) | |
226 | ;; nil nil prevstate)))) | |
227 | ;; ;; We found the end of a string. | |
228 | ;; (save-excursion | |
229 | ;; (setq foo2 (point)) | |
230 | ;; (let ((ept (point))) | |
231 | ;; (forward-sexp -1) | |
232 | ;; ;; Highlight the string when we see the end. | |
233 | ;; ;; Doing it at the start leads to trouble: | |
234 | ;; ;; either it fails to handle multiline strings | |
235 | ;; ;; or it can run away when an unmatched " is inserted. | |
236 | ;; (put-text-property (point) ept 'face | |
237 | ;; (if (= (car state) 1) | |
238 | ;; font-lock-doc-string-face | |
239 | ;; font-lock-string-face))))) | |
240 | ||
241 | (defun font-lock-unfontify-region (beg end) | |
313d590c RS |
242 | (let ((modified (buffer-modified-p)) |
243 | (buffer-read-only nil)) | |
244 | (remove-text-properties beg end '(face nil)) | |
245 | (set-buffer-modified-p modified))) | |
030f4a35 RS |
246 | |
247 | ;; Called when any modification is made to buffer text. | |
248 | (defun font-lock-after-change-function (beg end old-len) | |
249 | (save-excursion | |
250 | (save-match-data | |
251 | (goto-char beg) | |
252 | ;; Discard the cache info if text before it has changed. | |
253 | (and font-lock-cache-position | |
254 | (> font-lock-cache-position beg) | |
255 | (setq font-lock-cache-position nil)) | |
256 | ;; Rescan till end of line. yes! | |
257 | (goto-char end) | |
258 | (end-of-line) | |
259 | (setq end (point)) | |
030f4a35 RS |
260 | (goto-char beg) |
261 | (beginning-of-line) | |
262 | (setq beg (point)) | |
1ec9e15b RS |
263 | ;; First scan for strings and comments. |
264 | ;; Must scan from line start in case of | |
265 | ;; inserting space into `intfoo () {}'. | |
8f261d40 | 266 | (if font-lock-no-comments |
9ab70935 | 267 | (remove-text-properties beg (min (1+ end) (point-max)) '(face nil)) |
8f261d40 | 268 | (font-lock-fontify-region beg (min (1+ end) (point-max)))) |
030f4a35 RS |
269 | ;; Now scan for keywords. |
270 | (font-lock-hack-keywords beg end)))) | |
271 | \f | |
272 | ;;; Fontifying arbitrary patterns | |
273 | ||
274 | (defsubst font-lock-any-properties-p (start end) | |
214507c7 RS |
275 | (or (get-text-property start 'face) |
276 | (let ((next (next-single-property-change start 'face))) | |
030f4a35 RS |
277 | (and next (< next end))))) |
278 | ||
279 | (defun font-lock-hack-keywords (start end &optional loudly) | |
280 | (goto-char start) | |
281 | (let ((case-fold-search font-lock-keywords-case-fold-search) | |
282 | (rest font-lock-keywords) | |
283 | (count 0) | |
313d590c RS |
284 | (buffer-read-only nil) |
285 | (modified (buffer-modified-p)) | |
b056da51 RS |
286 | first str match face s e allow-overlap-p |
287 | (old-syntax (syntax-table))) | |
288 | (unwind-protect | |
289 | (progn | |
290 | (if font-lock-syntax-table | |
291 | (set-syntax-table font-lock-syntax-table)) | |
b056da51 RS |
292 | (while rest |
293 | (setq first (car rest) rest (cdr rest)) | |
294 | (goto-char start) | |
295 | (cond ((consp first) | |
296 | (setq str (car first)) | |
297 | (cond ((consp (cdr first)) | |
298 | (setq match (nth 1 first) | |
299 | face (eval (nth 2 first)) | |
300 | allow-overlap-p (nth 3 first))) | |
301 | ((symbolp (cdr first)) | |
302 | (setq match 0 allow-overlap-p nil | |
303 | face (eval (cdr first)))) | |
304 | (t | |
305 | (setq match (cdr first) | |
306 | allow-overlap-p nil | |
307 | face font-lock-keyword-face)))) | |
308 | (t | |
309 | (setq str first match 0 allow-overlap-p nil | |
310 | face font-lock-keyword-face))) | |
311 | ;(message "regexp: %s" str) | |
312 | (while (re-search-forward str end t) | |
313 | (setq s (match-beginning match) | |
314 | e (match-end match)) | |
315 | (or s (error "expression did not match subexpression %d" match)) | |
316 | ;; don't fontify this keyword if we're already in some other context. | |
317 | (or (if allow-overlap-p nil (font-lock-any-properties-p s e)) | |
318 | (if (not (memq allow-overlap-p '(t nil))) | |
319 | (save-excursion | |
320 | (goto-char s) | |
321 | (while (< (point) e) | |
322 | (let ((next (next-single-property-change (point) 'face | |
323 | nil e))) | |
324 | (if (or (null next) (> next e)) | |
325 | (setq next e)) | |
326 | (if (not (get-text-property (point) 'face)) | |
327 | (put-text-property (point) next 'face face)) | |
328 | (goto-char next)))) | |
329 | (put-text-property s e 'face face)))) | |
330 | (if loudly (message "Fontifying %s... (regexps...%s)" | |
331 | (buffer-name) | |
332 | (make-string (setq count (1+ count)) ?.))))) | |
333 | (set-syntax-table old-syntax)) | |
65df0851 RS |
334 | (and (buffer-modified-p) |
335 | (not modified) | |
336 | (set-buffer-modified-p nil)))) | |
030f4a35 RS |
337 | \f |
338 | ;; The user level functions | |
339 | ||
340 | (defvar font-lock-mode nil) ; for modeline | |
341 | (or (assq 'font-lock-mode minor-mode-alist) | |
342 | (setq minor-mode-alist | |
343 | (append minor-mode-alist | |
344 | '((font-lock-mode " Font"))))) | |
345 | ||
346 | (defvar font-lock-fontified nil) ; whether we have hacked this buffer | |
347 | (put 'font-lock-fontified 'permanent-local t) | |
348 | ||
349 | ;;;###autoload | |
350 | (defun font-lock-mode (&optional arg) | |
351 | "Toggle Font Lock mode. | |
352 | With arg, turn Font Lock mode on if and only if arg is positive. | |
353 | ||
354 | When Font Lock mode is enabled, text is fontified as you type it: | |
355 | ||
356 | - comments are displayed in `font-lock-comment-face'; | |
357 | (That is a variable whose value should be a face name.) | |
358 | - strings are displayed in `font-lock-string-face'; | |
359 | - documentation strings are displayed in `font-lock-doc-string-face'; | |
360 | - function and variable names in their defining forms are displayed | |
361 | in `font-lock-function-name-face'; | |
362 | - and certain other expressions are displayed in other faces | |
363 | according to the value of the variable `font-lock-keywords'. | |
364 | ||
365 | When you turn Font Lock mode on/off, the buffer is fontified/defontified. | |
366 | To fontify a buffer without having newly typed text become fontified, you | |
367 | can use \\[font-lock-fontify-buffer]." | |
368 | (interactive "P") | |
369 | (let ((on-p (if (null arg) | |
370 | (not font-lock-mode) | |
371 | (> (prefix-numeric-value arg) 0)))) | |
372 | (if (equal (buffer-name) " *Compiler Input*") ; hack for bytecomp... | |
373 | (setq on-p nil)) | |
9ab70935 RS |
374 | (make-local-variable 'after-change-functions) |
375 | (if on-p | |
376 | (or (memq 'font-lock-after-change-function after-change-functions) | |
377 | (setq after-change-functions (cons 'font-lock-after-change-function | |
378 | after-change-functions))) | |
379 | (setq after-change-functions | |
380 | (delq 'font-lock-after-change-function | |
381 | (copy-sequence after-change-functions)))) | |
030f4a35 | 382 | (set (make-local-variable 'font-lock-mode) on-p) |
8f261d40 | 383 | (make-local-variable 'font-lock-no-comments) |
030f4a35 RS |
384 | (cond (on-p |
385 | (font-lock-set-defaults) | |
7daa8d6b | 386 | (make-local-variable 'before-revert-hook) |
87cd38d6 | 387 | (make-local-variable 'after-revert-hook) |
7daa8d6b KH |
388 | ;; If buffer is reverted, must clean up the state. |
389 | (add-hook 'before-revert-hook 'font-lock-revert-setup) | |
390 | (add-hook 'after-revert-hook 'font-lock-revert-cleanup) | |
030f4a35 RS |
391 | (run-hooks 'font-lock-mode-hook) |
392 | (or font-lock-fontified (font-lock-fontify-buffer))) | |
393 | (font-lock-fontified | |
394 | (setq font-lock-fontified nil) | |
7daa8d6b KH |
395 | (remove-hook 'before-revert-hook 'font-lock-revert-setup) |
396 | (remove-hook 'after-revert-hook 'font-lock-revert-cleanup) | |
030f4a35 RS |
397 | (font-lock-unfontify-region (point-min) (point-max)))) |
398 | (force-mode-line-update))) | |
399 | ||
7daa8d6b KH |
400 | ;; If the buffer is about to be reverted, it won't be fontified. |
401 | (defun font-lock-revert-setup () | |
402 | (setq font-lock-fontified nil)) | |
403 | ||
404 | ;; If the buffer has just been reverted, we might not even be in font-lock | |
405 | ;; mode anymore, and if we are, the buffer may or may not have already been | |
406 | ;; refontified. Refontify here if it looks like we need to. | |
407 | (defun font-lock-revert-cleanup () | |
408 | (and font-lock-mode | |
409 | (not font-lock-fontified) | |
410 | (font-lock-mode 1))) | |
411 | ||
030f4a35 RS |
412 | (defun font-lock-fontify-buffer () |
413 | "Fontify the current buffer the way `font-lock-mode' would: | |
414 | ||
415 | - comments are displayed in `font-lock-comment-face'; | |
416 | - strings are displayed in `font-lock-string-face'; | |
417 | - documentation strings are displayed in `font-lock-doc-string-face'; | |
418 | - function and variable names in their defining forms are displayed | |
419 | in `font-lock-function-name-face'; | |
420 | - and certain other expressions are displayed in other faces | |
421 | according to the value of the variable `font-lock-keywords'. | |
422 | ||
423 | This can take a while for large buffers." | |
424 | (interactive) | |
425 | (let ((was-on font-lock-mode) | |
426 | (font-lock-verbose (or font-lock-verbose (interactive-p)))) | |
427 | (if font-lock-verbose (message "Fontifying %s..." (buffer-name))) | |
428 | ;; Turn it on to run hooks and get the right font-lock-keywords. | |
366b3ecc | 429 | (or was-on (font-lock-set-defaults)) |
030f4a35 | 430 | (font-lock-unfontify-region (point-min) (point-max)) |
8f261d40 RS |
431 | (if (and font-lock-verbose (not font-lock-no-comments)) |
432 | (message "Fontifying %s... (syntactically...)" (buffer-name))) | |
030f4a35 | 433 | (save-excursion |
8f261d40 RS |
434 | (or font-lock-no-comments |
435 | (font-lock-fontify-region (point-min) (point-max))) | |
030f4a35 RS |
436 | (if font-lock-verbose (message "Fontifying %s... (regexps...)" |
437 | (buffer-name))) | |
438 | (font-lock-hack-keywords (point-min) (point-max) font-lock-verbose)) | |
030f4a35 RS |
439 | (set (make-local-variable 'font-lock-fontified) t) |
440 | (if font-lock-verbose (message "Fontifying %s... done." (buffer-name))) | |
441 | )) | |
442 | ||
443 | \f | |
444 | ;;; Various mode-specific information. | |
445 | ||
030f4a35 RS |
446 | (defconst lisp-font-lock-keywords-1 |
447 | '(;; | |
448 | ;; highlight defining forms. This doesn't work too nicely for | |
449 | ;; (defun (setf foo) ...) but it does work for (defvar foo) which | |
450 | ;; is more important. | |
451 | ("^(def[-a-z]+\\s +\\([^ \t\n\)]+\\)" 1 font-lock-function-name-face) | |
452 | ;; | |
453 | ;; highlight CL keywords | |
454 | ("\\s :\\(\\(\\sw\\|\\s_\\)+\\)\\>" . 1) | |
455 | ;; | |
456 | ;; this is highlights things like (def* (setf foo) (bar baz)), but may | |
457 | ;; be slower (I haven't really thought about it) | |
458 | ; ("^(def[-a-z]+\\s +\\(\\s(\\S)*\\s)\\|\\S(\\S *\\)" | |
459 | ; 1 font-lock-function-name-face) | |
460 | ) | |
461 | "For consideration as a value of `lisp-font-lock-keywords'. | |
462 | This does fairly subdued highlighting.") | |
463 | ||
464 | (defconst lisp-font-lock-keywords-2 | |
465 | (append | |
466 | lisp-font-lock-keywords-1 | |
467 | '(;; | |
468 | ;; Highlight control structures | |
469 | ("(\\(cond\\|if\\|when\\|unless\\|[ec]?\\(type\\)?case\\)[ \t\n]" . 1) | |
fee7a5a2 | 470 | ("(\\(while\\|do\\|let\\*?\\|flet\\|labels\\|prog[nv12*]?\\)[ \t\n]" . 1) |
030f4a35 RS |
471 | ("(\\(catch\\|\\throw\\|block\\|return\\|return-from\\)[ \t\n]" . 1) |
472 | ("(\\(save-restriction\\|save-window-restriction\\)[ \t\n]" . 1) | |
473 | ("(\\(save-excursion\\|unwind-protect\\|condition-case\\)[ \t\n]" . 1) | |
474 | ;; | |
475 | ;; highlight function names in emacs-lisp docstrings (in the syntax | |
476 | ;; that substitute-command-keys understands.) | |
477 | ("\\\\\\\\\\[\\([^]\\\n]+\\)]" 1 font-lock-keyword-face t) | |
478 | ;; | |
479 | ;; highlight words inside `' which tend to be function names | |
480 | ("`\\([-a-zA-Z0-9_][-a-zA-Z0-9_][-a-zA-Z0-9_.]+\\)'" | |
481 | 1 font-lock-keyword-face t) | |
482 | )) | |
483 | "For consideration as a value of `lisp-font-lock-keywords'. | |
484 | This does a lot more highlighting.") | |
485 | ||
486 | ;; default to the gaudier variety? | |
487 | ;(defvar lisp-font-lock-keywords lisp-font-lock-keywords-2 | |
488 | ; "Additional expressions to highlight in Lisp modes.") | |
489 | (defvar lisp-font-lock-keywords lisp-font-lock-keywords-1 | |
490 | "Additional expressions to highlight in Lisp modes.") | |
491 | ||
492 | ||
493 | (defconst c-font-lock-keywords-1 nil | |
494 | "For consideration as a value of `c-font-lock-keywords'. | |
495 | This does fairly subdued highlighting.") | |
496 | ||
497 | (defconst c-font-lock-keywords-2 nil | |
498 | "For consideration as a value of `c-font-lock-keywords'. | |
499 | This does a lot more highlighting.") | |
500 | ||
1bd50840 RS |
501 | (defconst c++-font-lock-keywords-1 nil |
502 | "For consideration as a value of `c++-font-lock-keywords'. | |
503 | This does fairly subdued highlighting.") | |
504 | ||
505 | (defconst c++-font-lock-keywords-2 nil | |
506 | "For consideration as a value of `c++-font-lock-keywords'. | |
507 | This does a lot more highlighting.") | |
508 | ||
f60f18ae KH |
509 | (let* ((storage "auto\\|extern\\|register\\|static\\|typedef") |
510 | (struct "struct\\|union\\|enum") | |
511 | (prefixes "signed\\|unsigned\\|short\\|long") | |
512 | (types (concat prefixes "\\|int\\|char\\|float\\|double\\|void")) | |
1bd50840 RS |
513 | (ctoken "[a-zA-Z0-9_:~*]+") |
514 | (c++-things (concat | |
515 | "const\\|class\\|protected:\\|private:\\|public:\\|inline\\|" | |
516 | "new\\|delete"))) | |
f60f18ae KH |
517 | (setq c-font-lock-keywords-1 |
518 | (list | |
519 | ;; fontify preprocessor directives as comments. | |
520 | '("^#[ \t]*[a-z]+" . font-lock-comment-face) | |
521 | ;; | |
522 | ;; fontify names being defined. | |
523 | '("^#[ \t]*\\(define\\|undef\\)[ \t]+\\(\\(\\sw\\|\\s_\\)+\\)" 2 | |
524 | font-lock-function-name-face) | |
525 | ;; | |
526 | ;; fontify other preprocessor lines. | |
527 | '("^#[ \t]*\\(if\\|elif\\|else\\|endif\\)[ \t]+\\([^\n]+\\)" | |
528 | 2 font-lock-function-name-face keep) | |
529 | '("^#[ \t]*\\(ifn?def\\)[ \t]+\\([^ \t\n]+\\)" | |
530 | 2 font-lock-function-name-face t) | |
531 | ;; | |
532 | ;; fontify the filename in #include <...> | |
533 | ;; don't need to do this for #include "..." because those were | |
534 | ;; already fontified as strings by the syntactic pass. | |
535 | '("^#[ \t]*include[ \t]+\\(<[^>\"\n]+>\\)" 1 font-lock-string-face) | |
536 | ;; | |
537 | ;; fontify the names of functions being defined. | |
538 | (list (concat | |
539 | "^\\(" ctoken "[ \t]+\\)?" ; type specs; there can be no | |
540 | "\\(" ctoken "[ \t]+\\)?" ; more than 3 tokens, right? | |
541 | "\\(" ctoken "[ \t]+\\)?" | |
542 | "\\([*&]+[ \t]*\\)?" ; pointer | |
543 | "\\(" ctoken "\\)[ \t]*(") ; name | |
544 | 5 'font-lock-function-name-face) | |
545 | ;; | |
546 | ;; | |
547 | ;; Fontify structure names (in structure definition form). | |
548 | (list (concat "^\\(" storage "\\)?[ \t]*\\<\\(" struct "\\)" | |
549 | "[ \t]+\\(" ctoken "\\)[ \t]*\\(\{\\|$\\)") | |
550 | 3 'font-lock-function-name-face) | |
551 | ;; | |
552 | ;; Fontify declarations of simple identifiers (including typedefs). | |
553 | ;; (Should this be in c-font-lock-keywords-2 instead?) | |
554 | (list (concat "^[ \t]*\\(\\(" storage "\\)[ \t]+\\)?\\(\\(\\(" prefixes | |
555 | "\\)\\>[ \t]*\\)*\\(" types "\\)\\)[ \t]+\\(" ctoken | |
556 | "\\)[ \t]*[=;]") | |
557 | 7 'font-lock-function-name-face 'keep) | |
558 | ;; | |
559 | ;; And likewise for structs | |
560 | (list (concat "^[ \t]*\\(\\(" storage "\\)[ \t]+\\)?\\(" struct | |
561 | "\\)[ \t]+" ctoken "[ \t]+\\(" ctoken "\\);") | |
562 | 4 'font-lock-function-name-face 'keep) | |
563 | ;; | |
564 | ;; Fontify case clauses. This is fast because its anchored on the left. | |
565 | '("case[ \t]+\\(\\(\\sw\\|\\s_\\)+\\):". 1) | |
566 | '("\\<\\(default\\):". 1) | |
567 | )) | |
568 | ||
569 | (setq c-font-lock-keywords-2 | |
570 | (append c-font-lock-keywords-1 | |
030f4a35 | 571 | (list |
030f4a35 | 572 | ;; |
f60f18ae KH |
573 | ;; fontify all storage classes and type specifiers |
574 | (cons (concat "\\<\\(" storage "\\)\\>") 'font-lock-type-face) | |
1bd50840 | 575 | (cons (concat "\\<\\(" types "\\)\\>") 'font-lock-type-face) |
f60f18ae KH |
576 | (cons (concat "\\<\\(\\(\\(" prefixes "\\)\\>[ \t]*\\)*\\(" types |
577 | "\\)\\)\\>") | |
578 | 'font-lock-type-face) | |
579 | (list (concat "\\<\\(" struct "\\)[ \t]+" ctoken) | |
580 | 0 'font-lock-type-face 'keep) | |
030f4a35 | 581 | ;; |
f60f18ae KH |
582 | ;; fontify all builtin tokens |
583 | (cons (concat | |
584 | "[ \t]\\(" | |
585 | (mapconcat 'identity | |
586 | '("for" "while" "do" "return" "goto" "case" "break" "switch" | |
587 | "if" "else" "default" "continue" "default") | |
588 | "\\|") | |
589 | "\\)[ \t\n(){};,]") | |
590 | 1) | |
030f4a35 | 591 | ;; |
f60f18ae KH |
592 | ;; fontify case targets and goto-tags. This is slow because the |
593 | ;; expression is anchored on the right. | |
65df0851 | 594 | '("[ \t\n]\\(\\(\\sw\\|\\s_\\)+\\):" . 1) |
030f4a35 | 595 | ;; |
f60f18ae KH |
596 | ;; Fontify variables declared with structures, or typedef names. |
597 | '("}[ \t*]*\\(\\(\\sw\\|\\s_\\)+\\)[ \t]*[,;]" | |
598 | 1 font-lock-function-name-face) | |
030f4a35 | 599 | ;; |
f60f18ae KH |
600 | ;; Fontify global variables without a type. |
601 | ; '("^\\([_a-zA-Z0-9:~*]+\\)[ \t]*[[;={]" 1 font-lock-function-name-face) | |
602 | ))) | |
1bd50840 RS |
603 | |
604 | (setq c++-font-lock-keywords-1 | |
605 | (cons | |
606 | (concat "\\(" c++-things "\\)[ \t\n]") | |
607 | c-font-lock-keywords-1)) | |
608 | (setq c++-font-lock-keywords-2 | |
609 | (cons | |
610 | (cons (concat "\\<\\(" c++-things "\\)\\>") 'font-lock-type-face) | |
611 | c-font-lock-keywords-2)) | |
f60f18ae | 612 | ) |
030f4a35 RS |
613 | |
614 | ; default to the gaudier variety? | |
030f4a35 RS |
615 | (defvar c-font-lock-keywords c-font-lock-keywords-1 |
616 | "Additional expressions to highlight in C mode.") | |
617 | ||
1bd50840 | 618 | (defvar c++-font-lock-keywords c++-font-lock-keywords-1 |
030f4a35 RS |
619 | "Additional expressions to highlight in C++ mode.") |
620 | ||
621 | ||
622 | (defvar perl-font-lock-keywords | |
623 | (list | |
313d590c RS |
624 | (cons (concat "[ \n\t{]*\\(" |
625 | (mapconcat 'identity | |
626 | '("if" "until" "while" "elsif" "else" "unless" "for" | |
627 | "foreach" "continue" "exit" "die" "last" "goto" "next" | |
628 | "redo" "return" "local" "exec") | |
629 | "\\|") | |
630 | "\\)[ \n\t;(]") 1) | |
030f4a35 RS |
631 | (mapconcat 'identity |
632 | '("#endif" "#else" "#ifdef" "#ifndef" "#if" "#include" | |
633 | "#define" "#undef") | |
634 | "\\|") | |
1ec9e15b RS |
635 | '("^[ \n\t]*sub[ \t]+\\([^ \t{]+\\)[ \t]*[{]" 1 font-lock-function-name-face) |
636 | '("[ \n\t{]*\\(eval\\)[ \n\t(;]" 1 font-lock-function-name-face) | |
030f4a35 RS |
637 | '("\\(--- .* ---\\|=== .* ===\\)" . font-lock-doc-string-face) |
638 | ) | |
639 | "Additional expressions to highlight in Perl mode.") | |
640 | ||
641 | (defvar tex-font-lock-keywords | |
642 | (list | |
055c8d71 | 643 | '("\\(\\\\\\([a-zA-Z@]+\\|.\\)\\)" 1 font-lock-keyword-face t) |
030f4a35 RS |
644 | '("{\\\\em\\([^}]+\\)}" 1 font-lock-comment-face t) |
645 | '("{\\\\bf\\([^}]+\\)}" 1 font-lock-keyword-face t) | |
646 | '("^[ \t\n]*\\\\def[\\\\@]\\(\\w+\\)" 1 font-lock-function-name-face t) | |
647 | '("\\\\\\(begin\\|end\\){\\([a-zA-Z0-9\\*]+\\)}" | |
648 | 2 font-lock-function-name-face t) | |
649 | '("[^\\\\]\\$\\([^$]*\\)\\$" 1 font-lock-string-face t) | |
650 | ; '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t) | |
651 | ) | |
652 | "Additional expressions to highlight in TeX mode.") | |
653 | ||
654 | (defvar texi-font-lock-keywords | |
655 | (list | |
656 | "@\\(@\\|[^}\t \n{]+\\)" ;commands | |
657 | '("^\\(@c\\|@comment\\)[ \t].*$" . font-lock-comment-face) ;comments | |
658 | '("^\\(*.*\\)[\t ]*$" 1 font-lock-function-name-face t) ;menu items | |
659 | '("@\\(emph\\|strong\\|b\\|i\\){\\([^}]+\\)" 2 font-lock-comment-face t) | |
660 | '("@\\(file\\|kbd\\|key\\){\\([^}]+\\)" 2 font-lock-string-face t) | |
661 | '("@\\(samp\\|code\\|var\\){\\([^}]+\\)" 2 font-lock-function-name-face t) | |
662 | '("@\\(xref\\|pxref\\){\\([^}]+\\)" 2 font-lock-keyword-face t) | |
663 | '("@end *\\([a-zA-Z0-9]+\\)[ \t]*$" 1 font-lock-function-name-face t) | |
664 | '("@item \\(.*\\)$" 1 font-lock-function-name-face t) | |
665 | '("\\$\\([^$]*\\)\\$" 1 font-lock-string-face t) | |
666 | ) | |
667 | "Additional expressions to highlight in TeXinfo mode.") | |
668 | ||
03244f89 RS |
669 | (defvar shell-font-lock-keywords |
670 | (list (cons shell-prompt-pattern 'font-lock-keyword-face) | |
03244f89 RS |
671 | '("[ \t]\\([+-][^ \t\n]+\\)" 1 font-lock-comment-face) |
672 | '("^[^ \t]+:.*$" . font-lock-string-face) | |
673 | '("^\\[[1-9][0-9]*\\]" . font-lock-string-face)) | |
eeb1e03e | 674 | "Additional expressions to highlight in Shell mode.") |
03244f89 | 675 | |
8023777c RS |
676 | (defvar dired-font-lock-keywords |
677 | '(;; Put directory headers in italics. | |
678 | ("^ \\(/.+\\)$" 1 font-lock-type-face) | |
679 | ;; Put symlinks in bold italics. | |
680 | ("\\([^ ]+\\) -> [^ ]+$" . font-lock-function-name-face) | |
681 | ;; Put marks in bold. | |
682 | ("^\\([^ ]\\).*$" 1 font-lock-keyword-face t) | |
683 | ;; Put files that are subdirectories in bold. | |
684 | ("^..d.* \\([^ ]+\\)$" 1 font-lock-keyword-face)) | |
685 | "Additional expressions to highlight in Dired mode.") | |
686 | ||
b545f35b RS |
687 | (defvar rmail-font-lock-keywords |
688 | '(;; Put From field in bold. | |
689 | ("^From: \\(.*\\)$" 1 font-lock-keyword-face) | |
690 | ;; Put subject in bold italics | |
691 | ("^Subject: \\(.*\\)$" 1 font-lock-function-name-face)) | |
692 | "Additional expressions to highlight in Rmail mode.") | |
693 | ||
ed9d4b0a RS |
694 | (defvar rmail-summary-font-lock-keywords |
695 | '(("^\\s *[0-9]+D.*$" . font-lock-doc-string-face) | |
696 | ("^\\s *[0-9]+-.*$" . font-lock-keyword-face)) | |
697 | "Additional expressions to highlight in Rmail Summary mode.") | |
698 | ||
b545f35b RS |
699 | (defvar compilation-mode-font-lock-keywords |
700 | '(("^\\([^\n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 1 font-lock-function-name-face)) | |
701 | ;;; ("^\\([^\n:]*:\\([0-9]+:\\)+\\)\\(.*\\)$" 0 font-lock-keyword-face keep) | |
702 | "Additional expressions to highlight in Compilation mode.") | |
703 | ||
8f261d40 RS |
704 | (defun font-lock-set-defaults () |
705 | "Set `font-lock-keywords' to something appropriate for this mode." | |
706 | (if (memq major-mode '(rmail-mode dired-mode compilation-mode shell-mode)) | |
707 | (setq font-lock-no-comments t)) | |
708 | (if (not font-lock-keywords) ; if not already set. | |
709 | (setq font-lock-keywords | |
710 | (cond ((eq major-mode 'lisp-mode) lisp-font-lock-keywords) | |
711 | ((eq major-mode 'emacs-lisp-mode) lisp-font-lock-keywords) | |
b056da51 RS |
712 | ((eq major-mode 'c-mode) |
713 | (make-local-variable 'font-lock-syntax-table) | |
714 | (setq font-lock-syntax-table | |
715 | (copy-syntax-table (syntax-table))) | |
716 | (modify-syntax-entry ?_ "w" font-lock-syntax-table) | |
717 | c-font-lock-keywords) | |
718 | ((eq major-mode 'c++-c-mode) | |
719 | (make-local-variable 'font-lock-syntax-table) | |
720 | (setq font-lock-syntax-table | |
721 | (copy-syntax-table (syntax-table))) | |
722 | (modify-syntax-entry ?_ "w" font-lock-syntax-table) | |
723 | c-font-lock-keywords) | |
8f261d40 RS |
724 | ((eq major-mode 'c++-mode) c++-font-lock-keywords) |
725 | ((eq major-mode 'perl-mode) perl-font-lock-keywords) | |
055c8d71 RS |
726 | ((eq major-mode 'plain-tex-mode) tex-font-lock-keywords) |
727 | ((eq major-mode 'latex-mode) tex-font-lock-keywords) | |
728 | ((eq major-mode 'slitex-mode) tex-font-lock-keywords) | |
8f261d40 RS |
729 | ((eq major-mode 'texinfo-mode) texi-font-lock-keywords) |
730 | ((eq major-mode 'shell-mode) shell-font-lock-keywords) | |
731 | ((eq major-mode 'dired-mode) dired-font-lock-keywords) | |
732 | ((eq major-mode 'rmail-mode) rmail-font-lock-keywords) | |
ed9d4b0a RS |
733 | ((eq major-mode 'rmail-summary-mode) |
734 | rmail-summary-font-lock-keywords) | |
8f261d40 RS |
735 | ((eq major-mode 'compilation-mode) |
736 | compilation-mode-font-lock-keywords) | |
737 | (t nil))))) | |
738 | ||
030f4a35 RS |
739 | (provide 'font-lock) |
740 | ||
741 | ;;; font-lock.el ends here |