| blob | 2d116e1ecdcc8052c1ecb188d1de24faf2539c37 |
1 ;;; cc-fonts.el --- font lock support for CC Mode
3 ;; Copyright (C) 2002-2012 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:
30 ;;
31 ;; o `c-label-face-name' is either `font-lock-constant-face' (in
32 ;; Emacs), or `font-lock-reference-face'.
33 ;;
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'.
37 ;;
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.
41 ;;
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).
47 ;;
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):
57 ;;
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.
72 load-path)))
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.
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.
103 \f
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.
110 ;; XEmacs has a font-lock-preprocessor-face.
113 ;; In Emacs font-lock-builtin-face has traditionally been
114 ;; used for preprocessor directives.
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.)
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.
139 ;; This doesn't exist in some earlier versions of XEmacs 21.
140 'font-lock-constant-face
141 c-label-face-name))
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.
157 ;; XEmacs.
160 ;; Emacs 21 and later.
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))
175 ;; Emacs 22 has a special face for negation chars.
182 ;; Emacs and XEmacs have completely different face manipulation
183 ;; routines. :P
186 ;; Emacs. This only looks at the inverse flag in the current
187 ;; frame. Other display configurations might be different,
188 ;; but it can only show if the same Emacs has frames on
189 ;; e.g. a color and a monochrome display simultaneously.
193 ;; XEmacs. Same pitfall here.
201 "Face for highlighting annotations in Java mode and similar modes."
206 ;; We need the following definitions during compilation since they're
207 ;; used when the `c-lang-defconst' initializers are evaluated. Define
208 ;; them at runtime too for the sake of derived modes.
210 ;; This indicates the "font locking context", and is set just before
211 ;; fontification is done. If non-nil, it says, e.g., point starts
212 ;; from within a #if preprocessor construct.
217 ;; Put a face on a region (overriding any existing face) in the way
218 ;; font-lock would do it. In XEmacs that means putting an
219 ;; additional font-lock property, or else the font-lock package
220 ;; won't recognize it as fontified and might override it
221 ;; incorrectly.
222 ;;
223 ;; This function does a hidden buffer change.
225 ;; Note: This function has no docstring in XEmacs so it might be
226 ;; considered internal.
231 ;; This is the inverse of `c-put-font-lock-face'.
232 ;;
233 ;; This function does a hidden buffer change.
239 ;; Put `font-lock-string-face' on a string. The surrounding
240 ;; quotes are included in Emacs but not in XEmacs. The passed
241 ;; region should include them.
242 ;;
243 ;; This function does a hidden buffer change.
249 ;; Like `let', but additionally activates `c-record-type-identifiers'
250 ;; and `c-record-ref-identifiers', and fontifies the recorded ranges
251 ;; accordingly on exit.
252 ;;
253 ;; This function does hidden buffer changes.
255 c-record-ref-identifiers
262 ;; If the point is within a region fontified as a comment or
263 ;; string literal skip to the end of it or to LIMIT, whichever
264 ;; comes first, and return t. Otherwise return nil. The match
265 ;; data is not clobbered.
266 ;;
267 ;; This function might do hidden buffer changes.
274 t))
277 ;; Returns a byte compiled function suitable for use in place of a
278 ;; regexp string in a `font-lock-keywords' matcher, except that
279 ;; only matches outside comments and string literals count.
280 ;;
281 ;; This function does not do any hidden buffer changes, but the
282 ;; generated functions will. (They are however used in places
283 ;; covered by the font-lock context.)
293 nil)))))
294 res))))
297 ;; Return a lisp form which will fontify every occurrence of REGEXP
298 ;; (a regular expression, NOT a function) between POINT and `limit'
299 ;; with HIGHLIGHTS, a list of highlighters as specified on page
300 ;; "Search-based Fontification" in the elisp manual.
309 ;; e.g. highlight is (1 font-lock-type-face t)
313 "The override flag must currently be t in %s"
314 highlight))
317 "The laxmatch flag may currently not be set in %s"
318 highlight))
324 ;; highlight is an "ANCHORED HIGHLIGHTER" of the form
325 ;; (ANCHORED-MATCHER PRE-FORM POST-FORM SUBEXP-HIGHLIGHTERS...)
328 highlight))
333 highlights))))
336 ;; This function makes a byte compiled function that works much like
337 ;; a matcher element in `font-lock-keywords'. It cuts out a little
338 ;; bit of the overhead compared to a real matcher. The main reason
339 ;; is however to pass the real search limit to the anchored
340 ;; matcher(s), since most (if not all) font-lock implementations
341 ;; arbitrarily limit anchored matchers to the same line, and also
342 ;; to insulate against various other irritating differences between
343 ;; the different (X)Emacs font-lock packages.
344 ;;
345 ;; REGEXP is the matcher, which must be a regexp. Only matches
346 ;; where the beginning is outside any comment or string literal are
347 ;; significant.
348 ;;
349 ;; HIGHLIGHTS is a list of highlight specs, just like in
350 ;; `font-lock-keywords', with these limitations: The face is always
351 ;; overridden (no big disadvantage, since hits in comments etc are
352 ;; filtered anyway), there is no "laxmatch", and an anchored matcher
353 ;; is always a form which must do all the fontification directly.
354 ;; `limit' is a variable bound to the real limit in the context of
355 ;; the anchored matcher forms.
356 ;;
357 ;; This function does not do any hidden buffer changes, but the
358 ;; generated functions will. (They are however used in places
359 ;; covered by the font-lock context.)
361 ;; Note: Replace `byte-compile' with `eval' to debug the generated
362 ;; lambda more easily.
366 ;; `parse-sexp-lookup-properties' (when it exists).
371 ;; (while (re-search-forward ,regexp limit t)
372 ;; (unless (progn
373 ;; (goto-char (match-beginning 0))
374 ;; (c-skip-comments-and-strings limit))
375 ;; (goto-char (match-end 0))
376 ;; ,@(mapcar
377 ;; (lambda (highlight)
378 ;; (if (integerp (car highlight))
379 ;; (progn
380 ;; (unless (eq (nth 2 highlight) t)
381 ;; (error
382 ;; "The override flag must currently be t in %s"
383 ;; highlight))
384 ;; (when (nth 3 highlight)
385 ;; (error
386 ;; "The laxmatch flag may currently not be set in %s"
387 ;; highlight))
388 ;; `(save-match-data
389 ;; (c-put-font-lock-face
390 ;; (match-beginning ,(car highlight))
391 ;; (match-end ,(car highlight))
392 ;; ,(elt highlight 1))))
393 ;; (when (nth 3 highlight)
394 ;; (error "Match highlights currently not supported in %s"
395 ;; highlight))
396 ;; `(progn
397 ;; ,(nth 1 highlight)
398 ;; (save-match-data ,(car highlight))
399 ;; ,(nth 2 highlight))))
400 ;; highlights)))
403 nil)))
406 ;; This function makes a byte compiled function that first moves back
407 ;; to the beginning of the current declaration (if any), then searches
408 ;; forward for matcher elements (as in `font-lock-keywords') and
409 ;; fontifies them.
410 ;;
411 ;; The motivation for moving back to the declaration start is to
412 ;; establish a context for the current text when, e.g., a character
413 ;; is typed on a C++ inheritance continuation line, or a jit-lock
414 ;; chunk starts there.
415 ;;
416 ;; The new function works much like a matcher element in
417 ;; `font-lock-keywords'. It cuts out a little bit of the overhead
418 ;; compared to a real matcher. The main reason is however to pass the
419 ;; real search limit to the anchored matcher(s), since most (if not
420 ;; all) font-lock implementations arbitrarily limit anchored matchers
421 ;; to the same line, and also to insulate against various other
422 ;; irritating differences between the different (X)Emacs font-lock
423 ;; packages.
424 ;;
425 ;; REGEXP is the matcher, which must be a regexp. Only matches
426 ;; where the beginning is outside any comment or string literal are
427 ;; significant.
428 ;;
429 ;; HIGHLIGHTS is a list of highlight specs, just like in
430 ;; `font-lock-keywords', with these limitations: The face is always
431 ;; overridden (no big disadvantage, since hits in comments etc are
432 ;; filtered anyway), there is no "laxmatch", and an anchored matcher
433 ;; is always a form which must do all the fontification directly.
434 ;; `limit' is a variable bound to the real limit in the context of
435 ;; the anchored matcher forms.
436 ;;
437 ;; This function does not do any hidden buffer changes, but the
438 ;; generated functions will. (They are however used in places
439 ;; covered by the font-lock context.)
441 ;; Note: Replace `byte-compile' with `eval' to debug the generated
442 ;; lambda more easily.
446 ;; `parse-sexp-lookup-properties' (when it exists).
456 here)))
458 nil)))
461 ;; This function makes a byte compiled function that works much like
462 ;; a matcher element in `font-lock-keywords', with the following
463 ;; enhancement: the generated function will test for particular "font
464 ;; lock contexts" at the start of the region, i.e. is this point in
465 ;; the middle of some particular construct? if so the generated
466 ;; function will first fontify the tail of the construct, before
467 ;; going into the main loop and fontify full constructs up to limit.
468 ;;
469 ;; The generated function takes one parameter called `limit', and
470 ;; will fontify the region between POINT and LIMIT.
471 ;;
472 ;; NORMAL is a list of the form (REGEXP HIGHLIGHTS .....), and is
473 ;; used to fontify the "regular" bit of the region.
474 ;; STATE-STANZAS is list of elements of the form (STATE LIM REGEXP
475 ;; HIGHLIGHTS), each element coding one possible font lock context.
477 ;; o - REGEXP is a font-lock regular expression (NOT a function),
478 ;; o - HIGHLIGHTS is a list of zero or more highlighters as defined
479 ;; on page "Search-based Fontification" in the elisp manual. As
480 ;; yet (2009-06), they must have OVERRIDE set, and may not have
481 ;; LAXMATCH set.
482 ;;
483 ;; o - STATE is the "font lock context" (e.g. in-cpp-expr) and is
484 ;; not quoted.
485 ;; o - LIM is a lisp form whose evaluation will yield the limit
486 ;; position in the buffer for fontification by this stanza.
487 ;;
488 ;; This function does not do any hidden buffer changes, but the
489 ;; generated functions will. (They are however used in places
490 ;; covered by the font-lock context.)
491 ;;
492 ;; Note: Replace `byte-compile' with `eval' to debug the generated
493 ;; lambda more easily.
497 ;; `parse-sexp-lookup-properties' (when it exists).
510 regexp highlights)))))
511 state-stanzas)
513 nil))))
515 ; (eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
516 ; '(progn
519 ;; If there are literal quoted or backquoted highlight specs in
520 ;; the call to `c-make-font-lock-search-function' then let's
521 ;; instrument the forms in them.
526 ;; Convert the ranges recorded on `c-record-type-identifiers' and
527 ;; `c-record-ref-identifiers' to fontification.
528 ;;
529 ;; This function does hidden buffer changes.
539 ;; Note that the reference face is a variable that is
540 ;; dereferenced, since it's an alias in Emacs.
542 c-reference-face-name))))
545 "Font lock matchers for preprocessor directives and purely lexical
546 stuff. Used on level 1 and higher."
548 ;; Note: `c-font-lock-declarations' assumes that no matcher here
549 ;; sets `font-lock-type-face' in languages where
550 ;; `c-recognize-<>-arglists' is set.
559 ;; fontify it as a string.
566 re
570 ;; Fontify filenames in #include <...> as strings.
577 re
581 font-lock-string-face)
583 ;; Use an anchored matcher to put paren syntax
584 ;; on the brackets.
595 ;; (c-clear-char-property beg 'syntax-table)
597 nil)))))))
599 ;; #define.
603 noncontinued-line-end
610 ;; Macro with arguments - a "function".
613 ;; Macro without arguments - a "variable".
620 ;; "Function". Fontify the name and the arguments.
645 ;; "Variable".
651 ;; Fontify cpp function names in preprocessor
652 ;; expressions in #if and #elif.
663 ced-re ; 1 + ncle-depth
664 ;; Match the whole logical line to look
665 ;; for the functions in.
671 c-preprocessor-face-name)))
675 ,cef-re
678 ;; Fontify the directive names.
692 c-negation-char-face-name
694 )))
697 ;; Recognize hashbangs in Pike.
701 ;; Make hard spaces visible through an inverted `font-lock-warning-face'.
709 ))
712 ;; Assuming the point is after the opening character of a string,
713 ;; fontify that char with `font-lock-warning-face' if the string
714 ;; decidedly isn't terminated properly.
715 ;;
716 ;; This function does hidden buffer changes.
721 ;; There's no multiline string start char before the
722 ;; string, so newlines aren't allowed.
724 ;; Multiline strings are allowed anywhere if
725 ;; c-multiline-string-start-char is t.
728 ;; There's no \ before the newline.
730 ;; Escaped newlines aren't supported.
731 t)
735 "Font lock matchers for basic keywords, labels, references and various
736 other easily recognizable things that should be fontified before generic
737 casts and declarations are fontified. Used on level 2 and higher."
739 ;; Note: `c-font-lock-declarations' assumes that no matcher here
740 ;; sets `font-lock-type-face' in languages where
741 ;; `c-recognize-<>-arglists' is set.
744 ;; can't span lines. Later font
745 ;; lock packages have a `font-lock-syntactic-face-function' for
746 ;; this, but it doesn't give the control we want since any
747 ;; fontification done inside the function will be
748 ;; unconditionally overridden.
750 ;; Match a char before the string starter to make
751 ;; `c-skip-comments-and-strings' work correctly.
755 ;; Fontify keyword constants.
759 ;; No symbol is a keyword after "->" in Pike.
766 ;; Fontify all keywords except the primitive types.
768 ;; No symbol is a keyword after "->" in Pike.
775 ;; Fontify leading identifiers in fully qualified names like
776 ;; "foo::bar" in languages that supports such things.
779 ;; Java needs special treatment since "." is used both to
780 ;; qualify names and in normal indexing. Here we look for
781 ;; capital characters at the beginning of an identifier to
782 ;; recognize the class. "*" is also recognized to cover
783 ;; wildcard import declarations. All preceding dot separated
784 ;; identifiers are taken as package names and therefore
785 ;; fontified as references.
787 ;; Search for class identifiers preceded by ".". The
788 ;; anchored matcher takes it from there.
808 c-reference-face-name)
810 nil
814 ;; Must use a function here since we match longer than
815 ;; we want to move before doing a new search. This is
816 ;; not necessary for XEmacs since it restarts the
817 ;; search from the end of the first highlighted
818 ;; submatch (something that causes problems in other
819 ;; places).
831 limit t)
838 c-reference-face-name))
841 ;; Fontify the special declarations in Objective-C.
849 ;; In this case we accept both primitive and known types.
856 ;; The @interface/@implementation/@protocol directives.
861 t)
865 ;; `parse-sexp-lookup-properties' (when it exists).
870 nil)
874 ))
877 ;; This function will be called from font-lock for a region bounded by POINT
878 ;; and LIMIT, as though it were to identify a keyword for
879 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
880 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
881 ;; Fontification".
882 ;;
883 ;; Called before any of the matchers in `c-complex-decl-matchers'.
884 ;;
885 ;; This function does hidden buffer changes.
887 ;;(message "c-font-lock-complex-decl-prepare %s %s" (point) limit)
889 ;; Clear the list of found types if we start from the start of the
890 ;; buffer, to make it easier to get rid of misspelled types and
891 ;; variables that have gotten recognized as types in malformed code.
895 ;; Clear the c-type char properties which mark the region, to recalculate
896 ;; them properly. The most interesting properties are those put on the
897 ;; closest token before the region.
905 c-decl-end
906 c-decl-id-start
907 c-decl-type-start)))
909 pos)
912 ;; Update `c-state-cache' to the beginning of the region. This will
913 ;; make `c-beginning-of-syntax' go faster when it's used later on,
914 ;; and it's near the point most of the time.
917 ;; Check if the fontified region starts inside a declarator list so
918 ;; that `c-font-lock-declarators' should be called at the start.
919 ;; The declared identifiers are font-locked correctly as types, if
920 ;; that is what they are.
935 nil)
938 ;; This function will be called from font-lock for a region bounded by POINT
939 ;; and LIMIT, as though it were to identify a keyword for
940 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
941 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
942 ;; Fontification".
943 ;;
944 ;; Fontify types and references in names containing angle bracket
945 ;; arglists from the point to LIMIT. Note that
946 ;; `c-font-lock-declarations' already has handled many of them.
947 ;;
948 ;; This function might do hidden buffer changes.
951 ;; `parse-sexp-lookup-properties' (when it exists).
956 c-restricted-<>-arglists
957 id-start id-end id-face pos kwd-sym)
969 c-restricted-<>-arglists nil
974 ;; The identifier got the type face so it has already been
975 ;; handled in `c-font-lock-declarations'.
976 nil)
980 ;; There's a special keyword before the "<" that tells
981 ;; that it's an angle bracket arglist.
985 ;; There's a normal identifier before the "<". If we're not in
986 ;; a declaration context then we set `c-restricted-<>-arglists'
987 ;; to avoid recognizing templates in function calls like "foo (a
988 ;; < b, c > d)".
994 t))
998 ;; Check for comment/string both at the identifier and
999 ;; at the "<".
1010 c-reference-face-name)
1016 nil)
1019 ;; Assuming the point is at the start of a declarator in a declaration,
1020 ;; fontify the identifier it declares. (If TYPES is set, it does this via
1021 ;; the macro `c-fontify-types-and-refs'.)
1022 ;;
1023 ;; If LIST is non-nil, also fontify the ids in any following declarators in
1024 ;; a comma separated list (e.g. "foo" and "*bar" in "int foo = 17, *bar;");
1025 ;; additionally, mark the commas with c-type property 'c-decl-id-start or
1026 ;; 'c-decl-type-start (according to TYPES). Stop at LIMIT.
1027 ;;
1028 ;; If TYPES is non-nil, fontify all identifiers as types.
1029 ;;
1030 ;; Nil is always returned. The function leaves point at the delimiter after
1031 ;; the last declarator it processes.
1032 ;;
1033 ;; This function might do hidden buffer changes.
1035 ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
1038 paren-depth
1039 id-face got-init
1040 c-last-identifier-range
1043 ;; The following `while' fontifies a single declarator id each time round.
1044 ;; It loops only when LIST is non-nil.
1046 ;; Inside the following "condition form", we move forward over the
1047 ;; declarator's identifier up as far as any opening bracket (for array
1048 ;; size) or paren (for parameters of function-type) or brace (for
1049 ;; array/struct initialization) or "=" or terminating delimiter
1050 ;; (e.g. "," or ";" or "}").
1052 pos
1055 ;; The following form moves forward over the declarator's
1056 ;; identifier (and what precedes it), returning t. If there
1057 ;; wasn't one, it returns nil, terminating the `while'.
1060 ;; Skip over type decl prefix operators, one for each iteration
1061 ;; of the while. These are, e.g. "*" in "int *foo" or "(" and
1062 ;; "*" in "int (*foo) (void)" (Note similar code in
1063 ;; `c-forward-decl-or-cast-1'.)
1067 ;; If the third submatch matches in C++ then
1068 ;; we're looking at an identifier that's a
1069 ;; prefix only if it specifies a member pointer.
1074 ;; We only check for a trailing "::" and
1075 ;; let the "*" that should follow be
1076 ;; matched in the next round.
1077 t
1078 ;; It turned out to be the real identifier,
1079 ;; so flag that and stop.
1081 nil))
1082 t))
1090 ;; If we haven't passed the identifier already, do it now.
1098 ;; Skip out of the parens surrounding the identifier. If closing
1099 ;; parens are missing, this form returns nil.
1105 ;; Skip over any trailing bit, such as "__attribute__".
1111 ;; Search syntactically to the end of the declarator (";",
1112 ;; ",", a closing paren, eob etc) or to the beginning of an
1113 ;; initializer or function prototype ("=" or "\\s\(").
1114 ;; Note that the open paren will match array specs in
1115 ;; square brackets, and we treat them as initializers too.
1125 'font-lock-function-name-face
1131 ;; Register and fontify the identifier as a type.
1135 ;; Fontify the last symbol in the identifier if it isn't fontified
1136 ;; already. The check is necessary only in certain cases where this
1137 ;; function is used "sloppily", e.g. in `c-simple-decl-matchers'.
1143 id-face)))
1148 ;; Jump past any initializer or function prototype to see if
1149 ;; there's a ',' to continue at.
1152 ;; Skip a parenthesized initializer (C++) or a function
1153 ;; prototype.
1159 ;; Skip an initializer expression. If we're at a '='
1160 ;; then accept a brace list directly after it to cope
1161 ;; with array initializers. Otherwise stop at braces
1162 ;; to avoid going past full function and class blocks.
1167 t)
1168 ;; FIXME: Should look for c-decl-end markers here;
1169 ;; we might go far into the following declarations
1170 ;; in e.g. ObjC mode (see e.g. methods-4.m).
1176 ;; If a ',' is found we set pos to the next declarator and iterate.
1182 nil)
1185 ;; List of faces that might be put at the start of a type when
1186 ;; `c-font-lock-declarations' runs. This needs to be evaluated to
1187 ;; ensure that face name aliases in Emacs are resolved.
1189 font-lock-type-face
1190 c-reference-face-name
1191 font-lock-keyword-face))
1194 ;; Fontify all the declarations, casts and labels from the point to LIMIT.
1195 ;; Assumes that strings and comments have been fontified already.
1196 ;;
1197 ;; This function will be called from font-lock for a region bounded by POINT
1198 ;; and LIMIT, as though it were to identify a keyword for
1199 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1200 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1201 ;; Fontification".
1202 ;;
1203 ;; This function might do hidden buffer changes.
1205 ;;(message "c-font-lock-declarations search from %s to %s" (point) limit)
1209 start-pos
1210 ;; o - 'decl if we're in an arglist containing declarations
1211 ;; (but if `c-recognize-paren-inits' is set it might also be
1212 ;; an initializer arglist);
1213 ;; o - '<> if the arglist is of angle bracket type;
1214 ;; o - 'arglist if it's some other arglist;
1215 ;; o - nil, if not in an arglist at all. This includes the
1216 ;; parenthesized condition which follows "if", "while", etc.
1217 context
1218 ;; The position of the next token after the closing paren of
1219 ;; the last detected cast.
1220 last-cast-end
1221 ;; The result from `c-forward-decl-or-cast-1'.
1222 decl-or-cast
1223 ;; The maximum of the end positions of all the checked type
1224 ;; decl expressions in the successfully identified
1225 ;; declarations. The position might be either before or
1226 ;; after the syntactic whitespace following the last token
1227 ;; in the type decl expression.
1229 ;; Same as `max-type-decl-*', but used when we're before
1230 ;; `token-pos'.
1232 ;; Set according to the context to direct the heuristics for
1233 ;; recognizing C++ templates.
1234 c-restricted-<>-arglists
1235 ;; Turn on recording of identifier ranges in
1236 ;; `c-forward-decl-or-cast-1' and `c-forward-label' for
1237 ;; later fontification.
1239 label-type
1240 c-record-ref-identifiers
1241 ;; Make `c-forward-type' calls mark up template arglists if
1242 ;; it finds any. That's necessary so that we later will
1243 ;; stop inside them to fontify types there.
1245 lbrace ; position of some {.
1246 ;; The font-lock package in Emacs is known to clobber
1247 ;; `parse-sexp-lookup-properties' (when it exists).
1252 ;; Below we fontify a whole declaration even when it crosses the limit,
1253 ;; to avoid gaps when jit/lazy-lock fontifies the file a block at a
1254 ;; time. That is however annoying during editing, e.g. the following is
1255 ;; a common situation while the first line is being written:
1256 ;;
1257 ;; my_variable
1258 ;; some_other_variable = 0;
1259 ;;
1260 ;; font-lock will put the limit at the beginning of the second line
1261 ;; here, and if we go past it we'll fontify "my_variable" as a type and
1262 ;; "some_other_variable" as an identifier, and the latter will not
1263 ;; correct itself until the second line is changed. To avoid that we
1264 ;; narrow to the limit if the region to fontify is a single line.
1269 ;; Narrow after any operator chars following the limit though,
1270 ;; since those characters can be useful in recognizing a
1271 ;; declaration (in particular the '{' that opens a function body
1272 ;; after the header).
1278 limit
1279 c-decl-start-re
1280 c-font-lock-maybe-decl-faces
1285 ;; The result of the form below is true when we don't recognize a
1286 ;; declaration or cast.
1292 ;; Don't do anything more if we're looking at a keyword that
1293 ;; can't start a declaration.
1294 t
1296 ;; Set `context' and `c-restricted-<>-arglists'. Look for
1297 ;; "<" for the sake of C++-style template arglists.
1298 ;; Ignore "(" when it's part of a control flow construct
1299 ;; (e.g. "for (").
1305 ;; A control flow expression
1314 ;; Near BOB.
1318 ;; Got a cached hit in a declaration arglist.
1322 ;; Inside an angle bracket arglist.
1327 ;; Got a cached hit in some other type of arglist.
1334 ;; The point is within the range of a previously
1335 ;; encountered type decl expression, so the arglist
1336 ;; is probably one that contains declarations.
1337 ;; However, if `c-recognize-paren-inits' is set it
1338 ;; might also be an initializer arglist.
1341 ;; The result of this check is cached with a char
1342 ;; property on the match token, so that we can look
1343 ;; it up again when refontifying single lines in a
1344 ;; multiline declaration.
1350 ;; Check we haven't missed a preceding "typedef".
1357 ;; In QT, "more" is an irritating keyword that expands to nothing.
1358 ;; We skip over it to prevent recognition of "more slots: <symbol>"
1359 ;; as a bitfield declaration.
1366 ;; Now analyze the construct.
1368 match-pos context last-cast-end))
1372 ;; Save the position after the previous cast so we can feed
1373 ;; it to `c-forward-decl-or-cast-1' in the next round. That
1374 ;; helps it discover cast chains like "(a) (b) c".
1377 nil)
1380 ;; We've found a declaration.
1382 ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
1383 ;; under the assumption that we're after the first type decl
1384 ;; expression in the declaration now. That's not really true;
1385 ;; we could also be after a parenthesized initializer
1386 ;; expression in C++, but this is only used as a last resort
1387 ;; to slant ambiguous expression/declarations, and overall
1388 ;; it's worth the risk to occasionally fontify an expression
1389 ;; as a declaration in an initializer expression compared to
1390 ;; getting ambiguous things in normal function prototypes
1391 ;; fontified as expressions.
1398 ;; Back up to the type to fontify the declarator(s).
1403 ;; Should normally not fontify a list of
1404 ;; declarators inside an arglist, but the first
1405 ;; argument in the ';' separated list of a "for"
1406 ;; statement is an exception.
1413 t)))
1415 ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
1416 ;; before the first declarator if it's a list.
1417 ;; `c-font-lock-declarators' handles the rest.
1424 'c-decl-type-start
1430 ;; A declaration has been successfully identified, so do all the
1431 ;; fontification of types and refs that've been recorded.
1433 nil)
1435 ;; Restore point, since at this point in the code it has been
1436 ;; left undefined by c-forward-decl-or-cast-1 above.
1439 ;; If point is inside a bracelist, there's no point checking it
1440 ;; being at a declarator.
1443 ;; Move past this bracelist to prevent an endless loop.
1448 nil)
1450 ;; If point is just after a ")" which is followed by an
1451 ;; identifier which isn't a label, or at the matching "(", we're
1452 ;; at either a macro invocation, a cast, or a
1453 ;; for/while/etc. statement. The cast case is handled above.
1454 ;; None of these cases can contain a declarator.
1466 nil)
1469 ;; An optimization quickly to eliminate scans of long enum
1470 ;; declarations in the next cond arm.
1482 nil)
1485 ;; Are we at a declarator? Try to go back to the declaration
1486 ;; to check this. If we get there, check whether a "typedef"
1487 ;; is there, then fontify the declarators accordingly.
1489 paren-state bod-res encl-pos is-typedef
1491 ; speeds up lisp.h tremendously.
1500 ;; We're now putatively at the declaration.
1502 ;; At top level or inside a "{"?
1511 ;; At a real declaration?
1515 nil)
1516 ;; False alarm. Return t to go on to the next check.
1518 t))
1519 t))))))
1521 ;; It was a false alarm. Check if we're in a label (or other
1522 ;; construct with `:' except bitfield) instead.
1525 ;; Can't use `c-fontify-types-and-refs' here since we
1526 ;; use the label face at times.
1530 c-label-face-name))
1540 c-record-ref-identifiers)))
1542 ;; `c-forward-label' has probably added a `c-decl-end'
1543 ;; marker, so return t to `c-find-decl-spots' to signal
1544 ;; that.
1545 t))))
1547 nil)))
1550 ;; Fontify an enum's identifiers when POINT is within the enum's brace
1551 ;; block.
1552 ;;
1553 ;; This function will be called from font-lock for a region bounded by POINT
1554 ;; and LIMIT, as though it were to identify a keyword for
1555 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1556 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1557 ;; Fontification".
1558 ;;
1559 ;; Note that this function won't attempt to fontify beyond the end of the
1560 ;; current enum block, if any.
1564 )
1566 encl-pos
1581 nil)
1584 ;; Fontify the declarators of (nested) declarations we're in the middle of.
1585 ;; This is mainly for when a jit-lock etc. chunk starts inside the brace
1586 ;; block of a struct/union/class, etc.
1587 ;;
1588 ;; This function will be called from font-lock for a region bounded by POINT
1589 ;; and LIMIT, as though it were to identify a keyword for
1590 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1591 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1592 ;; Fontification".
1594 decl-context in-typedef ps-elt)
1595 ;; Are we in any nested struct/union/class/etc. braces?
1613 "Simple font lock matchers for types and declarations. These are used
1614 on level 2 only and so aren't combined with `c-complex-decl-matchers'."
1622 ;; `parse-sexp-lookup-properties' (when it exists).
1629 nil))
1632 ;; Fontify all type names and the identifiers in the
1633 ;; declarations they might start. Use eval here since
1634 ;; `c-known-type-key' gets its value from
1635 ;; `*-font-lock-extra-types' on mode init.
1637 'c-known-type-key
1645 ;; Fontify types preceded by `c-type-prefix-kwds' and the
1646 ;; identifiers in the declarations they might start.
1659 `(,type-match
1667 ;; Fontify special declarations that lacks a type.
1679 ;; Fontify generic colon labels in languages that support them.
1684 "Complex font lock matchers for types and declarations. Used on level
1685 3 and higher."
1687 ;; Note: This code in this form dumps a number of functions into the
1688 ;; resulting constant, `c-matchers-3'. At run time, font lock will call
1689 ;; each of them as a "FUNCTION" (see Elisp page "Search-based
1690 ;; Fontification"). The font lock region is delimited by POINT and the
1691 ;; single parameter, LIMIT. Each of these functions returns NIL (thus
1692 ;; inhibiting spurious font-lock-keyword-face highlighting and another
1693 ;; call).
1696 c-font-lock-complex-decl-prepare
1699 ;; Fontify method declarations in Objective-C, but first
1700 ;; we have to put the `c-decl-end' `c-type' property on
1701 ;; all the @-style directives that haven't been handled in
1702 ;; `c-basic-matchers-before'.
1705 ;; Exclude "@class" since that directive ends with a
1706 ;; semicolon anyway.
1710 nil)))
1713 c-font-lock-objc-methods))
1715 ;; Fontify all declarations, casts and normal labels.
1716 c-font-lock-declarations
1718 ;; Fontify declarators when POINT is within their declaration.
1719 c-font-lock-enclosing-decls
1721 ;; Fontify angle bracket arglists like templates in C++.
1725 ;; The first two rules here mostly find occurrences that
1726 ;; `c-font-lock-declarations' has found already, but not
1727 ;; declarations containing blocks in the type (see note below).
1728 ;; It's also useful to fontify these everywhere to show e.g. when
1729 ;; a type keyword is accidentally used as an identifier.
1731 ;; Fontify basic types.
1735 ;; No symbol is a keyword after "->" in Pike.
1742 ;; Fontify types preceded by `c-type-prefix-kwds' (e.g. "struct").
1748 ;; The font-lock package in Emacs is known to clobber
1749 ;; `parse-sexp-lookup-properties' (when it exists).
1754 ;; Narrow to avoid going past the limit in
1755 ;; `c-forward-type'.
1762 limit t)
1765 ;; Handle prefix declaration specifiers.
1773 ;; In C++ we additionally check for a "class
1774 ;; X = Y" construct which is used in
1775 ;; templates, to fontify Y as a type.
1780 )))))))))
1782 ;; Fontify symbols after closing braces as declaration
1783 ;; identifiers under the assumption that they are part of
1784 ;; declarations like "class Foo { ... } foo;". It's too
1785 ;; expensive to check this accurately by skipping past the
1786 ;; brace block, so we use the heuristic that it's such a
1787 ;; declaration if the first identifier is on the same line as
1788 ;; the closing brace. `c-font-lock-declarations' will later
1789 ;; override it if it turns out to be an new declaration, but
1790 ;; it will be wrong if it's an expression (see the test
1791 ;; decls-8.cc).
1792 ;; ,@(when (c-lang-const c-opt-block-decls-with-vars-key)
1793 ;; `((,(c-make-font-lock-search-function
1794 ;; (concat "}"
1795 ;; (c-lang-const c-single-line-syntactic-ws)
1796 ;; "\\(" ; 1 + c-single-line-syntactic-ws-depth
1797 ;; (c-lang-const c-type-decl-prefix-key)
1798 ;; "\\|"
1799 ;; (c-lang-const c-symbol-key)
1800 ;; "\\)")
1801 ;; `((c-font-lock-declarators limit t nil) ; That `nil' says use `font-lock-variable-name-face';
1802 ;; ; `t' would mean `font-lock-function-name-face'.
1803 ;; (progn
1804 ;; (c-put-char-property (match-beginning 0) 'c-type
1805 ;; 'c-decl-id-start)
1806 ;; ; 'c-decl-type-start)
1807 ;; (goto-char (match-beginning
1808 ;; ,(1+ (c-lang-const
1809 ;; c-single-line-syntactic-ws-depth)))))
1810 ;; (goto-char (match-end 0)))))))
1812 ;; Fontify the type in C++ "new" expressions.
1814 ;; This pattern is a probably a "(MATCHER . ANCHORED-HIGHLIGHTER)"
1815 ;; (see Elisp page "Search-based Fontification").
1818 ))
1821 ;; Fontify all statement labels from the point to LIMIT. Assumes
1822 ;; that strings and comments have been fontified already. Nil is
1823 ;; always returned.
1824 ;;
1825 ;; Note: This function is only used on decoration level 2; this is
1826 ;; taken care of directly by the gargantuan
1827 ;; `c-font-lock-declarations' on higher levels.
1828 ;;
1829 ;; This function might do hidden buffer changes.
1832 ;; The font-lock package in Emacs is known to clobber
1833 ;; `parse-sexp-lookup-properties' (when it exists).
1852 ;; Check for a char that precedes a statement.
1854 ;; Check for a preceding label. We exploit the font
1855 ;; locking made earlier by this function.
1862 c-label-face-name))
1863 ;; Check for a keyword that precedes a statement.
1867 ;; Got a label.
1871 c-label-face-name)))
1874 nil)
1877 "Font lock matchers for various things that should be fontified after
1878 generic casts and declarations are fontified. Used on level 2 and
1879 higher."
1882 ;; Fontify the remaining identifiers inside an enum list when we start
1883 ;; inside it.
1885 ;; Fontify the identifiers inside enum lists. (The enum type
1886 ;; name is handled by `c-simple-decl-matchers' or
1887 ;; `c-complex-decl-matchers' below.
1893 ;; Disallow various common punctuation chars that can't come
1894 ;; before the '{' of the enum list, to avoid searching too far.
1895 "[^\]\[{}();,/#=]*"
1905 ;; Fontify labels after goto etc.
1908 ;; which makes it a bit complicated: 1) The backquote
1909 ;; stuff is expanded when compiled or loaded, 2) the
1910 ;; eval form is evaluated at font-lock setup (to
1911 ;; substitute c-label-face-name correctly), and 3) the
1912 ;; resulting structure is interpreted during
1913 ;; fontification.)
1925 c-label-face-name nil t))))))
1927 ;; Fontify the clauses after various keywords.
1954 ))
1972 ;; Incorporate the font lock keyword lists according to
1973 ;; `c-doc-comment-style' on the given keyword list and return it.
1974 ;; This is used in the function bindings of the
1975 ;; `*-font-lock-keywords-*' symbols since we have to build the list
1976 ;; when font-lock is initialized.
1985 c-doc-comment-style))
1997 doc-keywords
1999 base-list)))
2001 ;; Kludge: If `c-font-lock-complex-decl-prepare' is on the list we
2002 ;; move it first since the doc comment font lockers might add
2003 ;; `c-type' text properties, so they have to be cleared before that.
2009 list))
2012 ;; This is used to override the value on a `*-font-lock-keywords'
2013 ;; variable only if it's nil or has the same value as one of the
2014 ;; `*-font-lock-keywords-*' variables. Older font-lock packages
2015 ;; define a default value for `*-font-lock-keywords' which we want
2016 ;; to override, but we should otoh avoid clobbering a user setting.
2017 ;; This heuristic for that isn't perfect, but I can't think of any
2018 ;; better. /mast
2025 suffix))))
2028 ;; The overriding is done by unbinding the variable so that the normal
2029 ;; defvar will install its default value later on.
2032 \f
2033 ;;; C.
2038 "Minimal font locking for C mode.
2039 Fontifies only preprocessor directives (in addition to the syntactic
2043 "Fast normal font locking for C mode.
2044 In addition to `c-font-lock-keywords-1', this adds fontification of
2045 keywords, simple types, declarations that are easy to recognize, the
2046 user defined types on `c-font-lock-extra-types', and the doc comment
2050 "Accurate normal font locking for C mode.
2051 Like `c-font-lock-keywords-2' but detects declarations in a more
2052 accurate way that works in most cases for arbitrary types without the
2065 \f
2066 ;;; C++.
2069 ;; FIXME!!! Put in a comment about the context of this function's
2070 ;; invocation. I think it's called as an ANCHORED-MATCHER within an
2071 ;; ANCHORED-HIGHLIGHTER. (2007/2/10).
2072 ;;
2073 ;; Assuming point is after a "new" word, check that it isn't inside
2074 ;; a string or comment, and if so try to fontify the type in the
2075 ;; allocation expression. Nil is always returned.
2076 ;;
2077 ;; As usual, C++ takes the prize in coming up with a hard to parse
2078 ;; syntax. :P
2079 ;;
2080 ;; This function might do hidden buffer changes.
2085 ;; A "new" keyword is followed by one to three expressions, where
2086 ;; the type is the middle one, and the only required part.
2088 ;; Enable recording of identifier ranges in `c-forward-type'
2089 ;; etc for later fontification. Not using
2090 ;; `c-fontify-types-and-refs' here since the ranges should
2091 ;; be fontified selectively only when an allocation
2092 ;; expression is successfully recognized.
2094 c-record-ref-identifiers
2095 ;; The font-lock package in Emacs is known to clobber
2096 ;; `parse-sexp-lookup-properties' (when it exists).
2102 ;; The first placement arglist is always parenthesized, if it
2103 ;; exists.
2111 ;; The second expression is either a type followed by some "*" or
2112 ;; "[...]" or similar, or a parenthesized type followed by a full
2113 ;; identifierless declarator.
2123 ;; No second expression, so the first has to be a
2124 ;; parenthesized type.
2130 ;; Got two parenthesized expressions, so we have to look
2131 ;; closer at them to decide which is the type. No need to
2132 ;; handle `c-record-ref-identifiers' since all references
2133 ;; has already been handled by other fontification rules.
2142 ;; There's something after the would-be type that
2143 ;; can't be there, so this is a placement arglist.
2152 ;; There's something after the would-be type that can't
2153 ;; be there, so this is an initialization expression.
2158 ;; If there's a third initialization expression
2159 ;; then the second one is the type, so demote the
2160 ;; first match.
2163 ;; We fontify the most likely type, with a preference for
2164 ;; the first argument since a placement arglist is more
2165 ;; unusual than an initializer.
2184 ;; If both type matches are 'maybe then we're
2185 ;; too uncertain to promote either of them.
2186 )))))
2188 ;; Fontify the type that now is recorded in
2189 ;; `c-record-type-identifiers', if any.
2191 nil)
2196 "Minimal font locking for C++ mode.
2197 Fontifies only preprocessor directives (in addition to the syntactic
2201 "Fast normal font locking for C++ mode.
2202 In addition to `c++-font-lock-keywords-1', this adds fontification of
2203 keywords, simple types, declarations that are easy to recognize, the
2204 user defined types on `c++-font-lock-extra-types', and the doc comment
2208 "Accurate normal font locking for C++ mode.
2209 Like `c++-font-lock-keywords-2' but detects declarations in a more
2210 accurate way that works in most cases for arbitrary types without the
2223 \f
2224 ;;; Objective-C.
2227 ;; Assuming the point is after the + or - that starts an Objective-C
2228 ;; method declaration, fontify it. This must be done before normal
2229 ;; casts, declarations and labels are fontified since they will get
2230 ;; false matches in these things.
2231 ;;
2232 ;; This function might do hidden buffer changes.
2242 ;; An optional method type.
2250 t))
2252 ;; The name. The first time it's the first part of
2253 ;; the function name, the rest of the time it's an
2254 ;; argument name.
2261 'font-lock-function-name-face
2265 ;; Another optional part of the function name.
2273 ;; There's another argument if a colon follows.
2279 ;; Fontify method declarations in Objective-C. Nil is always
2280 ;; returned.
2281 ;;
2282 ;; This function might do hidden buffer changes.
2285 ;; `parse-sexp-lookup-properties' (when it exists).
2291 limit
2292 "[-+]"
2293 nil
2297 nil)
2302 "Minimal font locking for Objective-C mode.
2303 Fontifies only compiler directives (in addition to the syntactic
2307 "Fast normal font locking for Objective-C mode.
2308 In addition to `objc-font-lock-keywords-1', this adds fontification of
2309 keywords, simple types, declarations that are easy to recognize, the
2310 user defined types on `objc-font-lock-extra-types', and the doc
2314 "Accurate normal font locking for Objective-C mode.
2315 Like `objc-font-lock-keywords-2' but detects declarations in a more
2316 accurate way that works in most cases for arbitrary types without the
2329 ;; Kludge to override the default value that
2330 ;; `objc-font-lock-extra-types' might have gotten from the font-lock
2331 ;; package. The value replaced here isn't relevant now anyway since
2332 ;; those types are builtin and therefore listed directly in
2333 ;; `c-primitive-type-kwds'.
2339 \f
2340 ;;; Java.
2345 "Minimal font locking for Java mode.
2346 Fontifies nothing except the syntactic fontification of strings and
2350 "Fast normal font locking for Java mode.
2351 In addition to `java-font-lock-keywords-1', this adds fontification of
2352 keywords, simple types, declarations that are easy to recognize, the
2353 user defined types on `java-font-lock-extra-types', and the doc
2357 "Accurate normal font locking for Java mode.
2358 Like `java-font-lock-keywords-2' but detects declarations in a more
2359 accurate way that works in most cases for arbitrary types without the
2372 \f
2373 ;;; CORBA IDL.
2378 "Minimal font locking for CORBA IDL mode.
2379 Fontifies nothing except the syntactic fontification of strings and
2383 "Fast normal font locking for CORBA IDL mode.
2384 In addition to `idl-font-lock-keywords-1', this adds fontification of
2385 keywords, simple types, declarations that are easy to recognize, the
2386 user defined types on `idl-font-lock-extra-types', and the doc comment
2390 "Accurate normal font locking for CORBA IDL mode.
2391 Like `idl-font-lock-keywords-2' but detects declarations in a more
2392 accurate way that works in most cases for arbitrary types without the
2405 \f
2406 ;;; Pike.
2411 "Minimal font locking for Pike mode.
2412 Fontifies only preprocessor directives (in addition to the syntactic
2416 "Fast normal font locking for Pike mode.
2417 In addition to `pike-font-lock-keywords-1', this adds fontification of
2418 keywords, simple types, declarations that are easy to recognize, the
2419 user defined types on `pike-font-lock-extra-types', and the doc
2423 "Accurate normal font locking for Pike mode.
2424 Like `pike-font-lock-keywords-2' but detects declarations in a more
2425 accurate way that works in most cases for arbitrary types without the
2438 \f
2439 ;;; Doc comments.
2442 ;; Fontify the comments between the point and LIMIT whose start
2443 ;; matches PREFIX with `c-doc-face-name'. Assumes comments have been
2444 ;; fontified with `font-lock-comment-face' already. nil is always
2445 ;; returned.
2446 ;;
2447 ;; After the fontification of a matching comment, fontification
2448 ;; according to KEYWORDS is applied inside it. It's a list like
2449 ;; `font-lock-keywords' except that anchored matches and eval
2450 ;; clauses aren't supported and that some abbreviated forms can't be
2451 ;; used. The buffer is narrowed to the comment while KEYWORDS is
2452 ;; applied; leading comment starters are included but trailing
2453 ;; comment enders for block comment are not.
2454 ;;
2455 ;; Note that faces added through KEYWORDS should never replace the
2456 ;; existing `c-doc-face-name' face since the existence of that face
2457 ;; is used as a flag in other code to skip comments.
2458 ;;
2459 ;; This function might do hidden buffer changes.
2464 ;; Handle the case when the fontified region starts inside a
2465 ;; comment.
2474 comment-beg
2476 ;; Search for the prefix until a match is found at the start
2477 ;; of a comment.
2481 c-literal-faces))
2484 c-literal-faces))))
2489 ;; Collect a sequence of doc style line comments.
2506 ;; Narrow to the doc comment. Among other things, this
2507 ;; helps by making "^" match at the start of the comment.
2508 ;; Do not include a trailing block comment ender, though.
2532 nil)
2536 ;; Used to fontify invalid markup in doc comments after the correct
2537 ;; ones have been fontified: Find the first occurrence of REGEXP
2538 ;; between the point and LIMIT that only is fontified with
2539 ;; `c-doc-face-name'. If a match is found then submatch 0 surrounds
2540 ;; the first char and t is returned, otherwise nil is returned.
2541 ;;
2542 ;; This function might do hidden buffer changes.
2547 c-doc-face-name))
2552 t)))
2554 ;; GtkDoc patterns contributed by Masatake YAMATO <jet@gyve.org>.
2567 ))
2576 gtkdoc-font-lock-doc-comments)
2578 gtkdoc-font-lock-doc-protection)
2579 ))))
2581 ;; Javadoc.
2596 ;; Fontify remaining markup characters as invalid. Note
2597 ;; that the Javadoc spec is hazy about when "@" is
2598 ;; allowed in non-markup use.
2606 javadoc-font-lock-doc-comments)))))
2608 ;; Pike autodoc.
2611 ;; Adorned regexp matching the keywords that introduce declarations
2612 ;; in Pike Autodoc.
2617 ;; Adorned regexp matching the keywords that are followed by a type.
2622 ;; Fontify all line oriented keywords between the point and LIMIT.
2623 ;; Nil is always returned.
2624 ;;
2625 ;; This function might do hidden buffer changes.
2628 c-current-comment-prefix
2639 end)
2643 ;; Put a declaration end mark at the markup keyword and
2644 ;; remove the faces from the rest of the line so that it
2645 ;; gets refontified as a declaration later on by
2646 ;; `c-font-lock-declarations'.
2662 ;; Include the final newline in the removed area. This
2663 ;; has no visual effect but it avoids some tricky special
2664 ;; cases in the testsuite wrt the differences in string
2665 ;; fontification in Emacs vs XEmacs.
2668 ;; Must handle string literals explicitly inside the declaration.
2676 ;; Fontify types after keywords that always are followed
2677 ;; by them.
2685 ;; Mark each whole line as markup, as long as the logical line
2686 ;; continues.
2690 markup-faces)
2698 nil)
2702 ;; In-text markup.
2705 ;; Fontify remaining markup characters as invalid.
2709 ))
2712 ;; Note that we depend on that `c-current-comment-prefix' has got
2713 ;; its proper value here.
2714 ;;
2715 ;; This function might do hidden buffer changes.
2717 ;; The `c-type' text property with `c-decl-end' is used to mark the
2718 ;; end of the `autodoc-decl-keywords' occurrences to fontify the
2719 ;; following declarations.
2724 autodoc-font-lock-doc-comments)))))
2726 \f
2727 ;; 2006-07-10: awk-font-lock-keywords has been moved back to cc-awk.el.
2730 ;;; cc-fonts.el ends here