| blob | 75d631ac3992460cb6f155cb939a124b4e17b674 |
1 ;;; cc-fonts.el --- font lock support for CC Mode
3 ;; Copyright (C) 2002, 2003, 2004, 2005, 2006 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 ;; Version: See cc-mode.el
10 ;; Keywords: c languages oop
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 2, or (at your option)
17 ;; 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 this program; see the file COPYING. If not, write to
26 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
27 ;; Boston, MA 02110-1301, USA.
29 ;;; Commentary:
31 ;; Some comments on the use of faces:
32 ;;
33 ;; o `c-label-face-name' is either `font-lock-constant-face' (in
34 ;; Emacs), or `font-lock-reference-face'.
35 ;;
36 ;; o `c-constant-face-name', `c-reference-face-name' and
37 ;; `c-doc-markup-face-name' are essentially set up like
38 ;; `c-label-face-name'.
39 ;;
40 ;; o `c-preprocessor-face-name' is `font-lock-preprocessor-face' in
41 ;; XEmacs and - in lack of a closer equivalent -
42 ;; `font-lock-builtin-face' or `font-lock-reference-face' in Emacs.
43 ;;
44 ;; o `c-doc-face-name' is `font-lock-doc-string-face' in XEmacs,
45 ;; `font-lock-doc-face' in Emacs 21 and later, or
46 ;; `font-lock-comment-face' in older Emacs (that since source
47 ;; documentation are actually comments in these languages, as opposed
48 ;; to elisp).
49 ;;
50 ;; TBD: We should probably provide real faces for the above uses and
51 ;; instead initialize them from the standard faces.
53 ;;; Code:
55 ;; The faces that already have been put onto the text is tested in
56 ;; various places to direct further fontifications. For this to work,
57 ;; the following assumptions regarding the faces must hold (apart from
58 ;; the dependencies on the font locking order):
59 ;;
60 ;; o `font-lock-comment-face' and the face in `c-doc-face-name' is
61 ;; not used in anything but comments.
62 ;; o If any face (e.g. `c-doc-markup-face-name') but those above is
63 ;; used in comments, it doesn't replace them.
64 ;; o `font-lock-string-face' is not used in anything but string
65 ;; literals (single or double quoted).
66 ;; o `font-lock-keyword-face' and the face in `c-label-face-name' are
67 ;; never overlaid with other faces.
74 load-path)))
82 ;; prevent cc-awk being loaded when it's not needed. There is now a (require
83 ;; 'cc-awk) in (defun awk-mode ..).
85 ;; Avoid repeated loading through the eval-after-load directive in
86 ;; cc-mode.el.
93 ;; Need to declare these local symbols during compilation since
94 ;; they're referenced from lambdas in `byte-compile' calls that are
95 ;; executed at compile time. They don't need to have the proper
96 ;; definitions, though, since the generated functions aren't called
97 ;; during compilation.
105 \f
106 ;; Note that font-lock in XEmacs doesn't expand face names as
107 ;; variables, so we have to use the (eval . FORM) in the font lock
108 ;; matchers wherever we use these alias variables.
112 ;; XEmacs has a font-lock-preprocessor-face.
115 ;; In Emacs font-lock-builtin-face has traditionally been
116 ;; used for preprocessor directives.
125 ;; If it happens to occur in the future. (Well, the more
126 ;; pragmatic reason is to get unique faces for the test
127 ;; suite.)
131 ;; Test both if font-lock-constant-face exists and that it's
132 ;; not an alias for something else. This is important since
133 ;; we compare already set faces in various places.
141 ;; This doesn't exist in some earlier versions of XEmacs 21.
142 'font-lock-constant-face
143 c-label-face-name))
149 ;; This is considered obsolete in Emacs, but it still maps well
150 ;; to this use. (Another reason to do this is to get unique
151 ;; faces for the test suite.)
152 'font-lock-reference-face
153 c-label-face-name)))
155 ;; This should not mapped to a face that also is used to fontify things
156 ;; that aren't comments or string literals.
159 ;; XEmacs.
162 ;; Emacs 21 and later.
169 ;; If it happens to occur in the future. (Well, the more
170 ;; pragmatic reason is to get unique faces for the test
171 ;; suite.)
172 'font-lock-doc-markup-face
173 c-label-face-name))
177 ;; Emacs 22 has a special face for negation chars.
184 ;; Emacs and XEmacs have completely different face manipulation
185 ;; routines. :P
188 ;; Emacs. This only looks at the inverse flag in the current
189 ;; frame. Other display configurations might be different,
190 ;; but it can only show if the same Emacs has frames on
191 ;; e.g. a color and a monochrome display simultaneously.
195 ;; XEmacs. Same pitfall here.
200 ;; We need the following functions during compilation since they're
201 ;; called when the `c-lang-defconst' initializers are evaluated.
202 ;; Define them at runtime too for the sake of derived modes.
205 ;; Put a face on a region (overriding any existing face) in the way
206 ;; font-lock would do it. In XEmacs that means putting an
207 ;; additional font-lock property, or else the font-lock package
208 ;; won't recognize it as fontified and might override it
209 ;; incorrectly.
210 ;;
211 ;; This function does a hidden buffer change.
213 ;; Note: This function has no docstring in XEmacs so it might be
214 ;; considered internal.
219 ;; This is the inverse of `c-put-font-lock-face'.
220 ;;
221 ;; This function does a hidden buffer change.
227 ;; Put `font-lock-string-face' on a string. The surrounding
228 ;; quotes are included in Emacs but not in XEmacs. The passed
229 ;; region should include them.
230 ;;
231 ;; This function does a hidden buffer change.
237 ;; Like `let', but additionally activates `c-record-type-identifiers'
238 ;; and `c-record-ref-identifiers', and fontifies the recorded ranges
239 ;; accordingly on exit.
240 ;;
241 ;; This function does hidden buffer changes.
243 c-record-ref-identifiers
250 ;; If the point is within a region fontified as a comment or
251 ;; string literal skip to the end of it or to LIMIT, whichever
252 ;; comes first, and return t. Otherwise return nil. The match
253 ;; data is not clobbered.
254 ;;
255 ;; This function might do hidden buffer changes.
262 t))
265 ;; Returns a byte compiled function suitable for use in place of a
266 ;; regexp string in a `font-lock-keywords' matcher, except that
267 ;; only matches outside comments and string literals count.
268 ;;
269 ;; This function does not do any hidden buffer changes, but the
270 ;; generated functions will. (They are however used in places
271 ;; covered by the font-lock context.)
281 nil)))))
282 res))))
285 ;; This function makes a byte compiled function that works much like
286 ;; a matcher element in `font-lock-keywords'. It cuts out a little
287 ;; bit of the overhead compared to a real matcher. The main reason
288 ;; is however to pass the real search limit to the anchored
289 ;; matcher(s), since most (if not all) font-lock implementations
290 ;; arbitrarily limits anchored matchers to the same line, and also
291 ;; to insulate against various other irritating differences between
292 ;; the different (X)Emacs font-lock packages.
293 ;;
294 ;; REGEXP is the matcher, which must be a regexp. Only matches
295 ;; where the beginning is outside any comment or string literal are
296 ;; significant.
297 ;;
298 ;; HIGHLIGHTS is a list of highlight specs, just like in
299 ;; `font-lock-keywords', with these limitations: The face is always
300 ;; overridden (no big disadvantage, since hits in comments etc are
301 ;; filtered anyway), there is no "laxmatch", and an anchored matcher
302 ;; is always a form which must do all the fontification directly.
303 ;; `limit' is a variable bound to the real limit in the context of
304 ;; the anchored matcher forms.
305 ;;
306 ;; This function does not do any hidden buffer changes, but the
307 ;; generated functions will. (They are however used in places
308 ;; covered by the font-lock context.)
310 ;; Note: Replace `byte-compile' with `eval' to debug the generated
311 ;; lambda easier.
315 ;; `parse-sexp-lookup-properties' (when it exists).
330 "The override flag must currently be t in %s"
331 highlight))
334 "The laxmatch flag may currently not be set in %s"
335 highlight))
343 highlight))
348 highlights))))
349 nil)))
355 ;; If there are literal quoted or backquoted highlight specs in
356 ;; the call to `c-make-font-lock-search-function' then let's
357 ;; instrument the forms in them.
362 ;; Convert the ranges recorded on `c-record-type-identifiers' and
363 ;; `c-record-ref-identifiers' to fontification.
364 ;;
365 ;; This function does hidden buffer changes.
375 ;; Note that the reference face is a variable that is
376 ;; dereferenced, since it's an alias in Emacs.
378 c-reference-face-name))))
381 "Font lock matchers for preprocessor directives and purely lexical
382 stuff. Used on level 1 and higher."
384 ;; Note: `c-font-lock-declarations' assumes that no matcher here
385 ;; sets `font-lock-type-face' in languages where
386 ;; `c-recognize-<>-arglists' is set.
395 ;; fontify it as a string.
402 re
406 ;; Fontify filenames in #include <...> as strings.
413 re
417 font-lock-string-face)
419 ;; Use an anchored matcher to put paren syntax
420 ;; on the brackets.
432 nil)))))))
434 ;; #define.
438 noncontinued-line-end
445 ;; Macro with arguments - a "function".
448 ;; Macro without arguments - a "variable".
455 ;; "Function". Fontify the name and the arguments.
480 ;; "Variable".
486 ;; Fontify cpp function names in preprocessor
487 ;; expressions in #if and #elif.
497 ced-re ; 1 + ncle-depth
498 ;; Match the whole logical line to look
499 ;; for the functions in.
505 c-preprocessor-face-name)))
508 ;; Fontify the directive names.
522 c-negation-char-face-name
524 )))
527 ;; Recognize hashbangs in Pike.
531 ;; Make hard spaces visible through an inverted `font-lock-warning-face'.
539 ))
542 ;; Assuming the point is after the opening character of a string,
543 ;; fontify that char with `font-lock-warning-face' if the string
544 ;; decidedly isn't terminated properly.
545 ;;
546 ;; This function does hidden buffer changes.
551 ;; There's no multiline string start char before the
552 ;; string, so newlines aren't allowed.
554 ;; Multiline strings are allowed anywhere if
555 ;; c-multiline-string-start-char is t.
558 ;; There's no \ before the newline.
560 ;; Escaped newlines aren't supported.
561 t)
565 "Font lock matchers for basic keywords, labels, references and various
566 other easily recognizable things that should be fontified before generic
567 casts and declarations are fontified. Used on level 2 and higher."
569 ;; Note: `c-font-lock-declarations' assumes that no matcher here
570 ;; sets `font-lock-type-face' in languages where
571 ;; `c-recognize-<>-arglists' is set.
574 ;; can't span lines. Later font
575 ;; lock packages have a `font-lock-syntactic-face-function' for
576 ;; this, but it doesn't give the control we want since any
577 ;; fontification done inside the function will be
578 ;; unconditionally overridden.
580 ;; Match a char before the string starter to make
581 ;; `c-skip-comments-and-strings' work correctly.
585 ;; Fontify keyword constants.
589 ;; No symbol is a keyword after "->" in Pike.
596 ;; Fontify all keywords except the primitive types.
598 ;; No symbol is a keyword after "->" in Pike.
605 ;; Fontify leading identifiers in fully qualified names like
606 ;; "foo::bar" in languages that supports such things.
609 ;; Java needs special treatment since "." is used both to
610 ;; qualify names and in normal indexing. Here we look for
611 ;; capital characters at the beginning of an identifier to
612 ;; recognize the class. "*" is also recognized to cover
613 ;; wildcard import declarations. All preceding dot separated
614 ;; identifiers are taken as package names and therefore
615 ;; fontified as references.
617 ;; Search for class identifiers preceded by ".". The
618 ;; anchored matcher takes it from there.
638 c-reference-face-name)
640 nil
644 ;; Must use a function here since we match longer than
645 ;; we want to move before doing a new search. This is
646 ;; not necessary for XEmacs since it restarts the
647 ;; search from the end of the first highlighted
648 ;; submatch (something that causes problems in other
649 ;; places).
661 limit t)
668 c-reference-face-name))
671 ;; Fontify the special declarations in Objective-C.
679 ;; In this case we accept both primitive and known types.
686 ;; The @interface/@implementation/@protocol directives.
691 t)
695 ;; `parse-sexp-lookup-properties' (when it exists).
700 nil)
704 ))
707 ;; Called before any of the matchers in `c-complex-decl-matchers'.
708 ;; Nil is always returned.
709 ;;
710 ;; This function does hidden buffer changes.
712 ;;(message "c-font-lock-complex-decl-prepare %s %s" (point) limit)
714 ;; Clear the list of found types if we start from the start of the
715 ;; buffer, to make it easier to get rid of misspelled types and
716 ;; variables that has gotten recognized as types in malformed code.
720 ;; Clear the c-type char properties in the region to recalculate
721 ;; them properly. This is necessary e.g. to handle constructs that
722 ;; might been required as declarations temporarily during editing.
723 ;; The interesting properties are anyway those put on the closest
724 ;; token before the region.
727 ;; Update `c-state-cache' to the beginning of the region. This will
728 ;; make `c-beginning-of-syntax' go faster when it's used later on,
729 ;; and it's near the point most of the time.
732 ;; Check if the fontified region starts inside a declarator list so
733 ;; that `c-font-lock-declarators' should be called at the start.
742 nil)
745 ;; Fontify types and references in names containing angle bracket
746 ;; arglists from the point to LIMIT. Note that
747 ;; `c-font-lock-declarations' already has handled many of them. Nil
748 ;; is always returned.
749 ;;
750 ;; This function might do hidden buffer changes.
753 ;; `parse-sexp-lookup-properties' (when it exists).
758 c-restricted-<>-arglists
759 id-start id-end id-face pos kwd-sym)
771 c-restricted-<>-arglists nil
776 ;; The identifier got the type face so it has already been
777 ;; handled in `c-font-lock-declarations'.
778 nil)
782 ;; There's a special keyword before the "<" that tells
783 ;; that it's an angle bracket arglist.
787 ;; There's a normal identifier before the "<". If we're not in
788 ;; a declaration context then we set `c-restricted-<>-arglists'
789 ;; to avoid recognizing templates in function calls like "foo (a
790 ;; < b, c > d)".
796 t))
800 ;; Check for comment/string both at the identifier and
801 ;; at the "<".
812 c-reference-face-name)
818 nil)
821 ;; Assuming the point is at the start of a declarator in a
822 ;; declaration, fontify it. If LIST is non-nil, fontify also all
823 ;; following declarators in a comma separated list (e.g. "foo" and
824 ;; "bar" in "int foo = 17, bar;"). Stop at LIMIT. If TYPES is
825 ;; non-nil, fontify all identifiers as types. Nil is always
826 ;; returned.
827 ;;
828 ;; This function might do hidden buffer changes.
830 ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
833 paren-depth
834 id-face got-init
835 c-last-identifier-range
839 pos
844 ;; Skip over type decl prefix operators. (Note similar
845 ;; code in `c-forward-decl-or-cast-1'.)
849 ;; If the second submatch matches in C++ then
850 ;; we're looking at an identifier that's a
851 ;; prefix only if it specifies a member pointer.
856 ;; We only check for a trailing "::" and
857 ;; let the "*" that should follow be
858 ;; matched in the next round.
859 t
860 ;; It turned out to be the real identifier,
861 ;; so flag that and stop.
863 nil))
864 t))
872 ;; If we didn't pass the identifier above already, do it now.
880 ;; Skip out of the parens surrounding the identifier.
891 ;; Search syntactically to the end of the declarator (";",
892 ;; ",", a closen paren, eob etc) or to the beginning of an
893 ;; initializer or function prototype ("=" or "\\s\(").
894 ;; Note that the open paren will match array specs in
895 ;; square brackets, and we treat them as initializers too.
901 'font-lock-function-name-face
907 ;; Register and fontify the identifer as a type.
911 ;; Fontify the last symbol in the identifier if it isn't fontified
912 ;; already. The check is necessary only in certain cases where this
913 ;; function is used "sloppily", e.g. in `c-simple-decl-matchers'.
919 id-face)))
924 ;; Jump past any initializer or function prototype to see if
925 ;; there's a ',' to continue at.
928 ;; Skip a parenthesized initializer (C++) or a function
929 ;; prototype.
935 ;; Skip an initializer expression. If we're at a '='
936 ;; then accept a brace list directly after it to cope
937 ;; with array initializers. Otherwise stop at braces
938 ;; to avoid going past full function and class blocks.
943 t)
944 ;; FIXME: Should look for c-decl-end markers here;
945 ;; we might go far into the following declarations
946 ;; in e.g. ObjC mode (see e.g. methods-4.m).
952 ;; If a ',' is found we set pos to the next declarator and iterate.
958 nil)
961 ;; List of faces that might be put at the start of a type when
962 ;; `c-font-lock-declarations' runs. This needs to be evaluated to
963 ;; ensure that face name aliases in Emacs are resolved.
965 font-lock-type-face
966 c-reference-face-name
967 font-lock-keyword-face))
970 ;; Fontify all the declarations, casts and labels from the point to LIMIT.
971 ;; Assumes that strings and comments have been fontified already. Nil is
972 ;; always returned.
973 ;;
974 ;; This function might do hidden buffer changes.
976 ;;(message "c-font-lock-declarations search from %s to %s" (point) limit)
980 start-pos
981 ;; 'decl if we're in an arglist containing declarations (but
982 ;; if `c-recognize-paren-inits' is set it might also be an
983 ;; initializer arglist), '<> if the arglist is of angle
984 ;; bracket type, 'arglist if it's some other arglist, or nil
985 ;; if not in an arglist at all.
986 context
987 ;; The position of the next token after the closing paren of
988 ;; the last detected cast.
989 last-cast-end
990 ;; The result from `c-forward-decl-or-cast-1'.
991 decl-or-cast
992 ;; The maximum of the end positions of all the checked type
993 ;; decl expressions in the successfully identified
994 ;; declarations. The position might be either before or
995 ;; after the syntactic whitespace following the last token
996 ;; in the type decl expression.
998 ;; Same as `max-type-decl-*', but used when we're before
999 ;; `token-pos'.
1001 ;; Set according to the context to direct the heuristics for
1002 ;; recognizing C++ templates.
1003 c-restricted-<>-arglists
1004 ;; Turn on recording of identifier ranges in
1005 ;; `c-forward-decl-or-cast-1' and `c-forward-label' for
1006 ;; later fontification.
1008 c-record-ref-identifiers
1009 ;; Make `c-forward-type' calls mark up template arglists if
1010 ;; it finds any. That's necessary so that we later will
1011 ;; stop inside them to fontify types there.
1013 ;; The font-lock package in Emacs is known to clobber
1014 ;; `parse-sexp-lookup-properties' (when it exists).
1019 ;; Below we fontify a whole declaration even when it crosses the limit,
1020 ;; to avoid gaps when lazy-lock fontifies the file a screenful at a
1021 ;; time. That is however annoying during editing, e.g. the following is
1022 ;; a common situation while the first line is being written:
1023 ;;
1024 ;; my_variable
1025 ;; some_other_variable = 0;
1026 ;;
1027 ;; font-lock will put the limit at the beginning of the second line
1028 ;; here, and if we go past it we'll fontify "my_variable" as a type and
1029 ;; "some_other_variable" as an identifier, and the latter will not
1030 ;; correct itself until the second line is changed. To avoid that we
1031 ;; narrow to the limit if the region to fontify is a single line.
1036 ;; Narrow after any operator chars following the limit though,
1037 ;; since those characters can be useful in recognizing a
1038 ;; declaration (in particular the '{' that opens a function body
1039 ;; after the header).
1043 limit))
1046 limit
1047 c-decl-start-re
1048 c-font-lock-maybe-decl-faces
1053 ;; The result of the form below is true when we don't recognize a
1054 ;; declaration or cast.
1058 ;; Don't do anything more if we're looking at a keyword that
1059 ;; can't start a declaration.
1060 t
1062 ;; Set `context'. Look for "<" for the sake of C++-style template
1063 ;; arglists.
1066 ;; Find out the type of the arglist.
1071 ;; Got a cached hit in a declaration arglist.
1075 ;; Inside an angle bracket arglist.
1078 ;; Got a cached hit in some other type of arglist.
1083 ;; The point is within the range of a previously
1084 ;; encountered type decl expression, so the arglist
1085 ;; is probably one that contains declarations.
1086 ;; However, if `c-recognize-paren-inits' is set it
1087 ;; might also be an initializer arglist.
1089 ;; The result of this check is cached with a char
1090 ;; property on the match token, so that we can look
1091 ;; it up again when refontifying single lines in a
1092 ;; multiline declaration.
1100 ;; If we're in a normal arglist context we don't want to
1101 ;; recognize commas in nested angle bracket arglists since
1102 ;; those commas could be part of our own arglist.
1106 ;; Now analyze the construct.
1108 match-pos context last-cast-end))
1111 ;; False alarm. Return t to go on to the next check.
1112 t
1115 ;; Save the position after the previous cast so we can feed
1116 ;; it to `c-forward-decl-or-cast-1' in the next round. That
1117 ;; helps it discover cast chains like "(a) (b) c".
1120 ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
1121 ;; under the assumption that we're after the first type decl
1122 ;; expression in the declaration now. That's not really true;
1123 ;; we could also be after a parenthesized initializer
1124 ;; expression in C++, but this is only used as a last resort
1125 ;; to slant ambiguous expression/declarations, and overall
1126 ;; it's worth the risk to occasionally fontify an expression
1127 ;; as a declaration in an initializer expression compared to
1128 ;; getting ambiguous things in normal function prototypes
1129 ;; fontified as expressions.
1136 ;; Back up to the type to fontify the declarator(s).
1141 ;; Should normally not fontify a list of
1142 ;; declarators inside an arglist, but the first
1143 ;; argument in the ';' separated list of a "for"
1144 ;; statement is an exception.
1151 t)))
1153 ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
1154 ;; before the first declarator if it's a list.
1155 ;; `c-font-lock-declarators' handles the rest.
1162 'c-decl-type-start
1168 ;; A cast or declaration has been successfully identified, so do
1169 ;; all the fontification of types and refs that's been recorded.
1171 nil))
1173 ;; It was a false alarm. Check if we're in a label instead.
1176 ;; Can't use `c-fontify-types-and-refs' here since we
1177 ;; should use the label face.
1183 c-label-face-name)))
1184 ;; `c-forward-label' probably has added a `c-decl-end'
1185 ;; marker, so return t to `c-find-decl-spots' to signal
1186 ;; that.
1187 t))))
1189 nil)))
1192 "Simple font lock matchers for types and declarations. These are used
1193 on level 2 only and so aren't combined with `c-complex-decl-matchers'."
1201 ;; `parse-sexp-lookup-properties' (when it exists).
1208 nil))
1211 ;; Fontify all type names and the identifiers in the
1212 ;; declarations they might start. Use eval here since
1213 ;; `c-known-type-key' gets its value from
1214 ;; `*-font-lock-extra-types' on mode init.
1216 'c-known-type-key
1224 ;; Fontify types preceded by `c-type-prefix-kwds' and the
1225 ;; identifiers in the declarations they might start.
1238 `(,type-match
1246 ;; Fontify special declarations that lacks a type.
1258 ;; Fontify generic colon labels in languages that support them.
1263 "Complex font lock matchers for types and declarations. Used on level
1264 3 and higher."
1267 c-font-lock-complex-decl-prepare
1270 ;; Fontify method declarations in Objective-C, but first
1271 ;; we have to put the `c-decl-end' `c-type' property on
1272 ;; all the @-style directives that haven't been handled in
1273 ;; `c-basic-matchers-before'.
1276 ;; Exclude "@class" since that directive ends with a
1277 ;; semicolon anyway.
1281 nil)))
1284 c-font-lock-objc-methods))
1286 ;; Fontify all declarations, casts and normal labels.
1287 c-font-lock-declarations
1289 ;; Fontify angle bracket arglists like templates in C++.
1293 ;; The first two rules here mostly find occurences that
1294 ;; `c-font-lock-declarations' has found already, but not
1295 ;; declarations containing blocks in the type (see note below).
1296 ;; It's also useful to fontify these everywhere to show e.g. when
1297 ;; a type keyword is accidentally used as an identifier.
1299 ;; Fontify basic types.
1303 ;; No symbol is a keyword after "->" in Pike.
1310 ;; Fontify types preceded by `c-type-prefix-kwds'.
1316 ;; The font-lock package in Emacs is known to clobber
1317 ;; `parse-sexp-lookup-properties' (when it exists).
1322 ;; Narrow to avoid going past the limit in
1323 ;; `c-forward-type'.
1330 limit t)
1333 ;; Handle prefix declaration specifiers.
1339 ;; In C++ we additionally check for a "class
1340 ;; X = Y" construct which is used in
1341 ;; templates, to fontify Y as a type.
1346 )))))))))
1348 ;; Fontify symbols after closing braces as declaration
1349 ;; identifiers under the assumption that they are part of
1350 ;; declarations like "class Foo { ... } foo;". It's too
1351 ;; expensive to check this accurately by skipping past the
1352 ;; brace block, so we use the heuristic that it's such a
1353 ;; declaration if the first identifier is on the same line as
1354 ;; the closing brace. `c-font-lock-declarations' will later
1355 ;; override it if it turns out to be an new declaration, but
1356 ;; it will be wrong if it's an expression (see the test
1357 ;; decls-8.cc).
1373 c-single-line-syntactic-ws-depth)))))
1376 ;; Fontify the type in C++ "new" expressions.
1380 ))
1383 ;; Fontify all statement labels from the point to LIMIT. Assumes
1384 ;; that strings and comments have been fontified already. Nil is
1385 ;; always returned.
1386 ;;
1387 ;; Note: This function is only used on decoration level 2; this is
1388 ;; taken care of directly by the gargantuan
1389 ;; `c-font-lock-declarations' on higher levels.
1390 ;;
1391 ;; This function might do hidden buffer changes.
1394 ;; The font-lock package in Emacs is known to clobber
1395 ;; `parse-sexp-lookup-properties' (when it exists).
1414 ;; Check for a char that precedes a statement.
1416 ;; Check for a preceding label. We exploit the font
1417 ;; locking made earlier by this function.
1424 c-label-face-name))
1425 ;; Check for a keyword that precedes a statement.
1429 ;; Got a label.
1433 c-label-face-name)))
1436 nil)
1439 "Font lock matchers for various things that should be fontified after
1440 generic casts and declarations are fontified. Used on level 2 and
1441 higher."
1444 ;; name is handled by `c-simple-decl-matchers' or
1445 ;; `c-complex-decl-matchers' below.
1452 ;; Disallow various common punctuation chars that can't come
1453 ;; before the '{' of the enum list, to avoid searching too far.
1454 "[^\]\[{}();,/#=]*"
1464 ;; Fontify labels after goto etc.
1467 ;; which makes it a bit complicated: 1) The backquote
1468 ;; stuff is expanded when compiled or loaded, 2) the
1469 ;; eval form is evaluated at font-lock setup (to
1470 ;; substitute c-label-face-name correctly), and 3) the
1471 ;; resulting structure is interpreted during
1472 ;; fontification.)
1484 c-label-face-name nil t))))))
1486 ;; Fontify the clauses after various keywords.
1502 ))
1520 ;; Incorporate the font lock keyword lists according to
1521 ;; `c-doc-comment-style' on the given keyword list and return it.
1522 ;; This is used in the function bindings of the
1523 ;; `*-font-lock-keywords-*' symbols since we have to build the list
1524 ;; when font-lock is initialized.
1533 c-doc-comment-style))
1545 doc-keywords
1547 base-list)))
1549 ;; Kludge: If `c-font-lock-complex-decl-prepare' is on the list we
1550 ;; move it first since the doc comment font lockers might add
1551 ;; `c-type' text properties, so they have to be cleared before that.
1557 list))
1560 ;; This is used to override the value on a `*-font-lock-keywords'
1561 ;; variable only if it's nil or has the same value as one of the
1562 ;; `*-font-lock-keywords-*' variables. Older font-lock packages
1563 ;; define a default value for `*-font-lock-keywords' which we want
1564 ;; to override, but we should otoh avoid clobbering a user setting.
1565 ;; This heuristic for that isn't perfect, but I can't think of any
1566 ;; better. /mast
1573 suffix))))
1576 ;; The overriding is done by unbinding the variable so that the normal
1577 ;; defvar will install its default value later on.
1580 \f
1581 ;;; C.
1586 "Minimal font locking for C mode.
1587 Fontifies only preprocessor directives (in addition to the syntactic
1591 "Fast normal font locking for C mode.
1592 In addition to `c-font-lock-keywords-1', this adds fontification of
1593 keywords, simple types, declarations that are easy to recognize, the
1594 user defined types on `c-font-lock-extra-types', and the doc comment
1598 "Accurate normal font locking for C mode.
1599 Like `c-font-lock-keywords-2' but detects declarations in a more
1600 accurate way that works in most cases for arbitrary types without the
1613 \f
1614 ;;; C++.
1617 ;; Assuming point is after a "new" word, check that it isn't inside
1618 ;; a string or comment, and if so try to fontify the type in the
1619 ;; allocation expression. Nil is always returned.
1620 ;;
1621 ;; As usual, C++ takes the prize in coming up with a hard to parse
1622 ;; syntax. :P
1623 ;;
1624 ;; This function might do hidden buffer changes.
1629 ;; A "new" keyword is followed by one to three expressions, where
1630 ;; the type is the middle one, and the only required part.
1632 ;; Enable recording of identifier ranges in `c-forward-type'
1633 ;; etc for later fontification. Not using
1634 ;; `c-fontify-types-and-refs' here since the ranges should
1635 ;; be fontified selectively only when an allocation
1636 ;; expression is successfully recognized.
1638 c-record-ref-identifiers
1639 ;; The font-lock package in Emacs is known to clobber
1640 ;; `parse-sexp-lookup-properties' (when it exists).
1646 ;; The first placement arglist is always parenthesized, if it
1647 ;; exists.
1655 ;; The second expression is either a type followed by some "*" or
1656 ;; "[...]" or similar, or a parenthesized type followed by a full
1657 ;; identifierless declarator.
1667 ;; No second expression, so the first has to be a
1668 ;; parenthesized type.
1674 ;; Got two parenthesized expressions, so we have to look
1675 ;; closer at them to decide which is the type. No need to
1676 ;; handle `c-record-ref-identifiers' since all references
1677 ;; has already been handled by other fontification rules.
1686 ;; There's something after the would-be type that
1687 ;; can't be there, so this is a placement arglist.
1696 ;; There's something after the would-be type that can't
1697 ;; be there, so this is an initialization expression.
1702 ;; If there's a third initialization expression
1703 ;; then the second one is the type, so demote the
1704 ;; first match.
1707 ;; We fontify the most likely type, with a preference for
1708 ;; the first argument since a placement arglist is more
1709 ;; unusual than an initializer.
1728 ;; If both type matches are 'maybe then we're
1729 ;; too uncertain to promote either of them.
1730 )))))
1732 ;; Fontify the type that now is recorded in
1733 ;; `c-record-type-identifiers', if any.
1735 nil)
1740 "Minimal font locking for C++ mode.
1741 Fontifies only preprocessor directives (in addition to the syntactic
1745 "Fast normal font locking for C++ mode.
1746 In addition to `c++-font-lock-keywords-1', this adds fontification of
1747 keywords, simple types, declarations that are easy to recognize, the
1748 user defined types on `c++-font-lock-extra-types', and the doc comment
1752 "Accurate normal font locking for C++ mode.
1753 Like `c++-font-lock-keywords-2' but detects declarations in a more
1754 accurate way that works in most cases for arbitrary types without the
1767 \f
1768 ;;; Objective-C.
1771 ;; Assuming the point is after the + or - that starts an Objective-C
1772 ;; method declaration, fontify it. This must be done before normal
1773 ;; casts, declarations and labels are fontified since they will get
1774 ;; false matches in these things.
1775 ;;
1776 ;; This function might do hidden buffer changes.
1786 ;; An optional method type.
1794 t))
1796 ;; The name. The first time it's the first part of
1797 ;; the function name, the rest of the time it's an
1798 ;; argument name.
1805 'font-lock-function-name-face
1809 ;; Another optional part of the function name.
1817 ;; There's another argument if a colon follows.
1823 ;; Fontify method declarations in Objective-C. Nil is always
1824 ;; returned.
1825 ;;
1826 ;; This function might do hidden buffer changes.
1829 ;; `parse-sexp-lookup-properties' (when it exists).
1835 limit
1836 "[-+]"
1837 nil
1841 nil)
1846 "Minimal font locking for Objective-C mode.
1847 Fontifies only compiler directives (in addition to the syntactic
1851 "Fast normal font locking for Objective-C mode.
1852 In addition to `objc-font-lock-keywords-1', this adds fontification of
1853 keywords, simple types, declarations that are easy to recognize, the
1854 user defined types on `objc-font-lock-extra-types', and the doc
1858 "Accurate normal font locking for Objective-C mode.
1859 Like `objc-font-lock-keywords-2' but detects declarations in a more
1860 accurate way that works in most cases for arbitrary types without the
1873 ;; Kludge to override the default value that
1874 ;; `objc-font-lock-extra-types' might have gotten from the font-lock
1875 ;; package. The value replaced here isn't relevant now anyway since
1876 ;; those types are builtin and therefore listed directly in
1877 ;; `c-primitive-type-kwds'.
1883 \f
1884 ;;; Java.
1889 "Minimal font locking for Java mode.
1890 Fontifies nothing except the syntactic fontification of strings and
1894 "Fast normal font locking for Java mode.
1895 In addition to `java-font-lock-keywords-1', this adds fontification of
1896 keywords, simple types, declarations that are easy to recognize, the
1897 user defined types on `java-font-lock-extra-types', and the doc
1901 "Accurate normal font locking for Java mode.
1902 Like `java-font-lock-keywords-2' but detects declarations in a more
1903 accurate way that works in most cases for arbitrary types without the
1916 \f
1917 ;;; CORBA IDL.
1922 "Minimal font locking for CORBA IDL mode.
1923 Fontifies nothing except the syntactic fontification of strings and
1927 "Fast normal font locking for CORBA IDL mode.
1928 In addition to `idl-font-lock-keywords-1', this adds fontification of
1929 keywords, simple types, declarations that are easy to recognize, the
1930 user defined types on `idl-font-lock-extra-types', and the doc comment
1934 "Accurate normal font locking for CORBA IDL mode.
1935 Like `idl-font-lock-keywords-2' but detects declarations in a more
1936 accurate way that works in most cases for arbitrary types without the
1949 \f
1950 ;;; Pike.
1955 "Minimal font locking for Pike mode.
1956 Fontifies only preprocessor directives (in addition to the syntactic
1960 "Fast normal font locking for Pike mode.
1961 In addition to `pike-font-lock-keywords-1', this adds fontification of
1962 keywords, simple types, declarations that are easy to recognize, the
1963 user defined types on `pike-font-lock-extra-types', and the doc
1967 "Accurate normal font locking for Pike mode.
1968 Like `pike-font-lock-keywords-2' but detects declarations in a more
1969 accurate way that works in most cases for arbitrary types without the
1982 \f
1983 ;;; Doc comments.
1986 ;; Fontify the comments between the point and LIMIT whose start
1987 ;; matches PREFIX with `c-doc-face-name'. Assumes comments have been
1988 ;; fontified with `font-lock-comment-face' already. nil is always
1989 ;; returned.
1990 ;;
1991 ;; After the fontification of a matching comment, fontification
1992 ;; according to KEYWORDS is applied inside it. It's a list like
1993 ;; `font-lock-keywords' except that anchored matches and eval
1994 ;; clauses aren't supported and that some abbreviated forms can't be
1995 ;; used. The buffer is narrowed to the comment while KEYWORDS is
1996 ;; applied; leading comment starters are included but trailing
1997 ;; comment enders for block comment are not.
1998 ;;
1999 ;; Note that faces added through KEYWORDS should never replace the
2000 ;; existing `c-doc-face-name' face since the existence of that face
2001 ;; is used as a flag in other code to skip comments.
2002 ;;
2003 ;; This function might do hidden buffer changes.
2008 ;; Handle the case when the fontified region starts inside a
2009 ;; comment.
2018 comment-beg
2020 ;; Search for the prefix until a match is found at the start
2021 ;; of a comment.
2025 c-literal-faces))
2028 c-literal-faces))))
2033 ;; Collect a sequence of doc style line comments.
2050 ;; Narrow to the doc comment. Among other things, this
2051 ;; helps by making "^" match at the start of the comment.
2052 ;; Do not include a trailing block comment ender, though.
2076 nil)
2080 ;; Used to fontify invalid markup in doc comments after the correct
2081 ;; ones have been fontified: Find the first occurence of REGEXP
2082 ;; between the point and LIMIT that only is fontified with
2083 ;; `c-doc-face-name'. If a match is found then submatch 0 surrounds
2084 ;; the first char and t is returned, otherwise nil is returned.
2085 ;;
2086 ;; This function might do hidden buffer changes.
2091 c-doc-face-name))
2096 t)))
2098 ;; GtkDoc patterns contributed by Masatake YAMATO <jet@gyve.org>.
2111 ))
2120 gtkdoc-font-lock-doc-comments)
2122 gtkdoc-font-lock-doc-protection)
2123 ))))
2125 ;; Javadoc.
2140 ;; Fontify remaining markup characters as invalid. Note
2141 ;; that the Javadoc spec is hazy about when "@" is
2142 ;; allowed in non-markup use.
2150 javadoc-font-lock-doc-comments)))))
2152 ;; Pike autodoc.
2155 ;; Adorned regexp matching the keywords that introduce declarations
2156 ;; in Pike Autodoc.
2161 ;; Adorned regexp matching the keywords that are followed by a type.
2166 ;; Fontify all line oriented keywords between the point and LIMIT.
2167 ;; Nil is always returned.
2168 ;;
2169 ;; This function might do hidden buffer changes.
2172 c-current-comment-prefix
2183 end)
2187 ;; Put a declaration end mark at the markup keyword and
2188 ;; remove the faces from the rest of the line so that it
2189 ;; gets refontified as a declaration later on by
2190 ;; `c-font-lock-declarations'.
2206 ;; Include the final newline in the removed area. This
2207 ;; has no visual effect but it avoids some tricky special
2208 ;; cases in the testsuite wrt the differences in string
2209 ;; fontification in Emacs vs XEmacs.
2212 ;; Must handle string literals explicitly inside the declaration.
2220 ;; Fontify types after keywords that always are followed
2221 ;; by them.
2229 ;; Mark each whole line as markup, as long as the logical line
2230 ;; continues.
2234 markup-faces)
2242 nil)
2246 ;; In-text markup.
2249 ;; Fontify remaining markup characters as invalid.
2253 ))
2256 ;; Note that we depend on that `c-current-comment-prefix' has got
2257 ;; its proper value here.
2258 ;;
2259 ;; This function might do hidden buffer changes.
2261 ;; The `c-type' text property with `c-decl-end' is used to mark the
2262 ;; end of the `autodoc-decl-keywords' occurrences to fontify the
2263 ;; following declarations.
2268 autodoc-font-lock-doc-comments)))))
2270 \f
2271 ;; AWK.
2273 ;; Awk regexps written with help from Peter Galbraith
2274 ;; <galbraith@mixing.qc.dfo.ca>.
2275 ;; Take GNU Emacs's 'words out of the following regexp-opts. They dont work
2276 ;; in Xemacs 21.4.4. acm 2002/9/19.
2281 ;; Function names.
2284 ;;
2285 ;; Variable names.
2295 ;; Special file names. (acm, 2002/7/22)
2296 ;; The following regexp was created by first evaluating this in GNU Emacs 21.1:
2297 ;; (regexp-opt '("/dev/stdin" "/dev/stdout" "/dev/stderr" "/dev/fd/n" "/dev/pid"
2298 ;; "/dev/ppid" "/dev/pgrpid" "/dev/user") 'words)
2299 ;; , removing the "?:" from each "\\(?:" (for backward compatibility with older Emacsen)
2300 ;; , replacing the "n" in "dev/fd/n" with "[0-9]+"
2301 ;; , removing the unwanted \\< at the beginning, and finally filling out the
2302 ;; regexp so that a " must come before, and either a " or heuristic stuff after.
2303 ;; The surrounding quotes are fontified along with the filename, since, semantically,
2304 ;; they are an indivisible unit.
2310 ;; Do the same (almost) with
2311 ;; (regexp-opt '("/inet/tcp/lport/rhost/rport" "/inet/udp/lport/rhost/rport"
2312 ;; "/inet/raw/lport/rhost/rport") 'words)
2313 ;; This cannot be combined with the above pattern, because the match number
2314 ;; for the (optional) closing \" would then exceed 9.
2320 ;; Keywords.
2328 ;; Builtins.
2343 ;; gawk debugging keywords. (acm, 2002/7/21)
2344 ;; (Removed, 2003/6/6. These functions are now fontified as built-ins)
2345 ;; (list (concat "\\<" (regexp-opt '("adump" "stopme") t) "\\>")
2346 ;; 0 'font-lock-warning-face)
2348 ;; User defined functions with an apparent spurious space before the
2349 ;; opening parenthesis. acm, 2002/5/30.
2354 ;; Space after \ in what looks like an escaped newline. 2002/5/31
2357 ;; Unbalanced string (") or regexp (/) delimiters. 2002/02/16.
2359 ;; gawk 3.1 localizable strings ( _"translate me!"). 2002/5/21
2362 ))
2365 \f
2368 ;;; arch-tag: 2f65f405-735f-4da5-8d4b-b957844c5203
2369 ;;; cc-fonts.el ends here