Partially correct fontification of "(b*3)", and the like, in C++ Mode
[emacs.git] / lisp / progmodes / cc-fonts.el
blob39e68f0b8713dea070a9a5dcbf4691872a1b4bf8
1 ;;; cc-fonts.el --- font lock support for CC Mode
3 ;; Copyright (C) 2002-2016 Free Software Foundation, Inc.
5 ;; Authors: 2003- Alan Mackenzie
6 ;; 2002- Martin Stjernholm
7 ;; Maintainer: bug-cc-mode@gnu.org
8 ;; Created: 07-Jan-2002
9 ;; Keywords: c languages
10 ;; Package: cc-mode
12 ;; This file is part of GNU Emacs.
14 ;; GNU Emacs is free software: you can redistribute it and/or modify
15 ;; it under the terms of the GNU General Public License as published by
16 ;; the Free Software Foundation, either version 3 of the License, or
17 ;; (at your option) any later version.
19 ;; GNU Emacs is distributed in the hope that it will be useful,
20 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
21 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 ;; GNU General Public License for more details.
24 ;; You should have received a copy of the GNU General Public License
25 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
27 ;;; Commentary:
29 ;; Some comments on the use of faces:
31 ;; o `c-label-face-name' is either `font-lock-constant-face' (in
32 ;; Emacs), or `font-lock-reference-face'.
34 ;; o `c-constant-face-name', `c-reference-face-name' and
35 ;; `c-doc-markup-face-name' are essentially set up like
36 ;; `c-label-face-name'.
38 ;; o `c-preprocessor-face-name' is `font-lock-preprocessor-face' in
39 ;; XEmacs and - in lack of a closer equivalent -
40 ;; `font-lock-builtin-face' or `font-lock-reference-face' in Emacs.
42 ;; o `c-doc-face-name' is `font-lock-doc-string-face' in XEmacs,
43 ;; `font-lock-doc-face' in Emacs 21 and later, or
44 ;; `font-lock-comment-face' in older Emacs (that since source
45 ;; documentation are actually comments in these languages, as opposed
46 ;; to elisp).
48 ;; TBD: We should probably provide real faces for the above uses and
49 ;; instead initialize them from the standard faces.
51 ;;; Code:
53 ;; The faces that already have been put onto the text is tested in
54 ;; various places to direct further fontifications. For this to work,
55 ;; the following assumptions regarding the faces must hold (apart from
56 ;; the dependencies on the font locking order):
58 ;; o `font-lock-comment-face' and the face in `c-doc-face-name' is
59 ;; not used in anything but comments.
60 ;; o If any face (e.g. `c-doc-markup-face-name') but those above is
61 ;; used in comments, it doesn't replace them.
62 ;; o `font-lock-string-face' is not used in anything but string
63 ;; literals (single or double quoted).
64 ;; o `font-lock-keyword-face' and the face in `c-label-face-name' are
65 ;; never overlaid with other faces.
67 (eval-when-compile
68 (let ((load-path
69 (if (and (boundp 'byte-compile-dest-file)
70 (stringp byte-compile-dest-file))
71 (cons (file-name-directory byte-compile-dest-file) load-path)
72 load-path)))
73 (load "cc-bytecomp" nil t)))
75 (cc-require 'cc-defs)
76 (cc-require-when-compile 'cc-langs)
77 (cc-require 'cc-vars)
78 (cc-require 'cc-engine)
79 (cc-require-when-compile 'cc-awk) ; Change from cc-require, 2003/6/18 to
80 ;; prevent cc-awk being loaded when it's not needed. There is now a (require
81 ;; 'cc-awk) in (defun awk-mode ..).
83 ;; Avoid repeated loading through the eval-after-load directive in
84 ;; cc-mode.el.
85 (provide 'cc-fonts)
87 (cc-external-require 'font-lock)
89 (cc-bytecomp-defvar parse-sexp-lookup-properties) ; Emacs only.
91 ;; Need to declare these local symbols during compilation since
92 ;; they're referenced from lambdas in `byte-compile' calls that are
93 ;; executed at compile time. They don't need to have the proper
94 ;; definitions, though, since the generated functions aren't called
95 ;; during compilation.
96 (cc-bytecomp-defvar c-preprocessor-face-name)
97 (cc-bytecomp-defvar c-reference-face-name)
98 (cc-bytecomp-defun c-fontify-recorded-types-and-refs)
99 (cc-bytecomp-defun c-font-lock-declarators)
100 (cc-bytecomp-defun c-font-lock-objc-method)
101 (cc-bytecomp-defun c-font-lock-invalid-string)
104 ;; Note that font-lock in XEmacs doesn't expand face names as
105 ;; variables, so we have to use the (eval . FORM) in the font lock
106 ;; matchers wherever we use these alias variables.
108 (defconst c-preprocessor-face-name
109 (cond ((c-face-name-p 'font-lock-preprocessor-face)
110 ;; XEmacs has a font-lock-preprocessor-face.
111 'font-lock-preprocessor-face)
112 ((c-face-name-p 'font-lock-builtin-face)
113 ;; In Emacs font-lock-builtin-face has traditionally been
114 ;; used for preprocessor directives.
115 'font-lock-builtin-face)
117 'font-lock-reference-face)))
119 (cc-bytecomp-defvar font-lock-constant-face)
121 (defconst c-label-face-name
122 (cond ((c-face-name-p 'font-lock-label-face)
123 ;; If it happens to occur in the future. (Well, the more
124 ;; pragmatic reason is to get unique faces for the test
125 ;; suite.)
126 'font-lock-label-face)
127 ((and (c-face-name-p 'font-lock-constant-face)
128 (eq font-lock-constant-face 'font-lock-constant-face))
129 ;; Test both if font-lock-constant-face exists and that it's
130 ;; not an alias for something else. This is important since
131 ;; we compare already set faces in various places.
132 'font-lock-constant-face)
134 'font-lock-reference-face)))
136 (defconst c-constant-face-name
137 (if (and (c-face-name-p 'font-lock-constant-face)
138 (eq font-lock-constant-face 'font-lock-constant-face))
139 ;; This doesn't exist in some earlier versions of XEmacs 21.
140 'font-lock-constant-face
141 c-label-face-name))
143 (defconst c-reference-face-name
144 (with-no-warnings
145 (if (and (c-face-name-p 'font-lock-reference-face)
146 (eq font-lock-reference-face 'font-lock-reference-face))
147 ;; This is considered obsolete in Emacs, but it still maps well
148 ;; to this use. (Another reason to do this is to get unique
149 ;; faces for the test suite.)
150 'font-lock-reference-face
151 c-label-face-name)))
153 ;; This should not mapped to a face that also is used to fontify things
154 ;; that aren't comments or string literals.
155 (defconst c-doc-face-name
156 (cond ((c-face-name-p 'font-lock-doc-string-face)
157 ;; XEmacs.
158 'font-lock-doc-string-face)
159 ((c-face-name-p 'font-lock-doc-face)
160 ;; Emacs 21 and later.
161 'font-lock-doc-face)
163 'font-lock-comment-face)))
165 (defconst c-doc-markup-face-name
166 (if (c-face-name-p 'font-lock-doc-markup-face)
167 ;; If it happens to occur in the future. (Well, the more
168 ;; pragmatic reason is to get unique faces for the test
169 ;; suite.)
170 'font-lock-doc-markup-face
171 c-label-face-name))
173 (defconst c-negation-char-face-name
174 (if (c-face-name-p 'font-lock-negation-char-face)
175 ;; Emacs 22 has a special face for negation chars.
176 'font-lock-negation-char-face))
178 (cc-bytecomp-defun face-inverse-video-p) ; Only in Emacs.
180 (defun c-make-inverse-face (oldface newface)
181 ;; Emacs and XEmacs have completely different face manipulation
182 ;; routines. :P
183 (copy-face oldface newface)
184 (cond ((fboundp 'face-inverse-video-p)
185 ;; Emacs. This only looks at the inverse flag in the current
186 ;; frame. Other display configurations might be different,
187 ;; but it can only show if the same Emacs has frames on
188 ;; e.g. a color and a monochrome display simultaneously.
189 (unless (face-inverse-video-p oldface)
190 (invert-face newface)))
191 ((fboundp 'face-property-instance)
192 ;; XEmacs. Same pitfall here.
193 (unless (face-property-instance oldface 'reverse)
194 (invert-face newface)))))
196 (defvar c-annotation-face 'c-annotation-face)
198 (defface c-annotation-face
199 '((default :inherit font-lock-constant-face))
200 "Face for highlighting annotations in Java mode and similar modes."
201 :version "24.1"
202 :group 'c)
204 (eval-and-compile
205 ;; We need the following definitions during compilation since they're
206 ;; used when the `c-lang-defconst' initializers are evaluated. Define
207 ;; them at runtime too for the sake of derived modes.
209 ;; This indicates the "font locking context", and is set just before
210 ;; fontification is done. If non-nil, it says, e.g., point starts
211 ;; from within a #if preprocessor construct.
212 (defvar c-font-lock-context nil)
213 (make-variable-buffer-local 'c-font-lock-context)
215 (defmacro c-put-font-lock-face (from to face)
216 ;; Put a face on a region (overriding any existing face) in the way
217 ;; font-lock would do it. In XEmacs that means putting an
218 ;; additional font-lock property, or else the font-lock package
219 ;; won't recognize it as fontified and might override it
220 ;; incorrectly.
222 ;; This function does a hidden buffer change.
223 (if (fboundp 'font-lock-set-face)
224 ;; Note: This function has no docstring in XEmacs so it might be
225 ;; considered internal.
226 `(font-lock-set-face ,from ,to ,face)
227 `(put-text-property ,from ,to 'face ,face)))
229 (defmacro c-remove-font-lock-face (from to)
230 ;; This is the inverse of `c-put-font-lock-face'.
232 ;; This function does a hidden buffer change.
233 (if (fboundp 'font-lock-remove-face)
234 `(font-lock-remove-face ,from ,to)
235 `(remove-text-properties ,from ,to '(face nil))))
237 (defmacro c-put-font-lock-string-face (from to)
238 ;; Put `font-lock-string-face' on a string. The surrounding
239 ;; quotes are included in Emacs but not in XEmacs. The passed
240 ;; region should include them.
242 ;; This function does a hidden buffer change.
243 (if (featurep 'xemacs)
244 `(c-put-font-lock-face (1+ ,from) (1- ,to) 'font-lock-string-face)
245 `(c-put-font-lock-face ,from ,to 'font-lock-string-face)))
247 (defmacro c-fontify-types-and-refs (varlist &rest body)
248 ;; Like `let', but additionally activates `c-record-type-identifiers'
249 ;; and `c-record-ref-identifiers', and fontifies the recorded ranges
250 ;; accordingly on exit.
252 ;; This function does hidden buffer changes.
253 `(let ((c-record-type-identifiers t)
254 c-record-ref-identifiers
255 ,@varlist)
256 (prog1 (progn ,@body)
257 (c-fontify-recorded-types-and-refs))))
258 (put 'c-fontify-types-and-refs 'lisp-indent-function 1)
260 (defun c-skip-comments-and-strings (limit)
261 ;; If the point is within a region fontified as a comment or
262 ;; string literal skip to the end of it or to LIMIT, whichever
263 ;; comes first, and return t. Otherwise return nil. The match
264 ;; data is not clobbered.
266 ;; This function might do hidden buffer changes.
267 (when (c-got-face-at (point) c-literal-faces)
268 (while (progn
269 (goto-char (c-next-single-property-change
270 (point) 'face nil limit))
271 (and (< (point) limit)
272 (c-got-face-at (point) c-literal-faces))))
275 (defun c-make-syntactic-matcher (regexp)
276 ;; Returns a byte compiled function suitable for use in place of a
277 ;; regexp string in a `font-lock-keywords' matcher, except that
278 ;; only matches outside comments and string literals count.
280 ;; This function does not do any hidden buffer changes, but the
281 ;; generated functions will. (They are however used in places
282 ;; covered by the font-lock context.)
283 (byte-compile
284 `(lambda (limit)
285 (let (res)
286 (while (and (setq res (re-search-forward ,regexp limit t))
287 (progn
288 (goto-char (match-beginning 0))
289 (or (c-skip-comments-and-strings limit)
290 (progn
291 (goto-char (match-end 0))
292 nil)))))
293 res))))
295 (defun c-make-font-lock-search-form (regexp highlights)
296 ;; Return a lisp form which will fontify every occurrence of REGEXP
297 ;; (a regular expression, NOT a function) between POINT and `limit'
298 ;; with HIGHLIGHTS, a list of highlighters as specified on page
299 ;; "Search-based Fontification" in the elisp manual.
300 `(while (re-search-forward ,regexp limit t)
301 (unless (progn
302 (goto-char (match-beginning 0))
303 (c-skip-comments-and-strings limit))
304 (goto-char (match-end 0))
305 ,@(mapcar
306 (lambda (highlight)
307 (if (integerp (car highlight))
308 ;; e.g. highlight is (1 font-lock-type-face t)
309 (progn
310 (unless (eq (nth 2 highlight) t)
311 (error
312 "The override flag must currently be t in %s"
313 highlight))
314 (when (nth 3 highlight)
315 (error
316 "The laxmatch flag may currently not be set in %s"
317 highlight))
318 `(save-match-data
319 (c-put-font-lock-face
320 (match-beginning ,(car highlight))
321 (match-end ,(car highlight))
322 ,(elt highlight 1))))
323 ;; highlight is an "ANCHORED HIGHLIGHTER" of the form
324 ;; (ANCHORED-MATCHER PRE-FORM POST-FORM SUBEXP-HIGHLIGHTERS...)
325 (when (nth 3 highlight)
326 (error "Match highlights currently not supported in %s"
327 highlight))
328 `(progn
329 ,(nth 1 highlight)
330 (save-match-data ,(car highlight))
331 ,(nth 2 highlight))))
332 highlights))))
334 (defun c-make-font-lock-search-function (regexp &rest highlights)
335 ;; This function makes a byte compiled function that works much like
336 ;; a matcher element in `font-lock-keywords'. It cuts out a little
337 ;; bit of the overhead compared to a real matcher. The main reason
338 ;; is however to pass the real search limit to the anchored
339 ;; matcher(s), since most (if not all) font-lock implementations
340 ;; arbitrarily limit anchored matchers to the same line, and also
341 ;; to insulate against various other irritating differences between
342 ;; the different (X)Emacs font-lock packages.
344 ;; REGEXP is the matcher, which must be a regexp. Only matches
345 ;; where the beginning is outside any comment or string literal are
346 ;; significant.
348 ;; HIGHLIGHTS is a list of highlight specs, just like in
349 ;; `font-lock-keywords', with these limitations: The face is always
350 ;; overridden (no big disadvantage, since hits in comments etc are
351 ;; filtered anyway), there is no "laxmatch", and an anchored matcher
352 ;; is always a form which must do all the fontification directly.
353 ;; `limit' is a variable bound to the real limit in the context of
354 ;; the anchored matcher forms.
356 ;; This function does not do any hidden buffer changes, but the
357 ;; generated functions will. (They are however used in places
358 ;; covered by the font-lock context.)
360 ;; Note: Replace `byte-compile' with `eval' to debug the generated
361 ;; lambda more easily.
362 (byte-compile
363 `(lambda (limit)
364 (let ( ;; The font-lock package in Emacs is known to clobber
365 ;; `parse-sexp-lookup-properties' (when it exists).
366 (parse-sexp-lookup-properties
367 (cc-eval-when-compile
368 (boundp 'parse-sexp-lookup-properties))))
369 ,(c-make-font-lock-search-form regexp highlights))
370 nil)))
372 (defun c-make-font-lock-BO-decl-search-function (regexp &rest highlights)
373 ;; This function makes a byte compiled function that first moves back
374 ;; to the beginning of the current declaration (if any), then searches
375 ;; forward for matcher elements (as in `font-lock-keywords') and
376 ;; fontifies them.
378 ;; The motivation for moving back to the declaration start is to
379 ;; establish a context for the current text when, e.g., a character
380 ;; is typed on a C++ inheritance continuation line, or a jit-lock
381 ;; chunk starts there.
383 ;; The new function works much like a matcher element in
384 ;; `font-lock-keywords'. It cuts out a little bit of the overhead
385 ;; compared to a real matcher. The main reason is however to pass the
386 ;; real search limit to the anchored matcher(s), since most (if not
387 ;; all) font-lock implementations arbitrarily limit anchored matchers
388 ;; to the same line, and also to insulate against various other
389 ;; irritating differences between the different (X)Emacs font-lock
390 ;; packages.
392 ;; REGEXP is the matcher, which must be a regexp. Only matches
393 ;; where the beginning is outside any comment or string literal are
394 ;; significant.
396 ;; HIGHLIGHTS is a list of highlight specs, just like in
397 ;; `font-lock-keywords', with these limitations: The face is always
398 ;; overridden (no big disadvantage, since hits in comments etc are
399 ;; filtered anyway), there is no "laxmatch", and an anchored matcher
400 ;; is always a form which must do all the fontification directly.
401 ;; `limit' is a variable bound to the real limit in the context of
402 ;; the anchored matcher forms.
404 ;; This function does not do any hidden buffer changes, but the
405 ;; generated functions will. (They are however used in places
406 ;; covered by the font-lock context.)
408 ;; Note: Replace `byte-compile' with `eval' to debug the generated
409 ;; lambda more easily.
410 (byte-compile
411 `(lambda (limit)
412 (let ( ;; The font-lock package in Emacs is known to clobber
413 ;; `parse-sexp-lookup-properties' (when it exists).
414 (parse-sexp-lookup-properties
415 (cc-eval-when-compile
416 (boundp 'parse-sexp-lookup-properties)))
417 (BOD-limit
418 (c-determine-limit 1000)))
419 (goto-char
420 (let ((here (point)))
421 (if (eq (car (c-beginning-of-decl-1 BOD-limit)) 'same)
422 (point)
423 here)))
424 ,(c-make-font-lock-search-form regexp highlights))
425 nil)))
427 (defun c-make-font-lock-context-search-function (normal &rest state-stanzas)
428 ;; This function makes a byte compiled function that works much like
429 ;; a matcher element in `font-lock-keywords', with the following
430 ;; enhancement: the generated function will test for particular "font
431 ;; lock contexts" at the start of the region, i.e. is this point in
432 ;; the middle of some particular construct? if so the generated
433 ;; function will first fontify the tail of the construct, before
434 ;; going into the main loop and fontify full constructs up to limit.
436 ;; The generated function takes one parameter called `limit', and
437 ;; will fontify the region between POINT and LIMIT.
439 ;; NORMAL is a list of the form (REGEXP HIGHLIGHTS .....), and is
440 ;; used to fontify the "regular" bit of the region.
441 ;; STATE-STANZAS is list of elements of the form (STATE LIM REGEXP
442 ;; HIGHLIGHTS), each element coding one possible font lock context.
444 ;; o - REGEXP is a font-lock regular expression (NOT a function),
445 ;; o - HIGHLIGHTS is a list of zero or more highlighters as defined
446 ;; on page "Search-based Fontification" in the elisp manual. As
447 ;; yet (2009-06), they must have OVERRIDE set, and may not have
448 ;; LAXMATCH set.
450 ;; o - STATE is the "font lock context" (e.g. in-cpp-expr) and is
451 ;; not quoted.
452 ;; o - LIM is a lisp form whose evaluation will yield the limit
453 ;; position in the buffer for fontification by this stanza.
455 ;; This function does not do any hidden buffer changes, but the
456 ;; generated functions will. (They are however used in places
457 ;; covered by the font-lock context.)
459 ;; Note: Replace `byte-compile' with `eval' to debug the generated
460 ;; lambda more easily.
461 (byte-compile
462 `(lambda (limit)
463 (let ( ;; The font-lock package in Emacs is known to clobber
464 ;; `parse-sexp-lookup-properties' (when it exists).
465 (parse-sexp-lookup-properties
466 (cc-eval-when-compile
467 (boundp 'parse-sexp-lookup-properties))))
468 ,@(mapcar
469 (lambda (stanza)
470 (let ((state (car stanza))
471 (lim (nth 1 stanza))
472 (regexp (nth 2 stanza))
473 (highlights (cdr (cddr stanza))))
474 `(if (eq c-font-lock-context ',state)
475 (let ((limit ,lim))
476 ,(c-make-font-lock-search-form
477 regexp highlights)))))
478 state-stanzas)
479 ,(c-make-font-lock-search-form (car normal) (cdr normal))
480 nil))))
482 ; (eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
483 ; '(progn
484 (def-edebug-spec c-fontify-types-and-refs let*)
485 (def-edebug-spec c-make-syntactic-matcher t)
486 ;; If there are literal quoted or backquoted highlight specs in
487 ;; the call to `c-make-font-lock-search-function' then let's
488 ;; instrument the forms in them.
489 (def-edebug-spec c-make-font-lock-search-function
490 (form &rest &or ("quote" (&rest form)) ("`" (&rest form)) form)));))
492 (defun c-fontify-recorded-types-and-refs ()
493 ;; Convert the ranges recorded on `c-record-type-identifiers' and
494 ;; `c-record-ref-identifiers' to fontification.
496 ;; This function does hidden buffer changes.
497 (let (elem)
498 (while (consp c-record-type-identifiers)
499 (setq elem (car c-record-type-identifiers)
500 c-record-type-identifiers (cdr c-record-type-identifiers))
501 (c-put-font-lock-face (car elem) (cdr elem)
502 'font-lock-type-face))
503 (while c-record-ref-identifiers
504 (setq elem (car c-record-ref-identifiers)
505 c-record-ref-identifiers (cdr c-record-ref-identifiers))
506 ;; Note that the reference face is a variable that is
507 ;; dereferenced, since it's an alias in Emacs.
508 (c-put-font-lock-face (car elem) (cdr elem)
509 c-reference-face-name))))
511 (c-lang-defconst c-cpp-matchers
512 "Font lock matchers for preprocessor directives and purely lexical
513 stuff. Used on level 1 and higher."
515 ;; Note: `c-font-lock-declarations' assumes that no matcher here
516 ;; sets `font-lock-type-face' in languages where
517 ;; `c-recognize-<>-arglists' is set.
519 t `(,@(when (c-lang-const c-opt-cpp-prefix)
520 (let* ((noncontinued-line-end "\\(\\=\\|\\(\\=\\|[^\\]\\)[\n\r]\\)")
521 (ncle-depth (regexp-opt-depth noncontinued-line-end))
522 (sws-depth (c-lang-const c-syntactic-ws-depth))
523 (nsws-depth (c-lang-const c-nonempty-syntactic-ws-depth)))
525 `(;; The stuff after #error and #warning is a message, so
526 ;; fontify it as a string.
527 ,@(when (c-lang-const c-cpp-message-directives)
528 (let* ((re (c-make-keywords-re 'appendable ; nil
529 (c-lang-const c-cpp-message-directives)))
530 (re-depth (regexp-opt-depth re)))
531 `((,(concat noncontinued-line-end
532 (c-lang-const c-opt-cpp-prefix)
534 "\\s +\\(.*\\)$")
535 ,(+ ncle-depth re-depth 1) font-lock-string-face t))))
537 ;; Fontify filenames in #include <...> as strings.
538 ,@(when (c-lang-const c-cpp-include-directives)
539 (let* ((re (c-make-keywords-re nil
540 (c-lang-const c-cpp-include-directives)))
541 (re-depth (regexp-opt-depth re)))
542 ;; We used to use a font-lock "anchored matcher" here for
543 ;; the paren syntax. This failed when the ">" was at EOL,
544 ;; since `font-lock-fontify-anchored-keywords' terminated
545 ;; its loop at EOL without executing our lambda form at
546 ;; all.
547 `((,(c-make-font-lock-search-function
548 (concat noncontinued-line-end
549 (c-lang-const c-opt-cpp-prefix)
551 (c-lang-const c-syntactic-ws)
552 "\\(<[^>\n\r]*>?\\)")
553 `(,(+ ncle-depth re-depth sws-depth 1)
554 font-lock-string-face t)
555 `((let ((beg (match-beginning
556 ,(+ ncle-depth re-depth sws-depth 1)))
557 (end (1- (match-end ,(+ ncle-depth re-depth
558 sws-depth 1)))))
559 (if (eq (char-after end) ?>)
560 (progn
561 (c-mark-<-as-paren beg)
562 (c-mark->-as-paren end))
563 (c-unmark-<->-as-paren beg)))
564 nil))))))
566 ;; #define.
567 ,@(when (c-lang-const c-opt-cpp-macro-define)
568 `((,(c-make-font-lock-search-function
569 (concat
570 noncontinued-line-end
571 (c-lang-const c-opt-cpp-prefix)
572 (c-lang-const c-opt-cpp-macro-define)
573 (c-lang-const c-nonempty-syntactic-ws)
574 "\\(" (c-lang-const ; 1 + ncle + nsws
575 c-symbol-key) "\\)"
576 (concat "\\(" ; 2 + ncle + nsws + c-sym-key
577 ;; Macro with arguments - a "function".
578 "\\((\\)" ; 3 + ncle + nsws + c-sym-key
579 "\\|"
580 ;; Macro without arguments - a "variable".
581 "\\([^(]\\|$\\)"
582 "\\)"))
583 `((if (match-beginning
584 ,(+ 3 ncle-depth nsws-depth
585 (c-lang-const c-symbol-key-depth)))
587 ;; "Function". Fontify the name and the arguments.
588 (save-restriction
589 (c-put-font-lock-face
590 (match-beginning ,(+ 1 ncle-depth nsws-depth))
591 (match-end ,(+ 1 ncle-depth nsws-depth))
592 'font-lock-function-name-face)
593 (goto-char
594 (match-end
595 ,(+ 3 ncle-depth nsws-depth
596 (c-lang-const c-symbol-key-depth))))
598 (narrow-to-region (point-min) limit)
599 (while (and
600 (progn
601 (c-forward-syntactic-ws)
602 (looking-at c-symbol-key))
603 (progn
604 (c-put-font-lock-face
605 (match-beginning 0) (match-end 0)
606 'font-lock-variable-name-face)
607 (goto-char (match-end 0))
608 (c-forward-syntactic-ws)
609 (eq (char-after) ?,)))
610 (forward-char)))
612 ;; "Variable".
613 (c-put-font-lock-face
614 (match-beginning ,(+ 1 ncle-depth nsws-depth))
615 (match-end ,(+ 1 ncle-depth nsws-depth))
616 'font-lock-variable-name-face)))))))
618 ;; Fontify cpp function names in preprocessor
619 ;; expressions in #if and #elif.
620 ,@(when (and (c-lang-const c-cpp-expr-directives)
621 (c-lang-const c-cpp-expr-functions))
622 (let ((ced-re (c-make-keywords-re t
623 (c-lang-const c-cpp-expr-directives)))
624 (cef-re (c-make-keywords-re t
625 (c-lang-const c-cpp-expr-functions))))
627 `((,(c-make-font-lock-context-search-function
628 `(,(concat noncontinued-line-end
629 (c-lang-const c-opt-cpp-prefix)
630 ced-re ; 1 + ncle-depth
631 ;; Match the whole logical line to look
632 ;; for the functions in.
633 "\\(\\\\\\(.\\|[\n\r]\\)\\|[^\n\r]\\)*")
634 ((let ((limit (match-end 0)))
635 (while (re-search-forward ,cef-re limit 'move)
636 (c-put-font-lock-face (match-beginning 1)
637 (match-end 1)
638 c-preprocessor-face-name)))
639 (goto-char (match-end ,(1+ ncle-depth)))))
640 `(in-cpp-expr
641 (save-excursion (c-end-of-macro) (point))
642 ,cef-re
643 (1 c-preprocessor-face-name t)))))))
645 ;; Fontify the directive names.
646 (,(c-make-font-lock-search-function
647 (concat noncontinued-line-end
648 "\\("
649 (c-lang-const c-opt-cpp-prefix)
650 "[" (c-lang-const c-symbol-chars) "]+"
651 "\\)")
652 `(,(1+ ncle-depth) c-preprocessor-face-name t)))
654 (eval . (list ,(c-make-syntactic-matcher
655 (concat noncontinued-line-end
656 (c-lang-const c-opt-cpp-prefix)
657 "if\\(n\\)def\\>"))
658 ,(+ ncle-depth 1)
659 c-negation-char-face-name
660 'append))
663 ,@(when (c-major-mode-is 'pike-mode)
664 ;; Recognize hashbangs in Pike.
665 `((eval . (list "\\`#![^\n\r]*"
666 0 c-preprocessor-face-name))))
668 ;; Make hard spaces visible through an inverted `font-lock-warning-face'.
669 (eval . (list
670 "\240"
671 0 (progn
672 (unless (c-face-name-p 'c-nonbreakable-space-face)
673 (c-make-inverse-face 'font-lock-warning-face
674 'c-nonbreakable-space-face))
675 ''c-nonbreakable-space-face)))
678 (defun c-font-lock-invalid-string ()
679 ;; Assuming the point is after the opening character of a string,
680 ;; fontify that char with `font-lock-warning-face' if the string
681 ;; decidedly isn't terminated properly.
683 ;; This function does hidden buffer changes.
684 (let ((start (1- (point))))
685 (save-excursion
686 (and (eq (elt (parse-partial-sexp start (c-point 'eol)) 8) start)
687 (if (if (eval-when-compile (integerp ?c))
688 ;; Emacs
689 (integerp c-multiline-string-start-char)
690 ;; XEmacs
691 (characterp c-multiline-string-start-char))
692 ;; There's no multiline string start char before the
693 ;; string, so newlines aren't allowed.
694 (not (eq (char-before start) c-multiline-string-start-char))
695 ;; Multiline strings are allowed anywhere if
696 ;; c-multiline-string-start-char is t.
697 (not c-multiline-string-start-char))
698 (if c-string-escaped-newlines
699 ;; There's no \ before the newline.
700 (not (eq (char-before (point)) ?\\))
701 ;; Escaped newlines aren't supported.
703 (c-put-font-lock-face start (1+ start) 'font-lock-warning-face)))))
705 (c-lang-defconst c-basic-matchers-before
706 "Font lock matchers for basic keywords, labels, references and various
707 other easily recognizable things that should be fontified before generic
708 casts and declarations are fontified. Used on level 2 and higher."
710 ;; Note: `c-font-lock-declarations' assumes that no matcher here
711 ;; sets `font-lock-type-face' in languages where
712 ;; `c-recognize-<>-arglists' is set.
714 t `(;; Put a warning face on the opener of unclosed strings that
715 ;; can't span lines. Later font
716 ;; lock packages have a `font-lock-syntactic-face-function' for
717 ;; this, but it doesn't give the control we want since any
718 ;; fontification done inside the function will be
719 ;; unconditionally overridden.
720 ,(c-make-font-lock-search-function
721 ;; Match a char before the string starter to make
722 ;; `c-skip-comments-and-strings' work correctly.
723 (concat ".\\(" c-string-limit-regexp "\\)")
724 '((c-font-lock-invalid-string)))
726 ;; Fontify C++ raw strings.
727 ,@(when (c-major-mode-is 'c++-mode)
728 '(c-font-lock-raw-strings))
730 ;; Fontify keyword constants.
731 ,@(when (c-lang-const c-constant-kwds)
732 (let ((re (c-make-keywords-re nil (c-lang-const c-constant-kwds))))
733 (if (c-major-mode-is 'pike-mode)
734 ;; No symbol is a keyword after "->" in Pike.
735 `((eval . (list ,(concat "\\(\\=.?\\|[^>]\\|[^-]>\\)"
736 "\\<\\(" re "\\)\\>")
737 2 c-constant-face-name)))
738 `((eval . (list ,(concat "\\<\\(" re "\\)\\>")
739 1 c-constant-face-name))))))
741 ;; Fontify all keywords except the primitive types.
742 ,(if (c-major-mode-is 'pike-mode)
743 ;; No symbol is a keyword after "->" in Pike.
744 `(,(concat "\\(\\=.?\\|[^>]\\|[^-]>\\)"
745 "\\<" (c-lang-const c-regular-keywords-regexp))
746 2 font-lock-keyword-face)
747 `(,(concat "\\<" (c-lang-const c-regular-keywords-regexp))
748 1 font-lock-keyword-face))
750 ;; Fontify leading identifiers in fully qualified names like
751 ;; "foo::bar" in languages that supports such things.
752 ,@(when (c-lang-const c-opt-identifier-concat-key)
753 (if (c-major-mode-is 'java-mode)
754 ;; Java needs special treatment since "." is used both to
755 ;; qualify names and in normal indexing. Here we look for
756 ;; capital characters at the beginning of an identifier to
757 ;; recognize the class. "*" is also recognized to cover
758 ;; wildcard import declarations. All preceding dot separated
759 ;; identifiers are taken as package names and therefore
760 ;; fontified as references.
761 `(,(c-make-font-lock-search-function
762 ;; Search for class identifiers preceded by ".". The
763 ;; anchored matcher takes it from there.
764 (concat (c-lang-const c-opt-identifier-concat-key)
765 (c-lang-const c-simple-ws) "*"
766 (concat "\\("
767 "[" c-upper "]"
768 "[" (c-lang-const c-symbol-chars) "]*"
769 "\\|"
770 "\\*"
771 "\\)"))
772 `((let (id-end)
773 (goto-char (1+ (match-beginning 0)))
774 (while (and (eq (char-before) ?.)
775 (progn
776 (backward-char)
777 (c-backward-syntactic-ws)
778 (setq id-end (point))
779 (< (skip-chars-backward
780 ,(c-lang-const c-symbol-chars)) 0))
781 (not (get-text-property (point) 'face)))
782 (c-put-font-lock-face (point) id-end
783 c-reference-face-name)
784 (c-backward-syntactic-ws)))
786 (goto-char (match-end 0)))))
788 `((,(byte-compile
789 ;; Must use a function here since we match longer than
790 ;; we want to move before doing a new search. This is
791 ;; not necessary for XEmacs since it restarts the
792 ;; search from the end of the first highlighted
793 ;; submatch (something that causes problems in other
794 ;; places).
795 `(lambda (limit)
796 (while (re-search-forward
797 ,(concat "\\(\\<" ; 1
798 "\\(" (c-lang-const c-symbol-key) "\\)" ; 2
799 (c-lang-const c-simple-ws) "*"
800 (c-lang-const c-opt-identifier-concat-key)
801 (c-lang-const c-simple-ws) "*"
802 "\\)"
803 "\\("
804 (c-lang-const c-opt-after-id-concat-key)
805 "\\)")
806 limit t)
807 (unless (progn
808 (goto-char (match-beginning 0))
809 (c-skip-comments-and-strings limit))
810 (or (get-text-property (match-beginning 2) 'face)
811 (c-put-font-lock-face (match-beginning 2)
812 (match-end 2)
813 c-reference-face-name))
814 (goto-char (match-end 1))))))))))
816 ;; Fontify the special declarations in Objective-C.
817 ,@(when (c-major-mode-is 'objc-mode)
818 `(;; Fontify class names in the beginning of message expressions.
819 ,(c-make-font-lock-search-function
820 "\\["
821 '((c-fontify-types-and-refs ()
822 (c-forward-syntactic-ws limit)
823 (let ((start (point)))
824 ;; In this case we accept both primitive and known types.
825 (when (eq (c-forward-type) 'known)
826 (goto-char start)
827 (let ((c-promote-possible-types t))
828 (c-forward-type))))
829 (if (> (point) limit) (goto-char limit)))))
831 ;; The @interface/@implementation/@protocol directives.
832 ,(c-make-font-lock-search-function
833 (concat "\\<"
834 (regexp-opt
835 '("@interface" "@implementation" "@protocol")
837 "\\>")
838 '((c-fontify-types-and-refs
839 (;; The font-lock package in Emacs is known to clobber
840 ;; `parse-sexp-lookup-properties' (when it exists).
841 (parse-sexp-lookup-properties
842 (cc-eval-when-compile
843 (boundp 'parse-sexp-lookup-properties))))
844 (c-forward-objc-directive)
845 nil)
846 (goto-char (match-beginning 0))))))
848 (eval . (list "\\(!\\)[^=]" 1 c-negation-char-face-name))
851 (defun c-font-lock-complex-decl-prepare (limit)
852 ;; This function will be called from font-lock for a region bounded by POINT
853 ;; and LIMIT, as though it were to identify a keyword for
854 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
855 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
856 ;; Fontification".
858 ;; Called before any of the matchers in `c-complex-decl-matchers'.
860 ;; This function does hidden buffer changes.
862 ;;(message "c-font-lock-complex-decl-prepare %s %s" (point) limit)
864 ;; Clear the list of found types if we start from the start of the
865 ;; buffer, to make it easier to get rid of misspelled types and
866 ;; variables that have gotten recognized as types in malformed code.
867 (when (bobp)
868 (c-clear-found-types))
870 ;; Clear the c-type char properties which mark the region, to recalculate
871 ;; them properly. The most interesting properties are those put on the
872 ;; closest token before the region.
873 (save-excursion
874 (let ((pos (point)))
875 (c-backward-syntactic-ws)
876 (c-clear-char-properties
877 (if (and (not (bobp))
878 (memq (c-get-char-property (1- (point)) 'c-type)
879 '(c-decl-arg-start
880 c-decl-end
881 c-decl-id-start
882 c-decl-type-start)))
883 (1- (point))
884 pos)
885 limit 'c-type)))
887 ;; Update `c-state-cache' to the beginning of the region. This will
888 ;; make `c-beginning-of-syntax' go faster when it's used later on,
889 ;; and it's near the point most of the time.
890 (c-parse-state)
892 ;; Check if the fontified region starts inside a declarator list so
893 ;; that `c-font-lock-declarators' should be called at the start.
894 ;; The declared identifiers are font-locked correctly as types, if
895 ;; that is what they are.
896 (let ((prop (save-excursion
897 (c-backward-syntactic-ws)
898 (unless (bobp)
899 (c-get-char-property (1- (point)) 'c-type)))))
900 (when (memq prop '(c-decl-id-start c-decl-type-start))
901 (c-forward-syntactic-ws limit)
902 (c-font-lock-declarators limit t (eq prop 'c-decl-type-start)
903 (c-bs-at-toplevel-p (point)))))
905 (setq c-font-lock-context ;; (c-guess-font-lock-context)
906 (save-excursion
907 (if (and c-cpp-expr-intro-re
908 (c-beginning-of-macro)
909 (looking-at c-cpp-expr-intro-re))
910 'in-cpp-expr)))
911 nil)
913 (defun c-font-lock-<>-arglists (limit)
914 ;; This function will be called from font-lock for a region bounded by POINT
915 ;; and LIMIT, as though it were to identify a keyword for
916 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
917 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
918 ;; Fontification".
920 ;; Fontify types and references in names containing angle bracket
921 ;; arglists from the point to LIMIT. Note that
922 ;; `c-font-lock-declarations' has already handled many of them.
924 ;; This function might do hidden buffer changes.
926 (let (;; The font-lock package in Emacs is known to clobber
927 ;; `parse-sexp-lookup-properties' (when it exists).
928 (parse-sexp-lookup-properties
929 (cc-eval-when-compile
930 (boundp 'parse-sexp-lookup-properties)))
931 (c-parse-and-markup-<>-arglists t)
932 c-restricted-<>-arglists
933 id-start id-end id-face pos kwd-sym)
935 (while (and (< (point) limit)
936 (re-search-forward c-opt-<>-arglist-start limit t))
938 (setq id-start (match-beginning 1)
939 id-end (match-end 1)
940 pos (point))
942 (goto-char id-start)
943 (unless (c-skip-comments-and-strings limit)
944 (setq kwd-sym nil
945 c-restricted-<>-arglists nil
946 id-face (get-text-property id-start 'face))
948 (if (cond
949 ((eq id-face 'font-lock-type-face)
950 ;; The identifier got the type face so it has already been
951 ;; handled in `c-font-lock-declarations'.
952 nil)
954 ((eq id-face 'font-lock-keyword-face)
955 (when (looking-at c-opt-<>-sexp-key)
956 ;; There's a special keyword before the "<" that tells
957 ;; that it's an angle bracket arglist.
958 (setq kwd-sym (c-keyword-sym (match-string 1)))))
961 ;; There's a normal identifier before the "<". If we're not in
962 ;; a declaration context then we set `c-restricted-<>-arglists'
963 ;; to avoid recognizing templates in function calls like "foo (a
964 ;; < b, c > d)".
965 (c-backward-syntactic-ws)
966 (when (and (memq (char-before) '(?\( ?,))
967 (not (eq (get-text-property (1- (point)) 'c-type)
968 'c-decl-arg-start)))
969 (setq c-restricted-<>-arglists t))
972 (progn
973 (goto-char (1- pos))
974 ;; Check for comment/string both at the identifier and
975 ;; at the "<".
976 (unless (c-skip-comments-and-strings limit)
978 (c-fontify-types-and-refs ()
979 (when (c-forward-<>-arglist (c-keyword-member
980 kwd-sym 'c-<>-type-kwds))
981 (when (and c-opt-identifier-concat-key
982 (not (get-text-property id-start 'face)))
983 (c-forward-syntactic-ws)
984 (cond ((looking-at c-opt-identifier-concat-key)
985 (c-put-font-lock-face id-start id-end
986 c-reference-face-name))
987 ((eq (char-after) ?\())
988 (t (c-put-font-lock-face id-start id-end
989 'font-lock-type-face))))))
991 (goto-char pos)))
992 (goto-char pos)))))
993 nil)
995 (defun c-font-lock-declarators (limit list types not-top)
996 ;; Assuming the point is at the start of a declarator in a declaration,
997 ;; fontify the identifier it declares. (If TYPES is set, it does this via
998 ;; the macro `c-fontify-types-and-refs'.)
1000 ;; If LIST is non-nil, also fontify the ids in any following declarators in
1001 ;; a comma separated list (e.g. "foo" and "*bar" in "int foo = 17, *bar;");
1002 ;; additionally, mark the commas with c-type property 'c-decl-id-start or
1003 ;; 'c-decl-type-start (according to TYPES). Stop at LIMIT.
1005 ;; If TYPES is non-nil, fontify all identifiers as types. If NOT-TOP is
1006 ;; non-nil, we are not at the top-level ("top-level" includes being directly
1007 ;; inside a class or namespace, etc.).
1009 ;; Nil is always returned. The function leaves point at the delimiter after
1010 ;; the last declarator it processes.
1012 ;; This function might do hidden buffer changes.
1014 ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
1015 (c-fontify-types-and-refs
1016 ((pos (point)) next-pos id-start id-end
1017 decl-res
1018 paren-depth
1019 id-face got-type got-init
1020 c-last-identifier-range
1021 (separator-prop (if types 'c-decl-type-start 'c-decl-id-start))
1022 brackets-after-id)
1024 ;; The following `while' fontifies a single declarator id each time round.
1025 ;; It loops only when LIST is non-nil.
1026 (while
1027 (and pos (setq decl-res (c-forward-declarator limit)))
1028 (setq next-pos (point)
1029 id-start (car decl-res)
1030 id-face (if (and (eq (char-after) ?\()
1031 (or (not (c-major-mode-is 'c++-mode))
1032 (not not-top)
1033 (car (cddr (cddr decl-res))) ; Id is in
1034 ; parens, etc.
1035 (save-excursion
1036 (forward-char)
1037 (c-forward-syntactic-ws)
1038 (looking-at "[*&]")))
1039 (not (car (cddr decl-res))) ; brackets-after-id
1040 (or (not (c-major-mode-is 'c++-mode))
1041 (save-excursion
1042 (let (c-last-identifier-range)
1043 (forward-char)
1044 (c-forward-syntactic-ws)
1045 (catch 'is-function
1046 (while
1047 (progn
1048 (if (eq (char-after) ?\))
1049 (throw 'is-function t))
1050 (setq got-type (c-forward-type))
1051 (cond
1052 ((null got-type)
1053 (throw 'is-function nil))
1054 ((not (eq got-type 'maybe))
1055 (throw 'is-function t)))
1056 (c-forward-declarator limit t)
1057 (eq (char-after) ?,))
1058 (forward-char)
1059 (c-forward-syntactic-ws))
1060 t)))))
1061 'font-lock-function-name-face
1062 'font-lock-variable-name-face)
1063 got-init (and (cadr (cddr decl-res)) ; got-init
1064 (char-after)))
1066 (if types
1067 ;; Register and fontify the identifier as a type.
1068 (let ((c-promote-possible-types t))
1069 (goto-char id-start)
1070 (c-forward-type))
1071 ;; Fontify the last symbol in the identifier if it isn't fontified
1072 ;; already. The check is necessary only in certain cases where this
1073 ;; function is used "sloppily", e.g. in `c-simple-decl-matchers'.
1074 (when (and c-last-identifier-range
1075 (not (get-text-property (car c-last-identifier-range)
1076 'face)))
1077 (c-put-font-lock-face (car c-last-identifier-range)
1078 (cdr c-last-identifier-range)
1079 id-face)))
1081 (goto-char next-pos)
1082 (setq pos nil) ; So as to terminate the enclosing `while' form.
1083 (when list
1084 ;; Jump past any initializer or function prototype to see if
1085 ;; there's a ',' to continue at.
1086 (cond ((eq id-face 'font-lock-function-name-face)
1087 ;; Skip a parenthesized initializer (C++) or a function
1088 ;; prototype.
1089 (if (c-safe (c-forward-sexp 1) t) ; over the parameter list.
1090 (c-forward-syntactic-ws limit)
1091 (goto-char limit))) ; unbalanced parens
1093 (got-init ; "=" sign OR opening "(", "[", or "{"
1094 ;; Skip an initializer expression. If we're at a '='
1095 ;; then accept a brace list directly after it to cope
1096 ;; with array initializers. Otherwise stop at braces
1097 ;; to avoid going past full function and class blocks.
1098 (and (if (and (eq got-init ?=)
1099 (= (c-forward-token-2 1 nil limit) 0)
1100 (looking-at "{"))
1101 (c-safe (c-forward-sexp) t) ; over { .... }
1103 (< (point) limit)
1104 ;; FIXME: Should look for c-decl-end markers here;
1105 ;; we might go far into the following declarations
1106 ;; in e.g. ObjC mode (see e.g. methods-4.m).
1107 (c-syntactic-re-search-forward "[;,{]" limit 'move t)
1108 (backward-char)))
1110 (t (c-forward-syntactic-ws limit)))
1112 ;; If a ',' is found we set pos to the next declarator and iterate.
1113 (when (and (< (point) limit) (looking-at ","))
1114 (c-put-char-property (point) 'c-type separator-prop)
1115 (forward-char)
1116 (c-forward-syntactic-ws limit)
1117 (setq pos (point)))))) ; acts to make the `while' form continue.
1118 nil)
1120 (defun c-font-lock-declarations (limit)
1121 ;; Fontify all the declarations, casts and labels from the point to LIMIT.
1122 ;; Assumes that strings and comments have been fontified already.
1124 ;; This function will be called from font-lock for a region bounded by POINT
1125 ;; and LIMIT, as though it were to identify a keyword for
1126 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1127 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1128 ;; Fontification".
1130 ;; This function might do hidden buffer changes.
1132 ;;(message "c-font-lock-declarations search from %s to %s" (point) limit)
1134 (save-restriction
1135 (let (;; The position where `c-find-decl-spots' last stopped.
1136 start-pos
1137 ;; o - 'decl if we're in an arglist containing declarations
1138 ;; (but if `c-recognize-paren-inits' is set it might also be
1139 ;; an initializer arglist);
1140 ;; o - '<> if the arglist is of angle bracket type;
1141 ;; o - 'arglist if it's some other arglist;
1142 ;; o - nil, if not in an arglist at all. This includes the
1143 ;; parenthesized condition which follows "if", "while", etc.
1144 context
1145 ;; A list of starting positions of possible type declarations, or of
1146 ;; the typedef preceding one, if any.
1147 last-cast-end
1148 ;; The result from `c-forward-decl-or-cast-1'.
1149 decl-or-cast
1150 ;; The maximum of the end positions of all the checked type
1151 ;; decl expressions in the successfully identified
1152 ;; declarations. The position might be either before or
1153 ;; after the syntactic whitespace following the last token
1154 ;; in the type decl expression.
1155 (max-type-decl-end 0)
1156 ;; Same as `max-type-decl-*', but used when we're before
1157 ;; `token-pos'.
1158 (max-type-decl-end-before-token 0)
1159 ;; End of <..> construct which has had c-<>-arg-sep c-type
1160 ;; properties set within it.
1161 (max-<>-end 0)
1162 ;; Set according to the context to direct the heuristics for
1163 ;; recognizing C++ templates.
1164 c-restricted-<>-arglists
1165 ;; Turn on recording of identifier ranges in
1166 ;; `c-forward-decl-or-cast-1' and `c-forward-label' for
1167 ;; later fontification.
1168 (c-record-type-identifiers t)
1169 label-type
1170 c-record-ref-identifiers
1171 ;; Make `c-forward-type' calls mark up template arglists if
1172 ;; it finds any. That's necessary so that we later will
1173 ;; stop inside them to fontify types there.
1174 (c-parse-and-markup-<>-arglists t)
1175 lbrace ; position of some {.
1176 ;; The font-lock package in Emacs is known to clobber
1177 ;; `parse-sexp-lookup-properties' (when it exists).
1178 (parse-sexp-lookup-properties
1179 (cc-eval-when-compile
1180 (boundp 'parse-sexp-lookup-properties))
1183 ;; Below we fontify a whole declaration even when it crosses the limit,
1184 ;; to avoid gaps when jit/lazy-lock fontifies the file a block at a
1185 ;; time. That is however annoying during editing, e.g. the following is
1186 ;; a common situation while the first line is being written:
1188 ;; my_variable
1189 ;; some_other_variable = 0;
1191 ;; font-lock will put the limit at the beginning of the second line
1192 ;; here, and if we go past it we'll fontify "my_variable" as a type and
1193 ;; "some_other_variable" as an identifier, and the latter will not
1194 ;; correct itself until the second line is changed. To avoid that we
1195 ;; narrow to the limit if the region to fontify is a single line.
1196 (if (<= limit (c-point 'bonl))
1197 (narrow-to-region
1198 (point-min)
1199 (save-excursion
1200 ;; Narrow after any operator chars following the limit though,
1201 ;; since those characters can be useful in recognizing a
1202 ;; declaration (in particular the '{' that opens a function body
1203 ;; after the header).
1204 (goto-char limit)
1205 (skip-chars-forward c-nonsymbol-chars)
1206 (point))))
1208 (c-find-decl-spots
1209 limit
1210 c-decl-start-re
1211 (eval c-maybe-decl-faces)
1213 (lambda (match-pos inside-macro &optional toplev)
1214 ;; Note to maintainers: don't use `limit' inside this lambda form;
1215 ;; c-find-decl-spots sometimes narrows to less than `limit'.
1216 (setq start-pos (point))
1217 (when
1218 ;; The result of the form below is true when we don't recognize a
1219 ;; declaration or cast, and we don't recognize a "non-decl",
1220 ;; typically a brace list.
1221 (if (or (and (eq (get-text-property (point) 'face)
1222 'font-lock-keyword-face)
1223 (looking-at c-not-decl-init-keywords))
1224 (and c-macro-with-semi-re
1225 (looking-at c-macro-with-semi-re))) ; 2008-11-04
1226 ;; Don't do anything more if we're looking at a keyword that
1227 ;; can't start a declaration.
1230 ;; Set `context' and `c-restricted-<>-arglists'. Look for
1231 ;; "<" for the sake of C++-style template arglists.
1232 ;; Ignore "(" when it's part of a control flow construct
1233 ;; (e.g. "for (").
1234 (let ((type (and (> match-pos (point-min))
1235 (c-get-char-property (1- match-pos) 'c-type))))
1236 (cond ((not (memq (char-before match-pos) '(?\( ?, ?\[ ?< ?{)))
1237 (setq context (and toplev 'top)
1238 c-restricted-<>-arglists nil))
1239 ;; A control flow expression or a decltype
1240 ((and (eq (char-before match-pos) ?\()
1241 (save-excursion
1242 (goto-char match-pos)
1243 (backward-char)
1244 (c-backward-token-2)
1245 (or (looking-at c-block-stmt-2-key)
1246 (looking-at c-block-stmt-1-2-key)
1247 (looking-at c-typeof-key))))
1248 (setq context nil
1249 c-restricted-<>-arglists t))
1250 ;; Near BOB.
1251 ((<= match-pos (point-min))
1252 (setq context 'arglist
1253 c-restricted-<>-arglists t))
1254 ;; Got a cached hit in a declaration arglist.
1255 ((eq type 'c-decl-arg-start)
1256 (setq context 'decl
1257 c-restricted-<>-arglists nil))
1258 ;; We're inside (probably) a brace list.
1259 ((eq type 'c-not-decl)
1260 (setq context 'not-decl
1261 c-restricted-<>-arglists nil))
1262 ;; Inside a C++11 lambda function arglist.
1263 ((and (c-major-mode-is 'c++-mode)
1264 (eq (char-before match-pos) ?\()
1265 (save-excursion
1266 (goto-char match-pos)
1267 (c-backward-token-2)
1268 (and
1269 (c-safe (goto-char (scan-sexps (point) -1)))
1270 (c-looking-at-c++-lambda-capture-list))))
1271 (setq context 'decl
1272 c-restricted-<>-arglists nil)
1273 (c-put-char-property (1- match-pos) 'c-type
1274 'c-decl-arg-start))
1275 ;; We're inside a brace list.
1276 ((and (eq (char-before match-pos) ?{)
1277 (save-excursion
1278 (goto-char (1- match-pos))
1279 (consp
1280 (c-looking-at-or-maybe-in-bracelist))))
1281 (setq context 'not-decl
1282 c-restricted-<>-arglists nil)
1283 (c-put-char-property (1- match-pos) 'c-type
1284 'c-not-decl))
1285 ;; We're inside an "ordinary" open brace.
1286 ((eq (char-before match-pos) ?{)
1287 (setq context (and toplev 'top)
1288 c-restricted-<>-arglists nil))
1289 ;; Inside an angle bracket arglist.
1290 ((or (eq type 'c-<>-arg-sep)
1291 (eq (char-before match-pos) ?<))
1292 (setq context '<>
1293 c-restricted-<>-arglists nil))
1294 ;; Got a cached hit in some other type of arglist.
1295 (type
1296 (setq context 'arglist
1297 c-restricted-<>-arglists t))
1298 ((if inside-macro
1299 (< match-pos max-type-decl-end-before-token)
1300 (< match-pos max-type-decl-end))
1301 ;; The point is within the range of a previously
1302 ;; encountered type decl expression, so the arglist
1303 ;; is probably one that contains declarations.
1304 ;; However, if `c-recognize-paren-inits' is set it
1305 ;; might also be an initializer arglist.
1306 (setq context 'decl
1307 c-restricted-<>-arglists nil)
1308 ;; The result of this check is cached with a char
1309 ;; property on the match token, so that we can look
1310 ;; it up again when refontifying single lines in a
1311 ;; multiline declaration.
1312 (c-put-char-property (1- match-pos)
1313 'c-type 'c-decl-arg-start))
1314 ;; Got an open paren preceded by an arith operator.
1315 ((and (eq (char-before match-pos) ?\()
1316 (save-excursion
1317 (and (zerop (c-backward-token-2 2))
1318 (looking-at c-arithmetic-op-regexp))))
1319 (setq context nil
1320 c-restricted-<>-arglists nil))
1321 (t (setq context 'arglist
1322 c-restricted-<>-arglists t))))
1324 ;; Check we haven't missed a preceding "typedef".
1325 (when (not (looking-at c-typedef-key))
1326 (c-backward-syntactic-ws)
1327 (c-backward-token-2)
1328 (or (looking-at c-typedef-key)
1329 (goto-char start-pos)))
1331 ;; In QT, "more" is an irritating keyword that expands to nothing.
1332 ;; We skip over it to prevent recognition of "more slots: <symbol>"
1333 ;; as a bitfield declaration.
1334 (when (and (c-major-mode-is 'c++-mode)
1335 (looking-at
1336 (concat "\\(more\\)\\([^" c-symbol-chars "]\\|$\\)")))
1337 (goto-char (match-end 1))
1338 (c-forward-syntactic-ws))
1340 ;; Now analyze the construct.
1341 (if (eq context 'not-decl)
1342 (progn
1343 (setq decl-or-cast nil)
1344 (if (c-syntactic-re-search-forward
1345 "," (min limit (point-max)) 'at-limit t)
1346 (c-put-char-property (1- (point)) 'c-type 'c-not-decl))
1347 nil)
1348 (setq decl-or-cast
1349 (c-forward-decl-or-cast-1
1350 match-pos context last-cast-end))
1352 ;; Ensure that c-<>-arg-sep c-type properties are in place on the
1353 ;; commas separating the arguments inside template/generic <..>s.
1354 (when (and (eq (char-before match-pos) ?<)
1355 (> match-pos max-<>-end))
1356 (save-excursion
1357 (goto-char match-pos)
1358 (c-backward-token-2)
1359 (if (and
1360 (eq (char-after) ?<)
1361 (let ((c-restricted-<>-arglists
1362 (save-excursion
1363 (c-backward-token-2)
1364 (and
1365 (not (looking-at c-opt-<>-sexp-key))
1366 (progn (c-backward-syntactic-ws)
1367 (memq (char-before) '(?\( ?,)))
1368 (not (eq (c-get-char-property (1- (point))
1369 'c-type)
1370 'c-decl-arg-start))))))
1371 (c-forward-<>-arglist nil)))
1372 (setq max-<>-end (point)))))
1374 (cond
1375 ((eq decl-or-cast 'cast)
1376 ;; Save the position after the previous cast so we can feed
1377 ;; it to `c-forward-decl-or-cast-1' in the next round. That
1378 ;; helps it discover cast chains like "(a) (b) c".
1379 (setq last-cast-end (point))
1380 (c-fontify-recorded-types-and-refs)
1381 nil)
1383 (decl-or-cast
1384 ;; We've found a declaration.
1386 ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
1387 ;; under the assumption that we're after the first type decl
1388 ;; expression in the declaration now. That's not really true;
1389 ;; we could also be after a parenthesized initializer
1390 ;; expression in C++, but this is only used as a last resort
1391 ;; to slant ambiguous expression/declarations, and overall
1392 ;; it's worth the risk to occasionally fontify an expression
1393 ;; as a declaration in an initializer expression compared to
1394 ;; getting ambiguous things in normal function prototypes
1395 ;; fontified as expressions.
1396 (if inside-macro
1397 (when (> (point) max-type-decl-end-before-token)
1398 (setq max-type-decl-end-before-token (point)))
1399 (when (> (point) max-type-decl-end)
1400 (setq max-type-decl-end (point))))
1402 ;; Do we have an expression as the second or third clause of
1403 ;; a "for" paren expression?
1404 (if (save-excursion
1405 (and
1406 (car (cddr decl-or-cast)) ; maybe-expression flag.
1407 (goto-char start-pos)
1408 (c-go-up-list-backward)
1409 (eq (char-after) ?\()
1410 (progn (c-backward-syntactic-ws)
1411 (c-simple-skip-symbol-backward))
1412 (looking-at c-paren-stmt-key)
1413 (progn (goto-char match-pos)
1414 (while (and (eq (char-before) ?\))
1415 (c-go-list-backward))
1416 (c-backward-syntactic-ws))
1417 (eq (char-before) ?\;))))
1418 ;; We've got an expression in "for" parens. Remove the
1419 ;; "type" that would spuriously get fontified.
1420 (let ((elt (and (consp c-record-type-identifiers)
1421 (assq (cadr (cddr decl-or-cast))
1422 c-record-type-identifiers))))
1423 (when elt
1424 (setq c-record-type-identifiers
1425 (c-delq-from-dotted-list
1426 elt c-record-type-identifiers)))
1428 ;; Back up to the type to fontify the declarator(s).
1429 (goto-char (car decl-or-cast))
1431 (let ((decl-list
1432 (if (not (memq context '(nil top)))
1433 ;; Should normally not fontify a list of
1434 ;; declarators inside an arglist, but the first
1435 ;; argument in the ';' separated list of a "for"
1436 ;; statement is an exception.
1437 (when (eq (char-before match-pos) ?\()
1438 (save-excursion
1439 (goto-char (1- match-pos))
1440 (c-backward-syntactic-ws)
1441 (and (c-simple-skip-symbol-backward)
1442 (looking-at c-paren-stmt-key))))
1443 t)))
1445 ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
1446 ;; before the first declarator if it's a list.
1447 ;; `c-font-lock-declarators' handles the rest.
1448 (when decl-list
1449 (save-excursion
1450 (c-backward-syntactic-ws)
1451 (unless (bobp)
1452 (c-put-char-property (1- (point)) 'c-type
1453 (if (cadr decl-or-cast)
1454 'c-decl-type-start
1455 'c-decl-id-start)))))
1457 (c-font-lock-declarators
1458 (min limit (point-max)) decl-list
1459 (cadr decl-or-cast) (not toplev)))
1461 ;; A declaration has been successfully identified, so do all the
1462 ;; fontification of types and refs that've been recorded.
1463 (c-fontify-recorded-types-and-refs)
1464 nil))
1466 (t t))))
1468 ;; It was a false alarm. Check if we're in a label (or other
1469 ;; construct with `:' except bitfield) instead.
1470 (goto-char start-pos)
1471 (when (setq label-type (c-forward-label t match-pos nil))
1472 ;; Can't use `c-fontify-types-and-refs' here since we
1473 ;; use the label face at times.
1474 (cond ((eq label-type 'goto-target)
1475 (c-put-font-lock-face (caar c-record-ref-identifiers)
1476 (cdar c-record-ref-identifiers)
1477 c-label-face-name))
1478 ((eq label-type 'qt-1kwd-colon)
1479 (c-put-font-lock-face (caar c-record-ref-identifiers)
1480 (cdar c-record-ref-identifiers)
1481 'font-lock-keyword-face))
1482 ((eq label-type 'qt-2kwds-colon)
1483 (mapc
1484 (lambda (kwd)
1485 (c-put-font-lock-face (car kwd) (cdr kwd)
1486 'font-lock-keyword-face))
1487 c-record-ref-identifiers)))
1488 (setq c-record-ref-identifiers nil)
1489 ;; `c-forward-label' has probably added a `c-decl-end'
1490 ;; marker, so return t to `c-find-decl-spots' to signal
1491 ;; that.
1492 t))))
1494 nil)))
1496 (defun c-font-lock-enum-tail (limit)
1497 ;; Fontify an enum's identifiers when POINT is within the enum's brace
1498 ;; block.
1500 ;; This function will be called from font-lock for a region bounded by POINT
1501 ;; and LIMIT, as though it were to identify a keyword for
1502 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1503 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1504 ;; Fontification".
1506 ;; Note that this function won't attempt to fontify beyond the end of the
1507 ;; current enum block, if any.
1508 (let* ((paren-state (c-parse-state))
1509 (encl-pos (c-most-enclosing-brace paren-state)))
1510 (when (and
1511 encl-pos
1512 (eq (char-after encl-pos) ?\{)
1513 (save-excursion
1514 (goto-char encl-pos)
1515 (c-backward-over-enum-header)))
1516 (c-syntactic-skip-backward "^{," nil t)
1517 (c-put-char-property (1- (point)) 'c-type 'c-decl-id-start)
1519 (c-forward-syntactic-ws)
1520 (c-font-lock-declarators limit t nil t)))
1521 nil)
1523 (defun c-font-lock-cut-off-declarators (limit)
1524 ;; Fontify any declarators "cut off" from their declaring type at the start
1525 ;; of the region being fontified.
1527 ;; This function will be called from font-lock- for a region bounded by
1528 ;; POINT and LIMIT, as though it were to identify a keyword for
1529 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1530 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1531 ;; fontification".
1532 (let ((decl-search-lim (c-determine-limit 1000))
1533 paren-state bod-res is-typedef encl-pos
1534 (here (point))
1535 c-recognize-knr-p) ; Strictly speaking, bogus, but it
1536 ; speeds up lisp.h tremendously.
1537 (save-excursion
1538 (when (not (c-back-over-member-initializers))
1539 (unless (or (eobp)
1540 (looking-at "\\s(\\|\\s)"))
1541 (forward-char))
1542 (c-syntactic-skip-backward "^;{}" decl-search-lim t)
1543 (when (eq (char-before) ?})
1544 (c-go-list-backward) ; brace block of struct, etc.?
1545 (c-syntactic-skip-backward "^;{}" decl-search-lim t))
1546 (when (or (bobp)
1547 (memq (char-before) '(?\; ?{ ?})))
1548 (c-forward-syntactic-ws)
1549 ;; We're now putatively at the declaration.
1550 (setq paren-state (c-parse-state))
1551 ;; At top level or inside a "{"?
1552 (if (or (not (setq encl-pos
1553 (c-most-enclosing-brace paren-state)))
1554 (eq (char-after encl-pos) ?\{))
1555 (progn
1556 (when (looking-at c-typedef-key) ; "typedef"
1557 (setq is-typedef t)
1558 (goto-char (match-end 0))
1559 (c-forward-syntactic-ws))
1560 ;; At a real declaration?
1561 (if (memq (c-forward-type t) '(t known found decltype))
1562 (c-font-lock-declarators
1563 limit t is-typedef (not (c-bs-at-toplevel-p here)))))))))
1564 nil))
1566 (defun c-font-lock-enclosing-decls (limit)
1567 ;; Fontify the declarators of (nested) declarations we're in the middle of.
1568 ;; This is mainly for when a jit-lock etc. chunk starts inside the brace
1569 ;; block of a struct/union/class, etc.
1571 ;; This function will be called from font-lock for a region bounded by POINT
1572 ;; and LIMIT, as though it were to identify a keyword for
1573 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1574 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1575 ;; Fontification".
1576 (let* ((paren-state (c-parse-state))
1577 (decl-search-lim (c-determine-limit 1000))
1578 in-typedef ps-elt)
1579 ;; Are we in any nested struct/union/class/etc. braces?
1580 (while paren-state
1581 (setq ps-elt (car paren-state)
1582 paren-state (cdr paren-state))
1583 (when (and (atom ps-elt)
1584 (eq (char-after ps-elt) ?\{))
1585 (goto-char ps-elt)
1586 (c-syntactic-skip-backward "^;{}" decl-search-lim)
1587 (when (or (bobp)
1588 (memq (char-before) '(?\; ?})))
1589 (c-forward-syntactic-ws)
1590 (setq in-typedef (looking-at c-typedef-key))
1591 (if in-typedef (c-forward-token-2))
1592 (when (and c-opt-block-decls-with-vars-key
1593 (looking-at c-opt-block-decls-with-vars-key))
1594 (goto-char ps-elt)
1595 (when (c-safe (c-forward-sexp))
1596 (c-forward-syntactic-ws)
1597 (c-font-lock-declarators limit t in-typedef
1598 (not (c-bs-at-toplevel-p (point)))))))))))
1600 (defun c-font-lock-raw-strings (limit)
1601 ;; Fontify C++ raw strings.
1603 ;; This function will be called from font-lock for a region bounded by POINT
1604 ;; and LIMIT, as though it were to identify a keyword for
1605 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1606 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1607 ;; Fontification".
1608 (let* ((state (c-state-semi-pp-to-literal (point)))
1609 (string-start (and (eq (cadr state) 'string)
1610 (car (cddr state))))
1611 (raw-id (and string-start
1612 (save-excursion
1613 (goto-char string-start)
1614 (and (eq (char-before) ?R)
1615 (looking-at "\"\\([^ ()\\\n\r\t]\\{0,16\\}\\)(")
1616 (match-string-no-properties 1))))))
1617 (while (< (point) limit)
1618 (if raw-id
1619 (progn
1620 (if (search-forward-regexp (concat ")\\(" (regexp-quote raw-id) "\\)\"")
1621 limit 'limit)
1622 (c-put-font-lock-face (match-beginning 1) (point) 'default))
1623 (setq raw-id nil))
1625 (when (search-forward-regexp
1626 "R\\(\"\\)\\([^ ()\\\n\r\t]\\{0,16\\}\\)(" limit 'limit)
1627 (when
1628 (or (and (eobp)
1629 (eq (c-get-char-property (1- (point)) 'face)
1630 'font-lock-warning-face))
1631 (eq (c-get-char-property (point) 'face) 'font-lock-string-face)
1632 (and (equal (c-get-char-property (match-end 2) 'syntax-table) '(1))
1633 (equal (c-get-char-property (match-beginning 1) 'syntax-table)
1634 '(1))))
1635 (let ((paren-prop (c-get-char-property (1- (point)) 'syntax-table)))
1636 (if paren-prop
1637 (progn
1638 (c-put-font-lock-face (match-beginning 0) (match-end 0)
1639 'font-lock-warning-face)
1640 (when
1641 (and
1642 (equal paren-prop '(15))
1643 (not (c-search-forward-char-property 'syntax-table '(15) limit)))
1644 (goto-char limit)))
1645 (c-put-font-lock-face (match-beginning 1) (match-end 2) 'default)
1646 (setq raw-id (match-string-no-properties 2)))))))))
1647 nil)
1649 (defun c-font-lock-c++-lambda-captures (limit)
1650 ;; Fontify the lambda capture component of C++ lambda declarations.
1652 ;; This function will be called from font-lock for a region bounded by POINT
1653 ;; and LIMIT, as though it were to identify a keyword for
1654 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1655 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1656 ;; Fontification".
1657 (let (mode capture-default id-start id-end declaration sub-begin sub-end)
1658 (while (and (< (point) limit)
1659 (search-forward "[" limit t))
1660 (when (progn (backward-char)
1661 (prog1
1662 (c-looking-at-c++-lambda-capture-list)
1663 (forward-char)))
1664 (c-forward-syntactic-ws)
1665 (setq mode (and (memq (char-after) '(?= ?&))
1666 (char-after)))
1667 ;; Is the first element of the list a bare "=" or "&"?
1668 (when mode
1669 (forward-char)
1670 (c-forward-syntactic-ws)
1671 (if (memq (char-after) '(?, ?\]))
1672 (progn
1673 (setq capture-default mode)
1674 (when (eq (char-after) ?,)
1675 (forward-char)
1676 (c-forward-syntactic-ws)))
1677 (c-backward-token-2)))
1679 ;; Go round the following loop once per captured item. We use "\\s)"
1680 ;; rather than "\\]" here to avoid infinite looping in this situation:
1681 ;; "unsigned items [] { [ }". The second "[" triggers this function,
1682 ;; but if we don't match the "}" with an "\\s)", the
1683 ;; `c-syntactic-re-search-forward' at the end of the loop fails to
1684 ;; move forward over it, leaving point stuck at the "}".
1685 (while (and (not (looking-at "\\s)"))
1686 (< (point) limit))
1687 (if (eq (char-after) ?&)
1688 (progn (setq mode ?&)
1689 (forward-char)
1690 (c-forward-syntactic-ws))
1691 (setq mode ?=))
1692 (if (c-on-identifier)
1693 (progn
1694 (setq id-start (point))
1695 (forward-char)
1696 (c-end-of-current-token)
1697 (setq id-end (point))
1698 (c-forward-syntactic-ws)
1700 (setq declaration (eq (char-after) ?=))
1701 (when declaration
1702 (forward-char) ; over "="
1703 (c-forward-syntactic-ws)
1704 (setq sub-begin (point)))
1705 (if (or (and (< (point) limit)
1706 (c-syntactic-re-search-forward "," limit t t))
1707 (and (c-go-up-list-forward nil limit)
1708 (eq (char-before) ?\])))
1709 (backward-char)
1710 (goto-char limit))
1711 (when declaration
1712 (save-excursion
1713 (setq sub-end (point))
1714 (goto-char sub-begin)
1715 (c-font-lock-c++-lambda-captures sub-end)))
1717 (c-put-font-lock-face id-start id-end
1718 (cond
1719 (declaration
1720 'font-lock-variable-name-face)
1721 ((and capture-default
1722 (eq mode capture-default))
1723 'font-lock-warning-face)
1724 ((eq mode ?=) font-lock-constant-face)
1725 (t 'font-lock-variable-name-face))))
1726 (c-syntactic-re-search-forward "," limit 'bound t))
1728 (c-forward-syntactic-ws)
1729 (when (eq (char-after) ?,)
1730 (forward-char)
1731 (c-forward-syntactic-ws)))
1733 (setq capture-default nil)
1734 (if (< (point) limit)
1735 (forward-char))))) ; over the terminating "]" or other close paren.
1736 nil)
1739 (c-lang-defconst c-simple-decl-matchers
1740 "Simple font lock matchers for types and declarations. These are used
1741 on level 2 only and so aren't combined with `c-complex-decl-matchers'."
1743 t `(;; Objective-C methods.
1744 ,@(when (c-major-mode-is 'objc-mode)
1745 `((,(c-lang-const c-opt-method-key)
1746 (,(byte-compile
1747 (lambda (limit)
1748 (let (;; The font-lock package in Emacs is known to clobber
1749 ;; `parse-sexp-lookup-properties' (when it exists).
1750 (parse-sexp-lookup-properties
1751 (cc-eval-when-compile
1752 (boundp 'parse-sexp-lookup-properties))))
1753 (save-restriction
1754 (narrow-to-region (point-min) limit)
1755 (c-font-lock-objc-method)))
1756 nil))
1757 (goto-char (match-end 1))))))
1759 ;; Fontify all type names and the identifiers in the
1760 ;; declarations they might start. Use eval here since
1761 ;; `c-known-type-key' gets its value from
1762 ;; `*-font-lock-extra-types' on mode init.
1763 (eval . (list ,(c-make-font-lock-search-function
1764 'c-known-type-key
1765 '(1 'font-lock-type-face t)
1766 '((c-font-lock-declarators limit t nil nil)
1767 (save-match-data
1768 (goto-char (match-end 1))
1769 (c-forward-syntactic-ws))
1770 (goto-char (match-end 1))))))
1772 ;; Fontify types preceded by `c-type-prefix-kwds' and the
1773 ;; identifiers in the declarations they might start.
1774 ,@(when (c-lang-const c-type-prefix-kwds)
1775 (let* ((prefix-re (c-make-keywords-re nil
1776 (c-lang-const c-type-prefix-kwds)))
1777 (type-match (+ 2
1778 (regexp-opt-depth prefix-re)
1779 (c-lang-const c-simple-ws-depth))))
1780 `((,(c-make-font-lock-search-function
1781 (concat "\\<\\(" prefix-re "\\)" ; 1
1782 (c-lang-const c-simple-ws) "+"
1783 (concat "\\(" ; 2 + prefix-re + c-simple-ws
1784 (c-lang-const c-symbol-key)
1785 "\\)"))
1786 `(,type-match
1787 'font-lock-type-face t)
1788 `((c-font-lock-declarators limit t nil nil)
1789 (save-match-data
1790 (goto-char (match-end ,type-match))
1791 (c-forward-syntactic-ws))
1792 (goto-char (match-end ,type-match))))))))
1794 ;; Fontify special declarations that lacks a type.
1795 ,@(when (c-lang-const c-typeless-decl-kwds)
1796 `((,(c-make-font-lock-search-function
1797 (concat "\\<\\("
1798 (regexp-opt (c-lang-const c-typeless-decl-kwds))
1799 "\\)\\>")
1800 '((c-font-lock-declarators limit t nil nil)
1801 (save-match-data
1802 (goto-char (match-end 1))
1803 (c-forward-syntactic-ws))
1804 (goto-char (match-end 1)))))))
1806 ;; Fontify generic colon labels in languages that support them.
1807 ,@(when (c-lang-const c-recognize-colon-labels)
1808 `(c-font-lock-labels))))
1810 (c-lang-defconst c-complex-decl-matchers
1811 "Complex font lock matchers for types and declarations. Used on level
1812 3 and higher."
1814 ;; Note: This code in this form dumps a number of functions into the
1815 ;; resulting constant, `c-matchers-3'. At run time, font lock will call
1816 ;; each of them as a "FUNCTION" (see Elisp page "Search-based
1817 ;; Fontification"). The font lock region is delimited by POINT and the
1818 ;; single parameter, LIMIT. Each of these functions returns NIL (thus
1819 ;; inhibiting spurious font-lock-keyword-face highlighting and another
1820 ;; call).
1822 t `(;; Initialize some things before the search functions below.
1823 c-font-lock-complex-decl-prepare
1825 ,@(if (c-major-mode-is 'objc-mode)
1826 ;; Fontify method declarations in Objective-C, but first
1827 ;; we have to put the `c-decl-end' `c-type' property on
1828 ;; all the @-style directives that haven't been handled in
1829 ;; `c-basic-matchers-before'.
1830 `(,(c-make-font-lock-search-function
1831 (c-make-keywords-re t
1832 ;; Exclude "@class" since that directive ends with a
1833 ;; semicolon anyway.
1834 (delete "@class"
1835 (append (c-lang-const c-protection-kwds)
1836 (c-lang-const c-other-decl-kwds)
1837 nil)))
1838 '((c-put-char-property (1- (match-end 1))
1839 'c-type 'c-decl-end)))
1840 c-font-lock-objc-methods))
1842 ;; Fontify declarators which have been cut off from their declaring
1843 ;; types at the start of the region.
1844 c-font-lock-cut-off-declarators
1846 ;; Fontify all declarations, casts and normal labels.
1847 c-font-lock-declarations
1849 ;; Fontify declarators when POINT is within their declaration.
1850 c-font-lock-enclosing-decls
1852 ;; Fontify angle bracket arglists like templates in C++.
1853 ,@(when (c-lang-const c-recognize-<>-arglists)
1854 `(c-font-lock-<>-arglists))
1856 ,@(when (c-major-mode-is 'c++-mode)
1857 `(c-font-lock-c++-lambda-captures))
1859 ;; The first two rules here mostly find occurrences that
1860 ;; `c-font-lock-declarations' has found already, but not
1861 ;; declarations containing blocks in the type (see note below).
1862 ;; It's also useful to fontify these everywhere to show e.g. when
1863 ;; a type keyword is accidentally used as an identifier.
1865 ;; Fontify basic types.
1866 ,(let ((re (c-make-keywords-re nil
1867 (c-lang-const c-primitive-type-kwds))))
1868 (if (c-major-mode-is 'pike-mode)
1869 ;; No symbol is a keyword after "->" in Pike.
1870 `(,(concat "\\(\\=.?\\|[^>]\\|[^-]>\\)"
1871 "\\<\\(" re "\\)\\>")
1872 2 font-lock-type-face)
1873 `(,(concat "\\<\\(" re "\\)\\>")
1874 1 'font-lock-type-face)))
1876 ;; Fontify types preceded by `c-type-prefix-kwds' (e.g. "struct").
1877 ,@(when (c-lang-const c-type-prefix-kwds)
1878 `((,(byte-compile
1879 `(lambda (limit)
1880 (c-fontify-types-and-refs
1881 ((c-promote-possible-types t)
1882 ;; The font-lock package in Emacs is known to clobber
1883 ;; `parse-sexp-lookup-properties' (when it exists).
1884 (parse-sexp-lookup-properties
1885 (cc-eval-when-compile
1886 (boundp 'parse-sexp-lookup-properties))))
1887 (save-restriction
1888 ;; Narrow to avoid going past the limit in
1889 ;; `c-forward-type'.
1890 (narrow-to-region (point) limit)
1891 (while (re-search-forward
1892 ,(concat "\\<\\("
1893 (c-make-keywords-re nil
1894 (c-lang-const c-type-prefix-kwds))
1895 "\\)\\>")
1896 limit t)
1897 (unless (c-skip-comments-and-strings limit)
1898 (c-forward-syntactic-ws)
1899 ;; Handle prefix declaration specifiers.
1900 (while
1902 (when (or (looking-at c-prefix-spec-kwds-re)
1903 (and (c-major-mode-is 'java-mode)
1904 (looking-at "@[A-Za-z0-9]+")))
1905 (c-forward-keyword-clause 1)
1907 (when (and c-opt-cpp-prefix
1908 (looking-at
1909 c-noise-macro-with-parens-name-re))
1910 (c-forward-noise-clause)
1911 t)))
1912 ,(if (c-major-mode-is 'c++-mode)
1913 `(when (and (c-forward-type)
1914 (eq (char-after) ?=))
1915 ;; In C++ we additionally check for a "class
1916 ;; X = Y" construct which is used in
1917 ;; templates, to fontify Y as a type.
1918 (forward-char)
1919 (c-forward-syntactic-ws)
1920 (c-forward-type))
1921 `(c-forward-type))
1922 )))))))))
1924 ;; Fontify symbols after closing braces as declaration
1925 ;; identifiers under the assumption that they are part of
1926 ;; declarations like "class Foo { ... } foo;". It's too
1927 ;; expensive to check this accurately by skipping past the
1928 ;; brace block, so we use the heuristic that it's such a
1929 ;; declaration if the first identifier is on the same line as
1930 ;; the closing brace. `c-font-lock-declarations' will later
1931 ;; override it if it turns out to be an new declaration, but
1932 ;; it will be wrong if it's an expression (see the test
1933 ;; decls-8.cc).
1934 ;; ,@(when (c-lang-const c-opt-block-decls-with-vars-key)
1935 ;; `((,(c-make-font-lock-search-function
1936 ;; (concat "}"
1937 ;; (c-lang-const c-single-line-syntactic-ws)
1938 ;; "\\(" ; 1 + c-single-line-syntactic-ws-depth
1939 ;; (c-lang-const c-type-decl-prefix-key)
1940 ;; "\\|"
1941 ;; (c-lang-const c-symbol-key)
1942 ;; "\\)")
1943 ;; `((c-font-lock-declarators limit t nil) ; That nil says use `font-lock-variable-name-face';
1944 ;; ; t would mean `font-lock-function-name-face'.
1945 ;; (progn
1946 ;; (c-put-char-property (match-beginning 0) 'c-type
1947 ;; 'c-decl-id-start)
1948 ;; ; 'c-decl-type-start)
1949 ;; (goto-char (match-beginning
1950 ;; ,(1+ (c-lang-const
1951 ;; c-single-line-syntactic-ws-depth)))))
1952 ;; (goto-char (match-end 0)))))))
1954 ;; Fontify the type in C++ "new" expressions.
1955 ,@(when (c-major-mode-is 'c++-mode)
1956 ;; This pattern is a probably a "(MATCHER . ANCHORED-HIGHLIGHTER)"
1957 ;; (see Elisp page "Search-based Fontification").
1958 `(("\\<new\\>"
1959 (c-font-lock-c++-new))))
1962 (defun c-font-lock-labels (limit)
1963 ;; Fontify all statement labels from the point to LIMIT. Assumes
1964 ;; that strings and comments have been fontified already. Nil is
1965 ;; always returned.
1967 ;; Note: This function is only used on decoration level 2; this is
1968 ;; taken care of directly by the gargantuan
1969 ;; `c-font-lock-declarations' on higher levels.
1971 ;; This function might do hidden buffer changes.
1973 (let (continue-pos id-start
1974 ;; The font-lock package in Emacs is known to clobber
1975 ;; `parse-sexp-lookup-properties' (when it exists).
1976 (parse-sexp-lookup-properties
1977 (cc-eval-when-compile
1978 (boundp 'parse-sexp-lookup-properties))))
1980 (while (re-search-forward ":[^:]" limit t)
1981 (setq continue-pos (point))
1982 (goto-char (match-beginning 0))
1983 (unless (c-skip-comments-and-strings limit)
1985 (c-backward-syntactic-ws)
1986 (and (setq id-start (c-on-identifier))
1988 (not (get-text-property id-start 'face))
1990 (progn
1991 (goto-char id-start)
1992 (c-backward-syntactic-ws)
1994 ;; Check for a char that precedes a statement.
1995 (memq (char-before) '(?\} ?\{ ?\;))
1996 ;; Check for a preceding label. We exploit the font
1997 ;; locking made earlier by this function.
1998 (and (eq (char-before) ?:)
1999 (progn
2000 (backward-char)
2001 (c-backward-syntactic-ws)
2002 (not (bobp)))
2003 (eq (get-text-property (1- (point)) 'face)
2004 c-label-face-name))
2005 ;; Check for a keyword that precedes a statement.
2006 (c-after-conditional)))
2008 (progn
2009 ;; Got a label.
2010 (goto-char id-start)
2011 (looking-at c-symbol-key)
2012 (c-put-font-lock-face (match-beginning 0) (match-end 0)
2013 c-label-face-name)))
2015 (goto-char continue-pos))))
2016 nil)
2018 (c-lang-defconst c-basic-matchers-after
2019 "Font lock matchers for various things that should be fontified after
2020 generic casts and declarations are fontified. Used on level 2 and
2021 higher."
2023 t `(,@(when (c-lang-const c-brace-id-list-kwds)
2024 ;; Fontify the remaining identifiers inside an enum list when we start
2025 ;; inside it.
2026 `(c-font-lock-enum-tail
2027 ;; Fontify the identifiers inside enum lists. (The enum type
2028 ;; name is handled by `c-simple-decl-matchers' or
2029 ;; `c-complex-decl-matchers' below.
2030 (,(c-make-font-lock-search-function
2031 (concat
2032 "\\<\\("
2033 (c-make-keywords-re nil (c-lang-const c-brace-id-list-kwds))
2034 "\\)\\>"
2035 ;; Disallow various common punctuation chars that can't come
2036 ;; before the '{' of the enum list, to avoid searching too far.
2037 "[^][{};/#=]*"
2038 "{")
2039 '((c-font-lock-declarators limit t nil t)
2040 (save-match-data
2041 (goto-char (match-end 0))
2042 (c-put-char-property (1- (point)) 'c-type
2043 'c-decl-id-start)
2044 (c-forward-syntactic-ws))
2045 (goto-char (match-end 0)))))))
2047 ;; Fontify labels after goto etc.
2048 ,@(when (c-lang-const c-before-label-kwds)
2049 `(;; (Got three different interpretation levels here,
2050 ;; which makes it a bit complicated: 1) The backquote
2051 ;; stuff is expanded when compiled or loaded, 2) the
2052 ;; eval form is evaluated at font-lock setup (to
2053 ;; substitute c-label-face-name correctly), and 3) the
2054 ;; resulting structure is interpreted during
2055 ;; fontification.)
2056 (eval
2057 . ,(let* ((c-before-label-re
2058 (c-make-keywords-re nil
2059 (c-lang-const c-before-label-kwds))))
2060 `(list
2061 ,(concat "\\<\\(" c-before-label-re "\\)\\>"
2062 "\\s *"
2063 "\\(" ; identifier-offset
2064 (c-lang-const c-symbol-key)
2065 "\\)")
2066 (list ,(+ (regexp-opt-depth c-before-label-re) 2)
2067 c-label-face-name nil t))))))
2069 ;; Fontify the clauses after various keywords.
2070 ,@(when (or (c-lang-const c-type-list-kwds)
2071 (c-lang-const c-ref-list-kwds)
2072 (c-lang-const c-colon-type-list-kwds))
2073 `((,(c-make-font-lock-BO-decl-search-function
2074 (concat "\\<\\("
2075 (c-make-keywords-re nil
2076 (append (c-lang-const c-type-list-kwds)
2077 (c-lang-const c-ref-list-kwds)
2078 (c-lang-const c-colon-type-list-kwds)))
2079 "\\)\\>")
2080 '((c-fontify-types-and-refs ((c-promote-possible-types t))
2081 (c-forward-keyword-clause 1)
2082 (if (> (point) limit) (goto-char limit))))))))
2084 ,@(when (c-lang-const c-paren-type-kwds)
2085 `((,(c-make-font-lock-search-function
2086 (concat "\\<\\("
2087 (c-make-keywords-re nil
2088 (c-lang-const c-paren-type-kwds))
2089 "\\)\\>")
2090 '((c-fontify-types-and-refs ((c-promote-possible-types t))
2091 (c-forward-keyword-clause 1)
2092 (if (> (point) limit) (goto-char limit))))))))
2094 ,@(when (c-major-mode-is 'java-mode)
2095 `((eval . (list "\\<\\(@[a-zA-Z0-9]+\\)\\>" 1 c-annotation-face))))
2098 (c-lang-defconst c-matchers-1
2099 t (c-lang-const c-cpp-matchers))
2101 (c-lang-defconst c-matchers-2
2102 t (append (c-lang-const c-matchers-1)
2103 (c-lang-const c-basic-matchers-before)
2104 (c-lang-const c-simple-decl-matchers)
2105 (c-lang-const c-basic-matchers-after)))
2107 (c-lang-defconst c-matchers-3
2108 t (append (c-lang-const c-matchers-1)
2109 (c-lang-const c-basic-matchers-before)
2110 (c-lang-const c-complex-decl-matchers)
2111 (c-lang-const c-basic-matchers-after)))
2113 (defun c-compose-keywords-list (base-list)
2114 ;; Incorporate the font lock keyword lists according to
2115 ;; `c-doc-comment-style' on the given keyword list and return it.
2116 ;; This is used in the function bindings of the
2117 ;; `*-font-lock-keywords-*' symbols since we have to build the list
2118 ;; when font-lock is initialized.
2120 (unless (memq c-doc-face-name c-literal-faces)
2121 (setq c-literal-faces (cons c-doc-face-name c-literal-faces)))
2123 (let* ((doc-keywords
2124 (if (consp (car-safe c-doc-comment-style))
2125 (cdr-safe (or (assq c-buffer-is-cc-mode c-doc-comment-style)
2126 (assq 'other c-doc-comment-style)))
2127 c-doc-comment-style))
2128 (list (nconc (c--mapcan
2129 (lambda (doc-style)
2130 (let ((sym (intern
2131 (concat (symbol-name doc-style)
2132 "-font-lock-keywords"))))
2133 (cond ((fboundp sym)
2134 (funcall sym))
2135 ((boundp sym)
2136 (append (eval sym) nil)))))
2137 (if (listp doc-keywords)
2138 doc-keywords
2139 (list doc-keywords)))
2140 base-list)))
2142 ;; Kludge: If `c-font-lock-complex-decl-prepare' is on the list we
2143 ;; move it first since the doc comment font lockers might add
2144 ;; `c-type' text properties, so they have to be cleared before that.
2145 (when (memq 'c-font-lock-complex-decl-prepare list)
2146 (setq list (cons 'c-font-lock-complex-decl-prepare
2147 (delq 'c-font-lock-complex-decl-prepare
2148 (append list nil)))))
2150 list))
2152 (defun c-override-default-keywords (def-var)
2153 ;; This is used to override the value on a `*-font-lock-keywords'
2154 ;; variable only if it's nil or has the same value as one of the
2155 ;; `*-font-lock-keywords-*' variables. Older font-lock packages
2156 ;; define a default value for `*-font-lock-keywords' which we want
2157 ;; to override, but we should otoh avoid clobbering a user setting.
2158 ;; This heuristic for that isn't perfect, but I can't think of any
2159 ;; better. /mast
2160 (when (and (boundp def-var)
2161 (memq (symbol-value def-var)
2162 (cons nil
2163 (mapcar
2164 (lambda (suffix)
2165 (let ((sym (intern (concat (symbol-name def-var)
2166 suffix))))
2167 (and (boundp sym) (symbol-value sym))))
2168 '("-1" "-2" "-3")))))
2169 ;; The overriding is done by unbinding the variable so that the normal
2170 ;; defvar will install its default value later on.
2171 (makunbound def-var)))
2174 ;;; C.
2176 (c-override-default-keywords 'c-font-lock-keywords)
2178 (defconst c-font-lock-keywords-1 (c-lang-const c-matchers-1 c)
2179 "Minimal font locking for C mode.
2180 Fontifies only preprocessor directives (in addition to the syntactic
2181 fontification of strings and comments).")
2183 (defconst c-font-lock-keywords-2 (c-lang-const c-matchers-2 c)
2184 "Fast normal font locking for C mode.
2185 In addition to `c-font-lock-keywords-1', this adds fontification of
2186 keywords, simple types, declarations that are easy to recognize, the
2187 user defined types on `c-font-lock-extra-types', and the doc comment
2188 styles specified by `c-doc-comment-style'.")
2190 (defconst c-font-lock-keywords-3 (c-lang-const c-matchers-3 c)
2191 "Accurate normal font locking for C mode.
2192 Like the variable `c-font-lock-keywords-2' but detects declarations in a more
2193 accurate way that works in most cases for arbitrary types without the
2194 need for `c-font-lock-extra-types'.")
2196 (defvar c-font-lock-keywords c-font-lock-keywords-3
2197 "Default expressions to highlight in C mode.")
2199 (defun c-font-lock-keywords-2 ()
2200 (c-compose-keywords-list c-font-lock-keywords-2))
2201 (defun c-font-lock-keywords-3 ()
2202 (c-compose-keywords-list c-font-lock-keywords-3))
2203 (defun c-font-lock-keywords ()
2204 (c-compose-keywords-list c-font-lock-keywords))
2207 ;;; C++.
2209 (defun c-font-lock-c++-new (limit)
2210 ;; FIXME!!! Put in a comment about the context of this function's
2211 ;; invocation. I think it's called as an ANCHORED-MATCHER within an
2212 ;; ANCHORED-HIGHLIGHTER. (2007/2/10).
2214 ;; Assuming point is after a "new" word, check that it isn't inside
2215 ;; a string or comment, and if so try to fontify the type in the
2216 ;; allocation expression. Nil is always returned.
2218 ;; As usual, C++ takes the prize in coming up with a hard to parse
2219 ;; syntax. :P
2221 ;; This function might do hidden buffer changes.
2223 (unless (c-skip-comments-and-strings limit)
2224 (save-excursion
2225 (catch 'false-alarm
2226 ;; A "new" keyword is followed by one to three expressions, where
2227 ;; the type is the middle one, and the only required part.
2228 (let (expr1-pos expr2-pos
2229 ;; Enable recording of identifier ranges in `c-forward-type'
2230 ;; etc for later fontification. Not using
2231 ;; `c-fontify-types-and-refs' here since the ranges should
2232 ;; be fontified selectively only when an allocation
2233 ;; expression is successfully recognized.
2234 (c-record-type-identifiers t)
2235 c-record-ref-identifiers
2236 ;; The font-lock package in Emacs is known to clobber
2237 ;; `parse-sexp-lookup-properties' (when it exists).
2238 (parse-sexp-lookup-properties
2239 (cc-eval-when-compile
2240 (boundp 'parse-sexp-lookup-properties))))
2241 (c-forward-syntactic-ws)
2243 ;; The first placement arglist is always parenthesized, if it
2244 ;; exists.
2245 (when (eq (char-after) ?\()
2246 (setq expr1-pos (1+ (point)))
2247 (condition-case nil
2248 (c-forward-sexp)
2249 (scan-error (throw 'false-alarm t)))
2250 (c-forward-syntactic-ws))
2252 ;; The second expression is either a type followed by some "*" or
2253 ;; "[...]" or similar, or a parenthesized type followed by a full
2254 ;; identifierless declarator.
2255 (setq expr2-pos (1+ (point)))
2256 (cond ((eq (char-after) ?\())
2257 ((let ((c-promote-possible-types t))
2258 (c-forward-type)))
2259 (t (setq expr2-pos nil)))
2261 (when expr1-pos
2262 (cond
2263 ((not expr2-pos)
2264 ;; No second expression, so the first has to be a
2265 ;; parenthesized type.
2266 (goto-char expr1-pos)
2267 (let ((c-promote-possible-types t))
2268 (c-forward-type)))
2270 ((eq (char-before expr2-pos) ?\()
2271 ;; Got two parenthesized expressions, so we have to look
2272 ;; closer at them to decide which is the type. No need to
2273 ;; handle `c-record-ref-identifiers' since all references
2274 ;; have already been handled by other fontification rules.
2275 (let (expr1-res expr2-res)
2277 (goto-char expr1-pos)
2278 (when (setq expr1-res (c-forward-type))
2279 (unless (looking-at
2280 (cc-eval-when-compile
2281 (concat (c-lang-const c-symbol-start c++)
2282 "\\|[*:)[]")))
2283 ;; There's something after the would-be type that
2284 ;; can't be there, so this is a placement arglist.
2285 (setq expr1-res nil)))
2287 (goto-char expr2-pos)
2288 (when (setq expr2-res (c-forward-type))
2289 (unless (looking-at
2290 (cc-eval-when-compile
2291 (concat (c-lang-const c-symbol-start c++)
2292 "\\|[*:)[]")))
2293 ;; There's something after the would-be type that can't
2294 ;; be there, so this is an initialization expression.
2295 (setq expr2-res nil))
2296 (when (and (c-go-up-list-forward)
2297 (progn (c-forward-syntactic-ws)
2298 (eq (char-after) ?\()))
2299 ;; If there's a third initialization expression
2300 ;; then the second one is the type, so demote the
2301 ;; first match.
2302 (setq expr1-res nil)))
2304 ;; We fontify the most likely type, with a preference for
2305 ;; the first argument since a placement arglist is more
2306 ;; unusual than an initializer.
2307 (cond ((memq expr1-res '(t known prefix)))
2308 ((memq expr2-res '(t known prefix)))
2309 ;; Presumably 'decltype's will be fontified elsewhere.
2310 ((eq expr1-res 'decltype))
2311 ((eq expr2-res 'decltype))
2312 ((eq expr1-res 'found)
2313 (let ((c-promote-possible-types t))
2314 (goto-char expr1-pos)
2315 (c-forward-type)))
2316 ((eq expr2-res 'found)
2317 (let ((c-promote-possible-types t))
2318 (goto-char expr2-pos)
2319 (c-forward-type)))
2320 ((and (eq expr1-res 'maybe) (not expr2-res))
2321 (let ((c-promote-possible-types t))
2322 (goto-char expr1-pos)
2323 (c-forward-type)))
2324 ((and (not expr1-res) (eq expr2-res 'maybe))
2325 (let ((c-promote-possible-types t))
2326 (goto-char expr2-pos)
2327 (c-forward-type)))
2328 ;; If both type matches are 'maybe then we're
2329 ;; too uncertain to promote either of them.
2330 )))))
2332 ;; Fontify the type that now is recorded in
2333 ;; `c-record-type-identifiers', if any.
2334 (c-fontify-recorded-types-and-refs)))))
2335 nil)
2337 (c-override-default-keywords 'c++-font-lock-keywords)
2339 (defconst c++-font-lock-keywords-1 (c-lang-const c-matchers-1 c++)
2340 "Minimal font locking for C++ mode.
2341 Fontifies only preprocessor directives (in addition to the syntactic
2342 fontification of strings and comments).")
2344 (defconst c++-font-lock-keywords-2 (c-lang-const c-matchers-2 c++)
2345 "Fast normal font locking for C++ mode.
2346 In addition to `c++-font-lock-keywords-1', this adds fontification of
2347 keywords, simple types, declarations that are easy to recognize, the
2348 user defined types on `c++-font-lock-extra-types', and the doc comment
2349 styles specified by `c-doc-comment-style'.")
2351 (defconst c++-font-lock-keywords-3 (c-lang-const c-matchers-3 c++)
2352 "Accurate normal font locking for C++ mode.
2353 Like the variable `c++-font-lock-keywords-2' but detects declarations in a more
2354 accurate way that works in most cases for arbitrary types without the
2355 need for `c++-font-lock-extra-types'.")
2357 (defvar c++-font-lock-keywords c++-font-lock-keywords-3
2358 "Default expressions to highlight in C++ mode.")
2360 (defun c++-font-lock-keywords-2 ()
2361 (c-compose-keywords-list c++-font-lock-keywords-2))
2362 (defun c++-font-lock-keywords-3 ()
2363 (c-compose-keywords-list c++-font-lock-keywords-3))
2364 (defun c++-font-lock-keywords ()
2365 (c-compose-keywords-list c++-font-lock-keywords))
2368 ;;; Objective-C.
2370 (defun c-font-lock-objc-method ()
2371 ;; Assuming the point is after the + or - that starts an Objective-C
2372 ;; method declaration, fontify it. This must be done before normal
2373 ;; casts, declarations and labels are fontified since they will get
2374 ;; false matches in these things.
2376 ;; This function might do hidden buffer changes.
2378 (c-fontify-types-and-refs
2379 ((first t)
2380 (c-promote-possible-types t))
2382 (while (and
2383 (progn
2384 (c-forward-syntactic-ws)
2386 ;; An optional method type.
2387 (if (eq (char-after) ?\()
2388 (progn
2389 (forward-char)
2390 (c-forward-syntactic-ws)
2391 (c-forward-type)
2392 (prog1 (c-go-up-list-forward)
2393 (c-forward-syntactic-ws)))
2396 ;; The name. The first time it's the first part of
2397 ;; the function name, the rest of the time it's an
2398 ;; argument name.
2399 (looking-at c-symbol-key)
2400 (progn
2401 (goto-char (match-end 0))
2402 (c-put-font-lock-face (match-beginning 0)
2403 (point)
2404 (if first
2405 'font-lock-function-name-face
2406 'font-lock-variable-name-face))
2407 (c-forward-syntactic-ws)
2409 ;; Another optional part of the function name.
2410 (when (looking-at c-symbol-key)
2411 (goto-char (match-end 0))
2412 (c-put-font-lock-face (match-beginning 0)
2413 (point)
2414 'font-lock-function-name-face)
2415 (c-forward-syntactic-ws))
2417 ;; There's another argument if a colon follows.
2418 (eq (char-after) ?:)))
2419 (forward-char)
2420 (setq first nil))))
2422 (defun c-font-lock-objc-methods (limit)
2423 ;; Fontify method declarations in Objective-C. Nil is always
2424 ;; returned.
2426 ;; This function might do hidden buffer changes.
2428 (let (;; The font-lock package in Emacs is known to clobber
2429 ;; `parse-sexp-lookup-properties' (when it exists).
2430 (parse-sexp-lookup-properties
2431 (cc-eval-when-compile
2432 (boundp 'parse-sexp-lookup-properties))))
2434 (c-find-decl-spots
2435 limit
2436 "[-+]"
2438 (lambda (match-pos inside-macro &optional top-level)
2439 (forward-char)
2440 (c-font-lock-objc-method))))
2441 nil)
2443 (c-override-default-keywords 'objc-font-lock-keywords)
2445 (defconst objc-font-lock-keywords-1 (c-lang-const c-matchers-1 objc)
2446 "Minimal font locking for Objective-C mode.
2447 Fontifies only compiler directives (in addition to the syntactic
2448 fontification of strings and comments).")
2450 (defconst objc-font-lock-keywords-2 (c-lang-const c-matchers-2 objc)
2451 "Fast normal font locking for Objective-C mode.
2452 In addition to `objc-font-lock-keywords-1', this adds fontification of
2453 keywords, simple types, declarations that are easy to recognize, the
2454 user defined types on `objc-font-lock-extra-types', and the doc
2455 comment styles specified by `c-doc-comment-style'.")
2457 (defconst objc-font-lock-keywords-3 (c-lang-const c-matchers-3 objc)
2458 "Accurate normal font locking for Objective-C mode.
2459 Like the variable `objc-font-lock-keywords-2' but detects declarations in a more
2460 accurate way that works in most cases for arbitrary types without the
2461 need for `objc-font-lock-extra-types'.")
2463 (defvar objc-font-lock-keywords objc-font-lock-keywords-3
2464 "Default expressions to highlight in Objective-C mode.")
2466 (defun objc-font-lock-keywords-2 ()
2467 (c-compose-keywords-list objc-font-lock-keywords-2))
2468 (defun objc-font-lock-keywords-3 ()
2469 (c-compose-keywords-list objc-font-lock-keywords-3))
2470 (defun objc-font-lock-keywords ()
2471 (c-compose-keywords-list objc-font-lock-keywords))
2473 ;; Kludge to override the default value that
2474 ;; `objc-font-lock-extra-types' might have gotten from the font-lock
2475 ;; package. The value replaced here isn't relevant now anyway since
2476 ;; those types are builtin and therefore listed directly in
2477 ;; `c-primitive-type-kwds'.
2478 (when (equal (sort (append objc-font-lock-extra-types nil) 'string-lessp)
2479 '("BOOL" "Class" "IMP" "SEL"))
2480 (setq objc-font-lock-extra-types
2481 (cc-eval-when-compile (list (concat "[" c-upper "]\\sw*")))))
2484 ;;; Java.
2486 (c-override-default-keywords 'java-font-lock-keywords)
2488 (defconst java-font-lock-keywords-1 (c-lang-const c-matchers-1 java)
2489 "Minimal font locking for Java mode.
2490 Fontifies nothing except the syntactic fontification of strings and
2491 comments.")
2493 (defconst java-font-lock-keywords-2 (c-lang-const c-matchers-2 java)
2494 "Fast normal font locking for Java mode.
2495 In addition to `java-font-lock-keywords-1', this adds fontification of
2496 keywords, simple types, declarations that are easy to recognize, the
2497 user defined types on `java-font-lock-extra-types', and the doc
2498 comment styles specified by `c-doc-comment-style'.")
2500 (defconst java-font-lock-keywords-3 (c-lang-const c-matchers-3 java)
2501 "Accurate normal font locking for Java mode.
2502 Like variable `java-font-lock-keywords-2' but detects declarations in a more
2503 accurate way that works in most cases for arbitrary types without the
2504 need for `java-font-lock-extra-types'.")
2506 (defvar java-font-lock-keywords java-font-lock-keywords-3
2507 "Default expressions to highlight in Java mode.")
2509 (defun java-font-lock-keywords-2 ()
2510 (c-compose-keywords-list java-font-lock-keywords-2))
2511 (defun java-font-lock-keywords-3 ()
2512 (c-compose-keywords-list java-font-lock-keywords-3))
2513 (defun java-font-lock-keywords ()
2514 (c-compose-keywords-list java-font-lock-keywords))
2517 ;;; CORBA IDL.
2519 (c-override-default-keywords 'idl-font-lock-keywords)
2521 (defconst idl-font-lock-keywords-1 (c-lang-const c-matchers-1 idl)
2522 "Minimal font locking for CORBA IDL mode.
2523 Fontifies nothing except the syntactic fontification of strings and
2524 comments.")
2526 (defconst idl-font-lock-keywords-2 (c-lang-const c-matchers-2 idl)
2527 "Fast normal font locking for CORBA IDL mode.
2528 In addition to `idl-font-lock-keywords-1', this adds fontification of
2529 keywords, simple types, declarations that are easy to recognize, the
2530 user defined types on `idl-font-lock-extra-types', and the doc comment
2531 styles specified by `c-doc-comment-style'.")
2533 (defconst idl-font-lock-keywords-3 (c-lang-const c-matchers-3 idl)
2534 "Accurate normal font locking for CORBA IDL mode.
2535 Like the variable `idl-font-lock-keywords-2' but detects declarations in a more
2536 accurate way that works in most cases for arbitrary types without the
2537 need for `idl-font-lock-extra-types'.")
2539 (defvar idl-font-lock-keywords idl-font-lock-keywords-3
2540 "Default expressions to highlight in CORBA IDL mode.")
2542 (defun idl-font-lock-keywords-2 ()
2543 (c-compose-keywords-list idl-font-lock-keywords-2))
2544 (defun idl-font-lock-keywords-3 ()
2545 (c-compose-keywords-list idl-font-lock-keywords-3))
2546 (defun idl-font-lock-keywords ()
2547 (c-compose-keywords-list idl-font-lock-keywords))
2550 ;;; Pike.
2552 (c-override-default-keywords 'pike-font-lock-keywords)
2554 (defconst pike-font-lock-keywords-1 (c-lang-const c-matchers-1 pike)
2555 "Minimal font locking for Pike mode.
2556 Fontifies only preprocessor directives (in addition to the syntactic
2557 fontification of strings and comments).")
2559 (defconst pike-font-lock-keywords-2 (c-lang-const c-matchers-2 pike)
2560 "Fast normal font locking for Pike mode.
2561 In addition to `pike-font-lock-keywords-1', this adds fontification of
2562 keywords, simple types, declarations that are easy to recognize, the
2563 user defined types on `pike-font-lock-extra-types', and the doc
2564 comment styles specified by `c-doc-comment-style'.")
2566 (defconst pike-font-lock-keywords-3 (c-lang-const c-matchers-3 pike)
2567 "Accurate normal font locking for Pike mode.
2568 Like the variable `pike-font-lock-keywords-2' but detects declarations in a more
2569 accurate way that works in most cases for arbitrary types without the
2570 need for `pike-font-lock-extra-types'.")
2572 (defvar pike-font-lock-keywords pike-font-lock-keywords-3
2573 "Default expressions to highlight in Pike mode.")
2575 (defun pike-font-lock-keywords-2 ()
2576 (c-compose-keywords-list pike-font-lock-keywords-2))
2577 (defun pike-font-lock-keywords-3 ()
2578 (c-compose-keywords-list pike-font-lock-keywords-3))
2579 (defun pike-font-lock-keywords ()
2580 (c-compose-keywords-list pike-font-lock-keywords))
2583 ;;; Doc comments.
2585 (defun c-font-lock-doc-comments (prefix limit keywords)
2586 ;; Fontify the comments between the point and LIMIT whose start
2587 ;; matches PREFIX with `c-doc-face-name'. Assumes comments have been
2588 ;; fontified with `font-lock-comment-face' already. nil is always
2589 ;; returned.
2591 ;; After the fontification of a matching comment, fontification
2592 ;; according to KEYWORDS is applied inside it. It's a list like
2593 ;; `font-lock-keywords' except that anchored matches and eval
2594 ;; clauses aren't supported and that some abbreviated forms can't be
2595 ;; used. The buffer is narrowed to the comment while KEYWORDS is
2596 ;; applied; leading comment starters are included but trailing
2597 ;; comment enders for block comment are not.
2599 ;; Note that faces added through KEYWORDS should never replace the
2600 ;; existing `c-doc-face-name' face since the existence of that face
2601 ;; is used as a flag in other code to skip comments.
2603 ;; This function might do hidden buffer changes.
2605 (let (comment-beg region-beg)
2606 (if (eq (get-text-property (point) 'face)
2607 'font-lock-comment-face)
2608 ;; Handle the case when the fontified region starts inside a
2609 ;; comment.
2610 (let ((start (c-literal-start)))
2611 (setq region-beg (point))
2612 (when start
2613 (goto-char start))
2614 (when (looking-at prefix)
2615 (setq comment-beg (point)))))
2617 (while (or
2618 comment-beg
2620 ;; Search for the prefix until a match is found at the start
2621 ;; of a comment.
2622 (while (when (re-search-forward prefix limit t)
2623 (setq comment-beg (match-beginning 0))
2624 (or (not (c-got-face-at comment-beg
2625 c-literal-faces))
2626 (and (/= comment-beg (point-min))
2627 (c-got-face-at (1- comment-beg)
2628 c-literal-faces))))
2629 (setq comment-beg nil))
2630 (setq region-beg comment-beg))
2632 (if (elt (parse-partial-sexp comment-beg (+ comment-beg 2)) 7)
2633 ;; Collect a sequence of doc style line comments.
2634 (progn
2635 (goto-char comment-beg)
2636 (while (and (progn
2637 (c-forward-single-comment)
2638 (skip-syntax-forward " ")
2639 (< (point) limit))
2640 (looking-at prefix))))
2641 (goto-char comment-beg)
2642 (c-forward-single-comment))
2643 (if (> (point) limit) (goto-char limit))
2644 (setq comment-beg nil)
2646 (let ((region-end (point))
2647 (keylist keywords) keyword matcher highlights)
2648 (c-put-font-lock-face region-beg region-end c-doc-face-name)
2649 (save-restriction
2650 ;; Narrow to the doc comment. Among other things, this
2651 ;; helps by making "^" match at the start of the comment.
2652 ;; Do not include a trailing block comment ender, though.
2653 (and (> region-end (1+ region-beg))
2654 (progn (goto-char region-end)
2655 (backward-char 2)
2656 (looking-at "\\*/"))
2657 (setq region-end (point)))
2658 (narrow-to-region region-beg region-end)
2660 (while keylist
2661 (setq keyword (car keylist)
2662 keylist (cdr keylist)
2663 matcher (car keyword))
2664 (goto-char region-beg)
2665 (while (if (stringp matcher)
2666 (re-search-forward matcher region-end t)
2667 (funcall matcher region-end))
2668 (setq highlights (cdr keyword))
2669 (if (consp (car highlights))
2670 (while highlights
2671 (font-lock-apply-highlight (car highlights))
2672 (setq highlights (cdr highlights)))
2673 (font-lock-apply-highlight highlights))))
2675 (goto-char region-end)))))
2676 nil)
2677 (put 'c-font-lock-doc-comments 'lisp-indent-function 2)
2679 (defun c-find-invalid-doc-markup (regexp limit)
2680 ;; Used to fontify invalid markup in doc comments after the correct
2681 ;; ones have been fontified: Find the first occurrence of REGEXP
2682 ;; between the point and LIMIT that only is fontified with
2683 ;; `c-doc-face-name'. If a match is found then submatch 0 surrounds
2684 ;; the first char and t is returned, otherwise nil is returned.
2686 ;; This function might do hidden buffer changes.
2687 (let (start)
2688 (while (if (re-search-forward regexp limit t)
2689 (not (eq (get-text-property
2690 (setq start (match-beginning 0)) 'face)
2691 c-doc-face-name))
2692 (setq start nil)))
2693 (when start
2694 (store-match-data (list (copy-marker start)
2695 (copy-marker (1+ start))))
2696 t)))
2698 ;; GtkDoc patterns contributed by Masatake YAMATO <jet@gyve.org>.
2700 (defconst gtkdoc-font-lock-doc-comments
2701 (let ((symbol "[a-zA-Z0-9_]+")
2702 (header "^ \\* "))
2703 `((,(concat header "\\(" symbol "\\):[ \t]*$")
2704 1 ,c-doc-markup-face-name prepend nil)
2705 (,(concat symbol "()")
2706 0 ,c-doc-markup-face-name prepend nil)
2707 (,(concat header "\\(" "@" symbol "\\):")
2708 1 ,c-doc-markup-face-name prepend nil)
2709 (,(concat "[#%@]" symbol)
2710 0 ,c-doc-markup-face-name prepend nil))
2713 (defconst gtkdoc-font-lock-doc-protection
2714 `(("< \\(public\\|private\\|protected\\) >"
2715 1 ,c-doc-markup-face-name prepend nil)))
2717 (defconst gtkdoc-font-lock-keywords
2718 `((,(lambda (limit)
2719 (c-font-lock-doc-comments "/\\*\\*$" limit
2720 gtkdoc-font-lock-doc-comments)
2721 (c-font-lock-doc-comments "/\\*< " limit
2722 gtkdoc-font-lock-doc-protection)
2723 ))))
2725 ;; Javadoc.
2727 (defconst javadoc-font-lock-doc-comments
2728 `(("{@[a-z]+[^}\n\r]*}" ; "{@foo ...}" markup.
2729 0 ,c-doc-markup-face-name prepend nil)
2730 ("^\\(/\\*\\)?\\(\\s \\|\\*\\)*\\(@[a-z]+\\)" ; "@foo ..." markup.
2731 3 ,c-doc-markup-face-name prepend nil)
2732 (,(concat "</?\\sw" ; HTML tags.
2733 "\\("
2734 (concat "\\sw\\|\\s \\|[=\n\r*.:]\\|"
2735 "\"[^\"]*\"\\|'[^']*'")
2736 "\\)*>")
2737 0 ,c-doc-markup-face-name prepend nil)
2738 ("&\\(\\sw\\|[.:]\\)+;" ; HTML entities.
2739 0 ,c-doc-markup-face-name prepend nil)
2740 ;; Fontify remaining markup characters as invalid. Note
2741 ;; that the Javadoc spec is hazy about when "@" is
2742 ;; allowed in non-markup use.
2743 (,(lambda (limit)
2744 (c-find-invalid-doc-markup "[<>&]\\|{@" limit))
2745 0 'font-lock-warning-face prepend nil)))
2747 (defconst javadoc-font-lock-keywords
2748 `((,(lambda (limit)
2749 (c-font-lock-doc-comments "/\\*\\*" limit
2750 javadoc-font-lock-doc-comments)))))
2752 ;; Pike autodoc.
2754 (defconst autodoc-decl-keywords
2755 ;; Adorned regexp matching the keywords that introduce declarations
2756 ;; in Pike Autodoc.
2757 (cc-eval-when-compile
2758 (c-make-keywords-re t '("@decl" "@elem" "@index" "@member") 'pike-mode)))
2760 (defconst autodoc-decl-type-keywords
2761 ;; Adorned regexp matching the keywords that are followed by a type.
2762 (cc-eval-when-compile
2763 (c-make-keywords-re t '("@elem" "@member") 'pike-mode)))
2765 (defun autodoc-font-lock-line-markup (limit)
2766 ;; Fontify all line oriented keywords between the point and LIMIT.
2767 ;; Nil is always returned.
2769 ;; This function might do hidden buffer changes.
2771 (let ((line-re (concat "^\\(\\(/\\*!\\|\\s *\\("
2772 c-current-comment-prefix
2773 "\\)\\)\\s *\\)@[A-Za-z_-]+\\(\\s \\|$\\)"))
2774 (markup-faces (list c-doc-markup-face-name c-doc-face-name)))
2776 (while (re-search-forward line-re limit t)
2777 (goto-char (match-end 1))
2779 (if (looking-at autodoc-decl-keywords)
2780 (let* ((kwd-pos (point))
2781 (start (match-end 1))
2782 (pos start)
2783 end)
2785 (c-put-font-lock-face (point) pos markup-faces)
2787 ;; Put a declaration end mark at the markup keyword and
2788 ;; remove the faces from the rest of the line so that it
2789 ;; gets refontified as a declaration later on by
2790 ;; `c-font-lock-declarations'.
2791 (c-put-char-property (1- pos) 'c-type 'c-decl-end)
2792 (goto-char pos)
2793 (while (progn
2794 (end-of-line)
2795 (setq end (point))
2796 (and (eq (char-before) ?@)
2797 (not (eobp))
2798 (progn (forward-char)
2799 (skip-syntax-forward " ")
2800 (looking-at c-current-comment-prefix))))
2801 (goto-char (match-end 0))
2802 (c-remove-font-lock-face pos (1- end))
2803 (c-put-font-lock-face (1- end) end markup-faces)
2804 (setq pos (point)))
2806 ;; Include the final newline in the removed area. This
2807 ;; has no visual effect but it avoids some tricky special
2808 ;; cases in the testsuite wrt the differences in string
2809 ;; fontification in Emacs vs XEmacs.
2810 (c-remove-font-lock-face pos (min (1+ (point)) (point-max)))
2812 ;; Must handle string literals explicitly inside the declaration.
2813 (goto-char start)
2814 (while (re-search-forward
2815 "\"\\([^\\\"]\\|\\\\.\\)*\"\\|'\\([^\\']\\|\\\\.\\)*'"
2816 end 'move)
2817 (c-put-font-lock-string-face (match-beginning 0)
2818 (point)))
2820 ;; Fontify types after keywords that always are followed
2821 ;; by them.
2822 (goto-char kwd-pos)
2823 (when (looking-at autodoc-decl-type-keywords)
2824 (c-fontify-types-and-refs ((c-promote-possible-types t))
2825 (goto-char start)
2826 (c-forward-syntactic-ws)
2827 (c-forward-type))))
2829 ;; Mark each whole line as markup, as long as the logical line
2830 ;; continues.
2831 (while (progn
2832 (c-put-font-lock-face (point)
2833 (progn (end-of-line) (point))
2834 markup-faces)
2835 (and (eq (char-before) ?@)
2836 (not (eobp))
2837 (progn (forward-char)
2838 (skip-syntax-forward " ")
2839 (looking-at c-current-comment-prefix))))
2840 (goto-char (match-end 0))))))
2842 nil)
2844 (defconst autodoc-font-lock-doc-comments
2845 `(("@\\(\\w+{\\|\\[\\([^]@\n\r]\\|@@\\)*\\]\\|[@}]\\|$\\)"
2846 ;; In-text markup.
2847 0 ,c-doc-markup-face-name prepend nil)
2848 (autodoc-font-lock-line-markup)
2849 ;; Fontify remaining markup characters as invalid.
2850 (,(lambda (limit)
2851 (c-find-invalid-doc-markup "@" limit))
2852 0 'font-lock-warning-face prepend nil)
2855 (defun autodoc-font-lock-keywords ()
2856 ;; Note that we depend on that `c-current-comment-prefix' has got
2857 ;; its proper value here.
2859 ;; This function might do hidden buffer changes.
2861 ;; The `c-type' text property with `c-decl-end' is used to mark the
2862 ;; end of the `autodoc-decl-keywords' occurrences to fontify the
2863 ;; following declarations.
2864 (setq c-type-decl-end-used t)
2866 `((,(lambda (limit)
2867 (c-font-lock-doc-comments "/[*/]!" limit
2868 autodoc-font-lock-doc-comments)))))
2871 ;; 2006-07-10: awk-font-lock-keywords has been moved back to cc-awk.el.
2872 (cc-provide 'cc-fonts)
2874 ;; Local Variables:
2875 ;; indent-tabs-mode: t
2876 ;; tab-width: 8
2877 ;; End:
2878 ;;; cc-fonts.el ends here