| blob | adb1f1a4937843c19f87b6c2c2591dd8f461d3e6 |
1 ;;; cc-fonts.el --- font lock support for CC Mode
3 ;; Copyright (C) 2002-2017 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.
181 ;; Emacs and XEmacs have completely different face manipulation
182 ;; routines. :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.
192 ;; XEmacs. Same pitfall here.
200 "Face for highlighting annotations in Java mode and similar modes."
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.
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.
221 ;;
222 ;; This function does a hidden buffer change.
224 ;; Note: This function has no docstring in XEmacs so it might be
225 ;; considered internal.
230 ;; This is the inverse of `c-put-font-lock-face'.
231 ;;
232 ;; This function does a hidden buffer change.
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.
241 ;;
242 ;; This function does a hidden buffer change.
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.
251 ;;
252 ;; This function does hidden buffer changes.
254 c-record-ref-identifiers
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.
265 ;;
266 ;; This function might do hidden buffer changes.
273 t))
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.
279 ;;
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.)
292 nil)))))
293 res))))
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.
308 ;; e.g. highlight is (1 font-lock-type-face t)
312 "The override flag must currently be t in %s"
313 highlight))
316 "The laxmatch flag may currently not be set in %s"
317 highlight))
323 ;; highlight is an "ANCHORED HIGHLIGHTER" of the form
324 ;; (ANCHORED-MATCHER PRE-FORM POST-FORM SUBEXP-HIGHLIGHTERS...)
327 highlight))
332 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.
343 ;;
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.
347 ;;
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.
355 ;;
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.
365 ;; `parse-sexp-lookup-properties' (when it exists).
370 nil)))
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.
377 ;;
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.
382 ;;
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.
391 ;;
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.
395 ;;
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.
403 ;;
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.
413 ;; `parse-sexp-lookup-properties' (when it exists).
423 here)))
425 nil)))
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.
435 ;;
436 ;; The generated function takes one parameter called `limit', and
437 ;; will fontify the region between POINT and LIMIT.
438 ;;
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.
449 ;;
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.
454 ;;
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.)
458 ;;
459 ;; Note: Replace `byte-compile' with `eval' to debug the generated
460 ;; lambda more easily.
464 ;; `parse-sexp-lookup-properties' (when it exists).
477 regexp highlights)))))
478 state-stanzas)
480 nil))))
482 ; (eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
483 ; '(progn
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.
493 ;; Convert the ranges recorded on `c-record-type-identifiers' and
494 ;; `c-record-ref-identifiers' to fontification.
495 ;;
496 ;; This function does hidden buffer changes.
506 ;; Note that the reference face is a variable that is
507 ;; dereferenced, since it's an alias in Emacs.
509 c-reference-face-name))))
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.
526 ;; fontify it as a string.
533 re
537 ;; Fontify filenames in #include <...> as strings.
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.
550 re
554 font-lock-string-face t)
564 nil))))))
566 ;; #define.
570 noncontinued-line-end
577 ;; Macro with arguments - a "function".
580 ;; Macro without arguments - a "variable".
587 ;; "Function". Fontify the name and the arguments.
612 ;; "Variable".
618 ;; Fontify cpp function names in preprocessor
619 ;; expressions in #if and #elif.
630 ced-re ; 1 + ncle-depth
631 ;; Match the whole logical line to look
632 ;; for the functions in.
638 c-preprocessor-face-name)))
642 ,cef-re
645 ;; Fontify the directive names.
659 c-negation-char-face-name
661 )))
664 ;; Recognize hashbangs in Pike.
668 ;; Make hard spaces visible through an inverted `font-lock-warning-face'.
676 ))
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.
682 ;;
683 ;; This function does hidden buffer changes.
688 ;; Emacs
690 ;; XEmacs
692 ;; There's no multiline string start char before the
693 ;; string, so newlines aren't allowed.
695 ;; Multiline strings are allowed anywhere if
696 ;; c-multiline-string-start-char is t.
699 ;; There's no \ before the newline.
701 ;; Escaped newlines aren't supported.
702 t)
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.
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.
721 ;; Match a char before the string starter to make
722 ;; `c-skip-comments-and-strings' work correctly.
726 ;; Fontify C++ raw strings.
730 ;; Fontify keyword constants.
734 ;; No symbol is a keyword after "->" in Pike.
741 ;; Fontify all keywords except the primitive types.
743 ;; No symbol is a keyword after "->" in Pike.
750 ;; Fontify leading identifiers in fully qualified names like
751 ;; "foo::bar" in languages that supports such things.
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.
762 ;; Search for class identifiers preceded by ".". The
763 ;; anchored matcher takes it from there.
783 c-reference-face-name)
785 nil
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).
806 limit t)
813 c-reference-face-name))
816 ;; Fontify the special declarations in Objective-C.
824 ;; In this case we accept both primitive and known types.
831 ;; The @interface/@implementation/@protocol directives.
836 t)
840 ;; `parse-sexp-lookup-properties' (when it exists).
845 nil)
849 ))
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".
857 ;;
858 ;; Called before any of the matchers in `c-complex-decl-matchers'.
859 ;;
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.
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.
880 c-decl-end
881 c-decl-id-start
882 c-decl-type-start)))
884 pos)
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.
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.
911 nil)
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".
919 ;;
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.
923 ;;
924 ;; This function might do hidden buffer changes.
927 ;; `parse-sexp-lookup-properties' (when it exists).
932 c-restricted-<>-arglists
933 id-start id-end id-face pos kwd-sym)
945 c-restricted-<>-arglists nil
950 ;; The identifier got the type face so it has already been
951 ;; handled in `c-font-lock-declarations'.
952 nil)
956 ;; There's a special keyword before the "<" that tells
957 ;; that it's an angle bracket arglist.
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)".
970 t))
974 ;; Check for comment/string both at the identifier and
975 ;; at the "<".
986 c-reference-face-name))
993 nil)
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'.)
999 ;;
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.
1004 ;;
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.).
1008 ;;
1009 ;; Nil is always returned. The function leaves point at the delimiter after
1010 ;; the last declarator it processes.
1011 ;;
1012 ;; This function might do hidden buffer changes.
1014 ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
1017 decl-res
1018 paren-depth
1019 id-face got-type got-init
1020 c-last-identifier-range
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.
1034 ; parens, etc.
1060 t)))))
1061 'font-lock-function-name-face
1067 ;; Register and fontify the identifier as a 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'.
1079 id-face)))
1084 ;; Jump past any initializer or function prototype to see if
1085 ;; there's a ',' to continue at.
1087 ;; Skip a parenthesized initializer (C++) or a function
1088 ;; prototype.
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.
1102 t)
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).
1112 ;; If a ',' is found we set pos to the next declarator and iterate.
1118 nil)
1121 ;; Return a cons (CONTEXT . RESTRICTED-<>-ARGLISTS) for MATCH-POS.
1122 ;; NOT-FRONT-DECL is non-nil when a declaration later in the buffer than
1123 ;; MATCH-POS has already been parsed. TOPLEV is non-nil when MATCH-POS is
1124 ;; known to be at "top level", i.e. outside any braces, or directly inside a
1125 ;; namespace, class, etc.
1126 ;;
1127 ;; CONTEXT is the fontification context of MATCH-POS, and is one of the
1128 ;; following:
1129 ;; 'decl In a comma-separated declaration context (typically
1130 ;; inside a function declaration arglist).
1131 ;; '<> In an angle bracket arglist.
1132 ;; 'arglist Some other type of arglist.
1133 ;; 'top Some other context and point is at the top-level (either
1134 ;; outside any braces or directly inside a class or namespace,
1135 ;; etc.)
1136 ;; nil Some other context or unknown context. Includes
1137 ;; within the parens of an if, for, ... construct.
1138 ;; 'not-decl Definitely not in a declaration.
1139 ;;
1140 ;; RESTRICTED-<>-ARGLISTS is non-nil when a scan of template/generic
1141 ;; arguments lists (i.e. lists enclosed by <...>) is more strict about what
1142 ;; characters it allows within the list.
1147 ;; A control flow expression or a decltype
1157 ;; Near BOB.
1160 ;; Got a cached hit in a declaration arglist.
1163 ;; We're inside (probably) a brace list.
1166 ;; Inside a C++11 lambda function arglist.
1178 ;; We're inside a brace list.
1187 ;; We're inside an "ordinary" open brace.
1190 ;; Inside an angle bracket arglist.
1194 ;; Got a cached hit in some other type of arglist.
1198 ;; The point is within the range of a previously
1199 ;; encountered type decl expression, so the arglist
1200 ;; is probably one that contains declarations.
1201 ;; However, if `c-recognize-paren-inits' is set it
1202 ;; might also be an initializer arglist.
1203 ;;
1204 ;; The result of this check is cached with a char
1205 ;; property on the match token, so that we can look
1206 ;; it up again when refontifying single lines in a
1207 ;; multiline declaration.
1211 ;; Got an open paren preceded by an arith operator.
1217 ;; At start of a declaration inside a declaration paren.
1234 c-decl-type-start))))))))))
1239 ;; Fontify all the declarations, casts and labels from the point to LIMIT.
1240 ;; Assumes that strings and comments have been fontified already.
1241 ;;
1242 ;; This function will be called from font-lock for a region bounded by POINT
1243 ;; and LIMIT, as though it were to identify a keyword for
1244 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1245 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1246 ;; Fontification".
1247 ;;
1248 ;; This function might do hidden buffer changes.
1250 ;;(message "c-font-lock-declarations search from %s to %s" (point) limit)
1254 start-pos
1255 ;; o - 'decl if we're in an arglist containing declarations
1256 ;; (but if `c-recognize-paren-inits' is set it might also be
1257 ;; an initializer arglist);
1258 ;; o - '<> if the arglist is of angle bracket type;
1259 ;; o - 'arglist if it's some other arglist;
1260 ;; o - nil, if not in an arglist at all. This includes the
1261 ;; parenthesized condition which follows "if", "while", etc.
1262 context
1263 ;; A list of starting positions of possible type declarations, or of
1264 ;; the typedef preceding one, if any.
1265 last-cast-end
1266 ;; The result from `c-forward-decl-or-cast-1'.
1267 decl-or-cast
1268 ;; The maximum of the end positions of all the checked type
1269 ;; decl expressions in the successfully identified
1270 ;; declarations. The position might be either before or
1271 ;; after the syntactic whitespace following the last token
1272 ;; in the type decl expression.
1274 ;; Same as `max-type-decl-*', but used when we're before
1275 ;; `token-pos'.
1277 ;; End of <..> construct which has had c-<>-arg-sep c-type
1278 ;; properties set within it.
1280 ;; Set according to the context to direct the heuristics for
1281 ;; recognizing C++ templates.
1282 c-restricted-<>-arglists
1283 ;; Turn on recording of identifier ranges in
1284 ;; `c-forward-decl-or-cast-1' and `c-forward-label' for
1285 ;; later fontification.
1287 label-type
1288 c-record-ref-identifiers
1289 ;; Make `c-forward-type' calls mark up template arglists if
1290 ;; it finds any. That's necessary so that we later will
1291 ;; stop inside them to fontify types there.
1293 lbrace ; position of some {.
1294 ;; The font-lock package in Emacs is known to clobber
1295 ;; `parse-sexp-lookup-properties' (when it exists).
1299 ))
1301 ;; Below we fontify a whole declaration even when it crosses the limit,
1302 ;; to avoid gaps when jit/lazy-lock fontifies the file a block at a
1303 ;; time. That is however annoying during editing, e.g. the following is
1304 ;; a common situation while the first line is being written:
1305 ;;
1306 ;; my_variable
1307 ;; some_other_variable = 0;
1308 ;;
1309 ;; font-lock will put the limit at the beginning of the second line
1310 ;; here, and if we go past it we'll fontify "my_variable" as a type and
1311 ;; "some_other_variable" as an identifier, and the latter will not
1312 ;; correct itself until the second line is changed. To avoid that we
1313 ;; narrow to the limit if the region to fontify is a single line.
1318 ;; Narrow after any operator chars following the limit though,
1319 ;; since those characters can be useful in recognizing a
1320 ;; declaration (in particular the '{' that opens a function body
1321 ;; after the header).
1327 limit
1328 c-decl-start-re
1332 ;; Note to maintainers: don't use `limit' inside this lambda form;
1333 ;; c-find-decl-spots sometimes narrows to less than `limit'.
1336 ;; The result of the form below is true when we don't recognize a
1337 ;; declaration or cast, and we don't recognize a "non-decl",
1338 ;; typically a brace list.
1344 ;; Don't do anything more if we're looking at a keyword that
1345 ;; can't start a declaration.
1346 t
1348 ;; Set `context' and `c-restricted-<>-arglists'. Look for
1349 ;; "<" for the sake of C++-style template arglists.
1350 ;; Ignore "(" when it's part of a control flow construct
1351 ;; (e.g. "for (").
1354 match-pos
1356 max-type-decl-end-before-token
1357 max-type-decl-end))
1358 toplev)))
1362 ;; Check we haven't missed a preceding "typedef".
1369 ;; In QT, "more" is an irritating keyword that expands to nothing.
1370 ;; We skip over it to prevent recognition of "more slots: <symbol>"
1371 ;; as a bitfield declaration.
1378 ;; Now analyze the construct.
1385 nil)
1388 match-pos context last-cast-end))
1390 ;; Ensure that c-<>-arg-sep c-type properties are in place on the
1391 ;; commas separating the arguments inside template/generic <..>s.
1414 ;; Save the position after the previous cast so we can feed
1415 ;; it to `c-forward-decl-or-cast-1' in the next round. That
1416 ;; helps it discover cast chains like "(a) (b) c".
1419 nil)
1422 ;; We've found a declaration.
1424 ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
1425 ;; under the assumption that we're after the first type decl
1426 ;; expression in the declaration now. That's not really true;
1427 ;; we could also be after a parenthesized initializer
1428 ;; expression in C++, but this is only used as a last resort
1429 ;; to slant ambiguous expression/declarations, and overall
1430 ;; it's worth the risk to occasionally fontify an expression
1431 ;; as a declaration in an initializer expression compared to
1432 ;; getting ambiguous things in normal function prototypes
1433 ;; fontified as expressions.
1440 ;; Do we have an expression as the second or third clause of
1441 ;; a "for" paren expression?
1456 ;; We've got an expression in "for" parens. Remove the
1457 ;; "type" that would spuriously get fontified.
1460 c-record-type-identifiers))))
1464 elt c-record-type-identifiers)))
1465 t)
1466 ;; Back up to the type to fontify the declarator(s).
1471 ;; Should normally not fontify a list of
1472 ;; declarators inside an arglist, but the first
1473 ;; argument in the ';' separated list of a "for"
1474 ;; statement is an exception.
1481 t)))
1483 ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
1484 ;; before the first declarator if it's a list.
1485 ;; `c-font-lock-declarators' handles the rest.
1492 'c-decl-type-start
1499 ;; A declaration has been successfully identified, so do all the
1500 ;; fontification of types and refs that've been recorded.
1502 nil))
1506 ;; It was a false alarm. Check if we're in a label (or other
1507 ;; construct with `:' except bitfield) instead.
1510 ;; Can't use `c-fontify-types-and-refs' here since we
1511 ;; use the label face at times.
1515 c-label-face-name))
1525 c-record-ref-identifiers)))
1527 ;; `c-forward-label' has probably added a `c-decl-end'
1528 ;; marker, so return t to `c-find-decl-spots' to signal
1529 ;; that.
1530 t))))
1532 nil)))
1535 ;; Fontify the identifiers of each enum we find by searching forward.
1536 ;;
1537 ;; This function will be called from font-lock for a region bounded by POINT
1538 ;; and LIMIT, as though it were to identify a keyword for
1539 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1540 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1541 ;; Fontification".
1548 nil)
1551 ;; Fontify an enum's identifiers when POINT is within the enum's brace
1552 ;; block.
1553 ;;
1554 ;; This function will be called from font-lock for a region bounded by POINT
1555 ;; and LIMIT, as though it were to identify a keyword for
1556 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1557 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1558 ;; Fontification".
1559 ;;
1560 ;; Note that this function won't attempt to fontify beyond the end of the
1561 ;; current enum block, if any.
1565 encl-pos
1575 nil)
1578 ;; Fontify any declarators "cut off" from their declaring type at the start
1579 ;; of the region being fontified.
1580 ;;
1581 ;; This function will be called from font-lock- for a region bounded by
1582 ;; POINT and LIMIT, as though it were to identify a keyword for
1583 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1584 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1585 ;; fontification".
1587 paren-state bod-res is-typedef encl-pos
1590 ; speeds up lisp.h tremendously.
1603 ;; We're now putatively at the declaration.
1605 ;; At top level or inside a "{"?
1614 ;; At a real declaration?
1618 nil))
1621 ;; Fontify the declarators of (nested) declarations we're in the middle of.
1622 ;; This is mainly for when a jit-lock etc. chunk starts inside the brace
1623 ;; block of a struct/union/class, etc.
1624 ;;
1625 ;; This function will be called from font-lock for a region bounded by POINT
1626 ;; and LIMIT, as though it were to identify a keyword for
1627 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1628 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1629 ;; Fontification".
1632 in-typedef ps-elt)
1633 ;; Are we in any nested struct/union/class/etc. braces?
1655 ;; Fontify C++ raw strings.
1656 ;;
1657 ;; This function will be called from font-lock for a region bounded by POINT
1658 ;; and LIMIT, as though it were to identify a keyword for
1659 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1660 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1661 ;; Fontification".
1701 nil)
1704 ;; Fontify the lambda capture component of C++ lambda declarations.
1705 ;;
1706 ;; This function will be called from font-lock for a region bounded by POINT
1707 ;; and LIMIT, as though it were to identify a keyword for
1708 ;; font-lock-keyword-face. It always returns NIL to inhibit this and
1709 ;; prevent a repeat invocation. See elisp/lispref page "Search-based
1710 ;; Fontification".
1721 ;; Is the first element of the list a bare "=" or "&"?
1733 ;; Go round the following loop once per captured item. We use "\\s)"
1734 ;; rather than "\\]" here to avoid infinite looping in this situation:
1735 ;; "unsigned items [] { [ }". The second "[" triggers this function,
1736 ;; but if we don't match the "}" with an "\\s)", the
1737 ;; `c-syntactic-re-search-forward' at the end of the loop fails to
1738 ;; move forward over it, leaving point stuck at the "}".
1790 nil)
1794 "Simple font lock matchers for types and declarations. These are used
1795 on level 2 only and so aren't combined with `c-complex-decl-matchers'."
1803 ;; `parse-sexp-lookup-properties' (when it exists).
1810 nil))
1813 ;; Fontify all type names and the identifiers in the
1814 ;; declarations they might start. Use eval here since
1815 ;; `c-known-type-key' gets its value from
1816 ;; `*-font-lock-extra-types' on mode init.
1818 'c-known-type-key
1826 ;; Fontify types preceded by `c-type-prefix-kwds' and the
1827 ;; identifiers in the declarations they might start.
1840 `(,type-match
1848 ;; Fontify special declarations that lacks a type.
1860 ;; Fontify generic colon labels in languages that support them.
1865 "Complex font lock matchers for types and declarations. Used on level
1866 3 and higher."
1868 ;; Note: This code in this form dumps a number of functions into the
1869 ;; resulting constant, `c-matchers-3'. At run time, font lock will call
1870 ;; each of them as a "FUNCTION" (see Elisp page "Search-based
1871 ;; Fontification"). The font lock region is delimited by POINT and the
1872 ;; single parameter, LIMIT. Each of these functions returns NIL (thus
1873 ;; inhibiting spurious font-lock-keyword-face highlighting and another
1874 ;; call).
1877 c-font-lock-complex-decl-prepare
1880 ;; Fontify method declarations in Objective-C, but first
1881 ;; we have to put the `c-decl-end' `c-type' property on
1882 ;; all the @-style directives that haven't been handled in
1883 ;; `c-basic-matchers-before'.
1886 ;; Exclude "@class" since that directive ends with a
1887 ;; semicolon anyway.
1891 nil)))
1894 c-font-lock-objc-methods))
1896 ;; Fontify declarators which have been cut off from their declaring
1897 ;; types at the start of the region.
1898 c-font-lock-cut-off-declarators
1900 ;; Fontify all declarations, casts and normal labels.
1901 c-font-lock-declarations
1903 ;; Fontify declarators when POINT is within their declaration.
1904 c-font-lock-enclosing-decls
1906 ;; Fontify angle bracket arglists like templates in C++.
1913 ;; The first two rules here mostly find occurrences that
1914 ;; `c-font-lock-declarations' has found already, but not
1915 ;; declarations containing blocks in the type (see note below).
1916 ;; It's also useful to fontify these everywhere to show e.g. when
1917 ;; a type keyword is accidentally used as an identifier.
1919 ;; Fontify basic types.
1923 ;; No symbol is a keyword after "->" in Pike.
1930 ;; Fontify types preceded by `c-type-prefix-kwds' (e.g. "struct").
1936 ;; The font-lock package in Emacs is known to clobber
1937 ;; `parse-sexp-lookup-properties' (when it exists).
1942 ;; Narrow to avoid going past the limit in
1943 ;; `c-forward-type'.
1950 limit t)
1953 ;; Handle prefix declaration specifiers.
1960 t)
1963 c-noise-macro-with-parens-name-re))
1965 t)))
1969 ;; In C++ we additionally check for a "class
1970 ;; X = Y" construct which is used in
1971 ;; templates, to fontify Y as a type.
1976 )))))))))
1978 ;; Fontify symbols after closing braces as declaration
1979 ;; identifiers under the assumption that they are part of
1980 ;; declarations like "class Foo { ... } foo;". It's too
1981 ;; expensive to check this accurately by skipping past the
1982 ;; brace block, so we use the heuristic that it's such a
1983 ;; declaration if the first identifier is on the same line as
1984 ;; the closing brace. `c-font-lock-declarations' will later
1985 ;; override it if it turns out to be an new declaration, but
1986 ;; it will be wrong if it's an expression (see the test
1987 ;; decls-8.cc).
1988 ;; ,@(when (c-lang-const c-opt-block-decls-with-vars-key)
1989 ;; `((,(c-make-font-lock-search-function
1990 ;; (concat "}"
1991 ;; (c-lang-const c-single-line-syntactic-ws)
1992 ;; "\\(" ; 1 + c-single-line-syntactic-ws-depth
1993 ;; (c-lang-const c-type-decl-prefix-key)
1994 ;; "\\|"
1995 ;; (c-lang-const c-symbol-key)
1996 ;; "\\)")
1997 ;; `((c-font-lock-declarators limit t nil) ; That nil says use `font-lock-variable-name-face';
1998 ;; ; t would mean `font-lock-function-name-face'.
1999 ;; (progn
2000 ;; (c-put-char-property (match-beginning 0) 'c-type
2001 ;; 'c-decl-id-start)
2002 ;; ; 'c-decl-type-start)
2003 ;; (goto-char (match-beginning
2004 ;; ,(1+ (c-lang-const
2005 ;; c-single-line-syntactic-ws-depth)))))
2006 ;; (goto-char (match-end 0)))))))
2008 ;; Fontify the type in C++ "new" expressions.
2010 ;; This pattern is a probably a "(MATCHER . ANCHORED-HIGHLIGHTER)"
2011 ;; (see Elisp page "Search-based Fontification").
2014 ))
2017 ;; Fontify all statement labels from the point to LIMIT. Assumes
2018 ;; that strings and comments have been fontified already. Nil is
2019 ;; always returned.
2020 ;;
2021 ;; Note: This function is only used on decoration level 2; this is
2022 ;; taken care of directly by the gargantuan
2023 ;; `c-font-lock-declarations' on higher levels.
2024 ;;
2025 ;; This function might do hidden buffer changes.
2028 ;; The font-lock package in Emacs is known to clobber
2029 ;; `parse-sexp-lookup-properties' (when it exists).
2048 ;; Check for a char that precedes a statement.
2050 ;; Check for a preceding label. We exploit the font
2051 ;; locking made earlier by this function.
2058 c-label-face-name))
2059 ;; Check for a keyword that precedes a statement.
2063 ;; Got a label.
2067 c-label-face-name)))
2070 nil)
2073 "Font lock matchers for various things that should be fontified after
2074 generic casts and declarations are fontified. Used on level 2 and
2075 higher."
2078 ;; Fontify the remaining identifiers inside an enum list when we start
2079 ;; inside it.
2081 ;; Fontify the identifiers inside enum lists. (The enum type
2082 ;; name is handled by `c-simple-decl-matchers' or
2083 ;; `c-complex-decl-matchers' below.
2084 c-font-lock-enum-body))
2086 ;; Fontify labels after goto etc.
2089 ;; which makes it a bit complicated: 1) The backquote
2090 ;; stuff is expanded when compiled or loaded, 2) the
2091 ;; eval form is evaluated at font-lock setup (to
2092 ;; substitute c-label-face-name correctly), and 3) the
2093 ;; resulting structure is interpreted during
2094 ;; fontification.)
2106 c-label-face-name nil t))))))
2108 ;; Fontify the clauses after various keywords.
2135 ))
2153 ;; Incorporate the font lock keyword lists according to
2154 ;; `c-doc-comment-style' on the given keyword list and return it.
2155 ;; This is used in the function bindings of the
2156 ;; `*-font-lock-keywords-*' symbols since we have to build the list
2157 ;; when font-lock is initialized.
2166 c-doc-comment-style))
2177 doc-keywords
2179 base-list)))
2181 ;; Kludge: If `c-font-lock-complex-decl-prepare' is on the list we
2182 ;; move it first since the doc comment font lockers might add
2183 ;; `c-type' text properties, so they have to be cleared before that.
2189 list))
2192 ;; This is used to override the value on a `*-font-lock-keywords'
2193 ;; variable only if it's nil or has the same value as one of the
2194 ;; `*-font-lock-keywords-*' variables. Older font-lock packages
2195 ;; define a default value for `*-font-lock-keywords' which we want
2196 ;; to override, but we should otoh avoid clobbering a user setting.
2197 ;; This heuristic for that isn't perfect, but I can't think of any
2198 ;; better. /mast
2205 suffix))))
2208 ;; The overriding is done by unbinding the variable so that the normal
2209 ;; defvar will install its default value later on.
2212 \f
2213 ;;; C.
2218 "Minimal font locking for C mode.
2219 Fontifies only preprocessor directives (in addition to the syntactic
2223 "Fast normal font locking for C mode.
2224 In addition to `c-font-lock-keywords-1', this adds fontification of
2225 keywords, simple types, declarations that are easy to recognize, the
2226 user defined types on `c-font-lock-extra-types', and the doc comment
2230 "Accurate normal font locking for C mode.
2231 Like the variable `c-font-lock-keywords-2' but detects declarations in a more
2232 accurate way that works in most cases for arbitrary types without the
2245 \f
2246 ;;; C++.
2249 ;; FIXME!!! Put in a comment about the context of this function's
2250 ;; invocation. I think it's called as an ANCHORED-MATCHER within an
2251 ;; ANCHORED-HIGHLIGHTER. (2007/2/10).
2252 ;;
2253 ;; Assuming point is after a "new" word, check that it isn't inside
2254 ;; a string or comment, and if so try to fontify the type in the
2255 ;; allocation expression. Nil is always returned.
2256 ;;
2257 ;; As usual, C++ takes the prize in coming up with a hard to parse
2258 ;; syntax. :P
2259 ;;
2260 ;; This function might do hidden buffer changes.
2265 ;; A "new" keyword is followed by one to three expressions, where
2266 ;; the type is the middle one, and the only required part.
2268 ;; Enable recording of identifier ranges in `c-forward-type'
2269 ;; etc for later fontification. Not using
2270 ;; `c-fontify-types-and-refs' here since the ranges should
2271 ;; be fontified selectively only when an allocation
2272 ;; expression is successfully recognized.
2274 c-record-ref-identifiers
2275 ;; The font-lock package in Emacs is known to clobber
2276 ;; `parse-sexp-lookup-properties' (when it exists).
2282 ;; The first placement arglist is always parenthesized, if it
2283 ;; exists.
2291 ;; The second expression is either a type followed by some "*" or
2292 ;; "[...]" or similar, or a parenthesized type followed by a full
2293 ;; identifierless declarator.
2303 ;; No second expression, so the first has to be a
2304 ;; parenthesized type.
2310 ;; Got two parenthesized expressions, so we have to look
2311 ;; closer at them to decide which is the type. No need to
2312 ;; handle `c-record-ref-identifiers' since all references
2313 ;; have already been handled by other fontification rules.
2322 ;; There's something after the would-be type that
2323 ;; can't be there, so this is a placement arglist.
2332 ;; There's something after the would-be type that can't
2333 ;; be there, so this is an initialization expression.
2338 ;; If there's a third initialization expression
2339 ;; then the second one is the type, so demote the
2340 ;; first match.
2343 ;; We fontify the most likely type, with a preference for
2344 ;; the first argument since a placement arglist is more
2345 ;; unusual than an initializer.
2348 ;; Presumably 'decltype's will be fontified elsewhere.
2367 ;; If both type matches are 'maybe then we're
2368 ;; too uncertain to promote either of them.
2369 )))))
2371 ;; Fontify the type that now is recorded in
2372 ;; `c-record-type-identifiers', if any.
2374 nil)
2379 "Minimal font locking for C++ mode.
2380 Fontifies only preprocessor directives (in addition to the syntactic
2384 "Fast normal font locking for C++ mode.
2385 In addition to `c++-font-lock-keywords-1', this adds fontification of
2386 keywords, simple types, declarations that are easy to recognize, the
2387 user defined types on `c++-font-lock-extra-types', and the doc comment
2391 "Accurate normal font locking for C++ mode.
2392 Like the variable `c++-font-lock-keywords-2' but detects declarations in a more
2393 accurate way that works in most cases for arbitrary types without the
2406 \f
2407 ;;; Objective-C.
2410 ;; Assuming the point is after the + or - that starts an Objective-C
2411 ;; method declaration, fontify it. This must be done before normal
2412 ;; casts, declarations and labels are fontified since they will get
2413 ;; false matches in these things.
2414 ;;
2415 ;; This function might do hidden buffer changes.
2425 ;; An optional method type.
2433 t))
2435 ;; The name. The first time it's the first part of
2436 ;; the function name, the rest of the time it's an
2437 ;; argument name.
2444 'font-lock-function-name-face
2448 ;; Another optional part of the function name.
2456 ;; There's another argument if a colon follows.
2462 ;; Fontify method declarations in Objective-C. Nil is always
2463 ;; returned.
2464 ;;
2465 ;; This function might do hidden buffer changes.
2468 ;; `parse-sexp-lookup-properties' (when it exists).
2474 limit
2475 "[-+]"
2476 nil
2480 nil)
2485 "Minimal font locking for Objective-C mode.
2486 Fontifies only compiler directives (in addition to the syntactic
2490 "Fast normal font locking for Objective-C mode.
2491 In addition to `objc-font-lock-keywords-1', this adds fontification of
2492 keywords, simple types, declarations that are easy to recognize, the
2493 user defined types on `objc-font-lock-extra-types', and the doc
2497 "Accurate normal font locking for Objective-C mode.
2498 Like the variable `objc-font-lock-keywords-2' but detects declarations in a more
2499 accurate way that works in most cases for arbitrary types without the
2512 ;; Kludge to override the default value that
2513 ;; `objc-font-lock-extra-types' might have gotten from the font-lock
2514 ;; package. The value replaced here isn't relevant now anyway since
2515 ;; those types are builtin and therefore listed directly in
2516 ;; `c-primitive-type-kwds'.
2522 \f
2523 ;;; Java.
2528 "Minimal font locking for Java mode.
2529 Fontifies nothing except the syntactic fontification of strings and
2533 "Fast normal font locking for Java mode.
2534 In addition to `java-font-lock-keywords-1', this adds fontification of
2535 keywords, simple types, declarations that are easy to recognize, the
2536 user defined types on `java-font-lock-extra-types', and the doc
2540 "Accurate normal font locking for Java mode.
2541 Like variable `java-font-lock-keywords-2' but detects declarations in a more
2542 accurate way that works in most cases for arbitrary types without the
2555 \f
2556 ;;; CORBA IDL.
2561 "Minimal font locking for CORBA IDL mode.
2562 Fontifies nothing except the syntactic fontification of strings and
2566 "Fast normal font locking for CORBA IDL mode.
2567 In addition to `idl-font-lock-keywords-1', this adds fontification of
2568 keywords, simple types, declarations that are easy to recognize, the
2569 user defined types on `idl-font-lock-extra-types', and the doc comment
2573 "Accurate normal font locking for CORBA IDL mode.
2574 Like the variable `idl-font-lock-keywords-2' but detects declarations in a more
2575 accurate way that works in most cases for arbitrary types without the
2588 \f
2589 ;;; Pike.
2594 "Minimal font locking for Pike mode.
2595 Fontifies only preprocessor directives (in addition to the syntactic
2599 "Fast normal font locking for Pike mode.
2600 In addition to `pike-font-lock-keywords-1', this adds fontification of
2601 keywords, simple types, declarations that are easy to recognize, the
2602 user defined types on `pike-font-lock-extra-types', and the doc
2606 "Accurate normal font locking for Pike mode.
2607 Like the variable `pike-font-lock-keywords-2' but detects declarations in a more
2608 accurate way that works in most cases for arbitrary types without the
2621 \f
2622 ;;; Doc comments.
2625 ;; Fontify the comments between the point and LIMIT whose start
2626 ;; matches PREFIX with `c-doc-face-name'. Assumes comments have been
2627 ;; fontified with `font-lock-comment-face' already. nil is always
2628 ;; returned.
2629 ;;
2630 ;; After the fontification of a matching comment, fontification
2631 ;; according to KEYWORDS is applied inside it. It's a list like
2632 ;; `font-lock-keywords' except that anchored matches and eval
2633 ;; clauses aren't supported and that some abbreviated forms can't be
2634 ;; used. The buffer is narrowed to the comment while KEYWORDS is
2635 ;; applied; leading comment starters are included but trailing
2636 ;; comment enders for block comment are not.
2637 ;;
2638 ;; Note that faces added through KEYWORDS should never replace the
2639 ;; existing `c-doc-face-name' face since the existence of that face
2640 ;; is used as a flag in other code to skip comments.
2641 ;;
2642 ;; This function might do hidden buffer changes.
2647 ;; Handle the case when the fontified region starts inside a
2648 ;; comment.
2657 comment-beg
2659 ;; Search for the prefix until a match is found at the start
2660 ;; of a comment.
2664 c-literal-faces))
2667 c-literal-faces))))
2672 ;; Collect a sequence of doc style line comments.
2689 ;; Narrow to the doc comment. Among other things, this
2690 ;; helps by making "^" match at the start of the comment.
2691 ;; Do not include a trailing block comment ender, though.
2715 nil)
2719 ;; Used to fontify invalid markup in doc comments after the correct
2720 ;; ones have been fontified: Find the first occurrence of REGEXP
2721 ;; between the point and LIMIT that only is fontified with
2722 ;; `c-doc-face-name'. If a match is found then submatch 0 surrounds
2723 ;; the first char and t is returned, otherwise nil is returned.
2724 ;;
2725 ;; This function might do hidden buffer changes.
2730 c-doc-face-name))
2735 t)))
2737 ;; GtkDoc patterns contributed by Masatake YAMATO <jet@gyve.org>.
2750 ))
2759 gtkdoc-font-lock-doc-comments)
2761 gtkdoc-font-lock-doc-protection)
2762 ))))
2764 ;; Javadoc.
2779 ;; Fontify remaining markup characters as invalid. Note
2780 ;; that the Javadoc spec is hazy about when "@" is
2781 ;; allowed in non-markup use.
2789 javadoc-font-lock-doc-comments)))))
2791 ;; Pike autodoc.
2794 ;; Adorned regexp matching the keywords that introduce declarations
2795 ;; in Pike Autodoc.
2800 ;; Adorned regexp matching the keywords that are followed by a type.
2805 ;; Fontify all line oriented keywords between the point and LIMIT.
2806 ;; Nil is always returned.
2807 ;;
2808 ;; This function might do hidden buffer changes.
2811 c-current-comment-prefix
2822 end)
2826 ;; Put a declaration end mark at the markup keyword and
2827 ;; remove the faces from the rest of the line so that it
2828 ;; gets refontified as a declaration later on by
2829 ;; `c-font-lock-declarations'.
2845 ;; Include the final newline in the removed area. This
2846 ;; has no visual effect but it avoids some tricky special
2847 ;; cases in the testsuite wrt the differences in string
2848 ;; fontification in Emacs vs XEmacs.
2851 ;; Must handle string literals explicitly inside the declaration.
2859 ;; Fontify types after keywords that always are followed
2860 ;; by them.
2868 ;; Mark each whole line as markup, as long as the logical line
2869 ;; continues.
2873 markup-faces)
2881 nil)
2885 ;; In-text markup.
2888 ;; Fontify remaining markup characters as invalid.
2892 ))
2895 ;; Note that we depend on that `c-current-comment-prefix' has got
2896 ;; its proper value here.
2897 ;;
2898 ;; This function might do hidden buffer changes.
2900 ;; The `c-type' text property with `c-decl-end' is used to mark the
2901 ;; end of the `autodoc-decl-keywords' occurrences to fontify the
2902 ;; following declarations.
2907 autodoc-font-lock-doc-comments)))))
2909 \f
2910 ;; 2006-07-10: awk-font-lock-keywords has been moved back to cc-awk.el.
2913 ;; Local Variables:
2914 ;; indent-tabs-mode: t
2915 ;; tab-width: 8
2916 ;; End:
2917 ;;; cc-fonts.el ends here