| blob | e78ec2c508d730d12bc0a7fc7ce3c2ea1463fb60 |
1 ;;; cc-fonts.el --- font lock support for CC Mode
3 ;; Copyright (C) 2002, 2003, 2005 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., 59 Temple Place - Suite 330,
27 ;; Boston, MA 02111-1307, 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 Emacs
34 ;; 20 and later), 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 ;; o `c-invalid-face-name' is `font-lock-warning-face' in Emacs. In
51 ;; older XEmacs there's no corresponding standard face, so there
52 ;; it's mapped to a special `c-invalid-face'.
53 ;;
54 ;; TBD: We should probably provide real faces for the above uses and
55 ;; instead initialize them from the standard faces.
57 ;;; Code:
59 ;; The faces that already have been put onto the text is tested in
60 ;; various places to direct further fontifications. For this to work,
61 ;; the following assumptions regarding the faces must hold (apart from
62 ;; the dependencies on the font locking order):
63 ;;
64 ;; o `font-lock-comment-face' and the face in `c-doc-face-name' is
65 ;; not used in anything but comments.
66 ;; o If any face (e.g. `c-doc-markup-face-name') but those above is
67 ;; used in comments, it doesn't replace them.
68 ;; o `font-lock-string-face' is not used in anything but string
69 ;; literals (single or double quoted).
70 ;; o `font-lock-keyword-face' and the face in `c-label-face-name' are
71 ;; never overlaid with other faces.
78 load-path)))
86 ;; prevent cc-awk being loaded when it's not needed. There is now a (require
87 ;; 'cc-awk) in (defun awk-mode ..).
89 ;; Avoid repeated loading through the eval-after-load directive in
90 ;; cc-mode.el.
97 ;; Need to declare these local symbols during compilation since
98 ;; they're referenced from lambdas in `byte-compile' calls that are
99 ;; executed at compile time. They don't need to have the proper
100 ;; definitions, though, since the generated functions aren't called
101 ;; during compilation.
110 ;; Emacs 19 doesn't have `defface'. This "replacement" leaves a lot
111 ;; to be wished for but at least it avoids any errors.
117 \f
118 ;; Note that font-lock in XEmacs doesn't expand face names as
119 ;; variables, so we have to use the (eval . FORM) in the font lock
120 ;; matchers wherever we use these alias variables.
124 ;; XEmacs has a font-lock-preprocessor-face.
127 ;; In Emacs 20 and later font-lock-builtin-face has
128 ;; traditionally been used for preprocessor directives.
137 ;; If it happens to occur in the future. (Well, the more
138 ;; pragmatic reason is to get unique faces for the test
139 ;; suite.)
143 ;; Test both if font-lock-constant-face exists and that it's
144 ;; not an alias for something else. This is important since
145 ;; we compare already set faces in various places.
153 ;; This doesn't exist in XEmacs <= 20 and some earlier versions
154 ;; of XEmacs 21.
155 'font-lock-constant-face
156 c-label-face-name))
161 ;; This is considered obsolete in Emacs 20 and later, but it
162 ;; still maps well to this use. (Another reason to do this is
163 ;; to get unique faces for the test suite.)
164 'font-lock-reference-face
165 c-label-face-name))
167 ;; This should not mapped to a face that also is used to fontify things
168 ;; that aren't comments or string literals.
171 ;; XEmacs.
174 ;; Emacs 21 and later.
181 ;; If it happens to occur in the future. (Well, the more
182 ;; pragmatic reason is to get unique faces for the test
183 ;; suite.)
184 'font-lock-doc-markup-face
185 c-label-face-name))
189 ;; Emacs >= 20 and XEmacs >= 21 has a font-lock-warning-face.
190 'font-lock-warning-face
191 ;; Otherwise we provide a face.
196 ;; This face should be called `c-invalid' for consistency with the
197 ;; rest of emacs, but as it's only used in very old versions of Emacs,
198 ;; we leave it unchanged (the face-alias mechanism doesn't exist in
199 ;; those old versions).
204 "Face used to highlight invalid syntax."
207 ;; To make hard spaces visible an inverted version of
208 ;; `c-invalid-face-name' is used. Since font-lock in Emacs expands
209 ;; all face names in `font-lock-keywords' as variables we need to have
210 ;; a variable for it.
217 ;; Emacs and XEmacs have completely different face manipulation
218 ;; routines. :P
219 ;;
220 ;; This function does not do any hidden buffer changes
223 ;; Emacs 20 and later. This only looks at the inverse flag
224 ;; in the current frame. Other display configurations might
225 ;; be different, but it can only show if the same Emacs has
226 ;; frames on e.g. a color and a monochrome display
227 ;; simultaneously.
231 ;; XEmacs. Same pitfall here.
235 ;; Emacs 19 has no inverse flag at all. Just inverse the
236 ;; face and hope it wasn't inversed already.
240 ;; We need the following functions during compilation since they're
241 ;; called when the `c-lang-defconst' initializers are evaluated.
242 ;; Define them at runtime too for the sake of derived modes.
245 ;; Put a face on a region (overriding any existing face) in the way
246 ;; font-lock would do it. In XEmacs that means putting an
247 ;; additional font-lock property, or else the font-lock package
248 ;; won't recognize it as fontified and might override it
249 ;; incorrectly.
251 ;; Note: This function has no docstring in XEmacs so it might be
252 ;; considered internal.
257 ;; This is the inverse of `c-put-font-lock-face'.
263 ;; Put `font-lock-string-face' on a string. The surrounding
264 ;; quotes are included in Emacs but not in XEmacs. The passed
265 ;; region should include them.
271 ;; Like `let', but additionally activates `c-record-type-identifiers'
272 ;; and `c-record-ref-identifiers', and fontifies the recorded ranges
273 ;; accordingly on exit.
275 c-record-ref-identifiers
283 ;; If the point is within a region fontified as a comment or
284 ;; string literal skip to the end of it or to LIMIT, whichever
285 ;; comes first, and return t. Otherwise return nil. The match
286 ;; data is not clobbered.
293 t))
296 ;; This function makes a byte compiled function that works much like
297 ;; a matcher element in `font-lock-keywords'. It cuts out a little
298 ;; bit of the overhead compared to a real matcher. The main reason
299 ;; is however to pass the real search limit to the anchored
300 ;; matcher(s), since most (if not all) font-lock implementations
301 ;; arbitrarily limits anchored matchers to the same line, and also
302 ;; to insulate against various other irritating differences between
303 ;; the different (X)Emacs font-lock packages.
304 ;;
305 ;; REGEXP is the matcher, which must be a regexp. Only matches
306 ;; where the beginning is outside any comment or string literal are
307 ;; significant.
308 ;;
309 ;; HIGHLIGHTS is a list of highlight specs, just like in
310 ;; `font-lock-keywords', with these limitations: The face is always
311 ;; overridden (no big disadvantage, since hits in comments etc are
312 ;; filtered anyway), there is no "laxmatch", and an anchored matcher
313 ;; is always a form which must do all the fontification directly.
314 ;; `limit' is a variable bound to the real limit in the context of
315 ;; the anchored matcher forms.
316 ;;
317 ;; This function does not do any hidden buffer changes, but the
318 ;; generated functions will. They are however used in places
319 ;; covered by the font-lock context.
321 ;; Note: Replace `byte-compile' with `eval' to debug the generated
322 ;; lambda easier.
326 ;; The font-lock package in Emacs is known to clobber
327 ;; `parse-sexp-lookup-properties' (when it exists).
343 "The override flag must currently be set in %s"
344 highlight))
347 "The laxmatch flag may currently not be set in %s"
348 highlight))
356 highlight))
361 highlights))))
362 nil))))
365 ;; Converts the ranges recorded on `c-record-type-identifiers' and
366 ;; `c-record-ref-identifiers' to fontification.
376 ;; Note that the reference face is a variable that is
377 ;; dereferenced, since it's an alias in Emacs.
379 c-reference-face-name))))
382 "Font lock matchers for preprocessor directives and purely lexical
383 stuff. Used on level 1 and higher."
385 ;; Note: `c-font-lock-declarations' assumes that no matcher here
386 ;; sets `font-lock-type-face' in languages where
387 ;; `c-recognize-<>-arglists' is set.
394 ;; fontify it as a string.
400 ;; Fontify filenames in #include <...> as strings.
407 font-lock-string-face)
409 ;; Use an anchored matcher to put paren syntax on the brackets.
421 nil))))
423 ;; #define.
426 noncontinued-line-end
432 ;; Macro with arguments - a "function".
435 ;; Macro without arguments - a "variable".
440 ;; "Function". Fontify the name and the arguments.
464 ;; "Variable".
470 ;; Fontify cpp function names in preprocessor
471 ;; expressions in #if and #elif.
477 ;; Match the whole logical line to look
478 ;; for the functions in.
485 nil)
491 c-preprocessor-face-name)))
494 ;; Fontify the directive names.
503 ;; fontify the n in ifndef
508 )))
514 ;; Make hard spaces visible through an inverted `c-invalid-face-name'.
520 c-nonbreakable-space-face))
522 ))
525 ;; Assuming the point is after the opening character of a string,
526 ;; fontify that char with `c-invalid-face-name' if the string
527 ;; decidedly isn't terminated properly.
532 ;; There's no \ before the newline.
534 ;; Quoted newlines aren't supported.
535 t)
537 ;; There's no # before the string, so newlines
538 ;; aren't allowed.
540 t)
544 "Font lock matchers for basic keywords, labels, references and various
545 other easily recognizable things that should be fontified before generic
546 casts and declarations are fontified. Used on level 2 and higher."
548 ;; Note: `c-font-lock-declarations' assumes that no matcher here
549 ;; sets `font-lock-type-face' in languages where
550 ;; `c-recognize-<>-arglists' is set.
553 ;; can't span lines. Later font
554 ;; lock packages have a `font-lock-syntactic-face-function' for
555 ;; this, but it doesn't give the control we want since any
556 ;; fontification done inside the function will be
557 ;; unconditionally overridden.
559 ;; Match a char before the string starter to make
560 ;; `c-skip-comments-and-strings' work correctly.
564 ;; Fontify keyword constants.
568 ;; No symbol is a keyword after "->" in Pike.
575 ;; Fontify all keywords except the primitive types.
577 ;; No symbol is a keyword after "->" in Pike.
584 ;; Fontify leading identifiers in fully qualified names like
585 ;; "foo::bar" in languages that supports such things.
588 ;; Java needs special treatment since "." is used both to
589 ;; qualify names and in normal indexing. Here we look for
590 ;; capital characters at the beginning of an identifier to
591 ;; recognize the class. "*" is also recognized to cover
592 ;; wildcard import declarations. All preceding dot separated
593 ;; identifiers are taken as package names and therefore
594 ;; fontified as references.
596 ;; Search for class identifiers preceded by ".". The
597 ;; anchored matcher takes it from there.
617 nil
621 ;; Must use a function here since we match longer than we
622 ;; want to move before doing a new search. This is not
623 ;; necessary for XEmacs >= 20 since it restarts the search
624 ;; from the end of the first highlighted submatch (something
625 ;; that causes problems in other places).
637 limit t)
644 c-reference-face-name))
647 ;; Fontify the special declarations in Objective-C.
655 ;; In this case we accept both primitive and known types.
662 ;; The @interface/@implementation/@protocol directives.
666 t)
671 ;; `parse-sexp-lookup-properties' (when it exists).
678 nil))))))
681 ))
684 ;; Called before any of the matchers in `c-complex-decl-matchers'.
685 ;; Nil is always returned.
687 ;;(message "c-font-lock-complex-decl-prepare %s %s" (point) limit)
689 ;; Clear the list of found types if we start from the start of the
690 ;; buffer, to make it easier to get rid of misspelled types and
691 ;; variables that has gotten recognized as types in malformed code.
695 ;; Clear the c-type char properties in the region to recalculate
696 ;; them properly. This is necessary e.g. to handle constructs that
697 ;; might been required as declarations temporarily during editing.
698 ;; The interesting properties are anyway those put on the closest
699 ;; token before the region.
702 ;; Update `c-state-cache' to the beginning of the region. This will
703 ;; make `c-beginning-of-syntax' go faster when it's used later on,
704 ;; and it's near the point most of the time.
707 ;; Check if the fontified region starts inside a declarator list so
708 ;; that `c-font-lock-declarators' should be called at the start.
717 nil)
720 ;; Fontify types and references in names containing angle bracket
721 ;; arglists from the point to LIMIT. This will also fontify cases
722 ;; like normal function calls on the form "foo (a < b, c > d)", but
723 ;; `c-font-lock-declarations' will undo that later. Nil is always
724 ;; returned.
727 ;; `parse-sexp-lookup-properties' (when it exists).
731 id-start id-end pos kwd-sym)
749 ;; Check for comment/string both at the identifier and
750 ;; at the "<".
755 t)
761 c-reference-face-name)
767 nil)
770 ;; Assuming the point is at the start of a declarator in a
771 ;; declaration, fontify it. If LIST is non-nil, fontify also all
772 ;; following declarators in a comma separated list (e.g. "foo" and
773 ;; "bar" in "int foo = 17, bar;"). Stop at LIMIT. If TYPES is
774 ;; non-nil, fontify all identifiers as types. Nil is always
775 ;; returned.
777 ;;(message "c-font-lock-declarators from %s to %s" (point) limit)
780 paren-depth
781 id-face got-init
782 c-last-identifier-range
786 pos
791 ;; Skip over type decl prefix operators. (Note similar
792 ;; code in `c-font-lock-declarations'.)
796 ;; If the second submatch matches in C++ then
797 ;; we're looking at an identifier that's a
798 ;; prefix only if it specifies a member pointer.
803 ;; We only check for a trailing "::" and
804 ;; let the "*" that should follow be
805 ;; matched in the next round.
806 t
807 ;; It turned out to be the real identifier,
808 ;; so flag that and stop.
810 nil))
811 t))
819 ;; If we didn't pass the identifier above already, do it now.
827 ;; Skip out of the parens surrounding the identifier.
833 ;; Search syntactically to the end of the declarator (";",
834 ;; ",", a closen paren, eob etc) or to the beginning of an
835 ;; initializer or function prototype ("=" or "\\s\(").
836 ;; Note that the open paren will match array specs in
837 ;; square brackets, and we treat them as initializers too.
843 'font-lock-function-name-face
849 ;; Register and fontify the identifer as a type.
853 ;; Fontify the last symbol in the identifier if it isn't fontified
854 ;; already. The check is necessary only in certain cases where this
855 ;; function is used "sloppily", e.g. in `c-simple-decl-matchers'.
861 id-face)))
866 ;; Jump past any initializer or function prototype to see if
867 ;; there's a ',' to continue at.
870 ;; Skip a parenthesized initializer (C++) or a function
871 ;; prototype.
877 ;; Skip an initializer expression. If we're at a '='
878 ;; then accept a brace list directly after it to cope
879 ;; with array initializers. Otherwise stop at braces
880 ;; to avoid going past full function and class blocks.
885 t)
891 ;; If a ',' is found we set pos to the next declarator and iterate.
897 nil)
900 ;; List of faces that might be put at the start of a type when
901 ;; `c-font-lock-declarations' runs. This needs to be evaluated to
902 ;; ensure that face name aliases in Emacs are resolved.
904 font-lock-type-face
905 c-reference-face-name
906 font-lock-keyword-face))
908 ;; Macro used inside `c-font-lock-declarations'. It ought to be a
909 ;; defsubst or perhaps even a defun, but it contains lots of free
910 ;; variables that refer to things inside `c-font-lock-declarations'.
912 ;; `c-font-lock-declarations' can consume an arbitrary length list
913 ;; of types when parsing a declaration, which means that it
914 ;; sometimes consumes the identifier in the declaration as a type.
915 ;; This is used to "backtrack" and make the last type be treated
916 ;; as an identifier instead.
919 ;; These identifiers are bound only in the inner let.
921 identifier-start type-start
922 identifier-end type-end))
924 t
925 prev-at-type))
927 type-end prev-type-end)
929 type-end start-pos))
931 ;; These identifiers are bound only in the inner let.
933 got-parens nil
934 got-identifier t
935 got-suffix t
936 got-suffix-after-parens t
940 ;; Fontify all the declarations and casts from the point to LIMIT.
941 ;; Assumes that strings and comments have been fontified already.
942 ;; Nil is always returned.
943 ;;
944 ;; This function can make hidden buffer changes, but the font-lock
945 ;; context covers that.
947 ;;(message "c-font-lock-declarations search from %s to %s" (point) limit)
951 c-restricted-<>-arglists
952 ;; Nonzero if the `c-decl-prefix-re' match is in an arglist context,
953 ;; as opposed to a statement-level context. The major difference is
954 ;; that "," works as declaration delimiter in an arglist context,
955 ;; whereas it only separates declarators in the same declaration in
956 ;; a statement context. If it's nonzero then the value is the
957 ;; matched char, e.g. ?\( or ?,.
958 arglist-match
959 ;; 'decl if we're in an arglist containing declarations (but if
960 ;; `c-recognize-paren-inits' is set it might also be an initializer
961 ;; arglist), '<> if the arglist is of angle bracket type, 'other if
962 ;; it's some other arglist, or nil if not in an arglist at all.
963 arglist-type
964 ;; Set to the result of `c-forward-type'.
965 at-type
966 ;; These record the start and end of the type or possible type found
967 ;; by `c-forward-type'. `type-start' is at the start of the first
968 ;; type token, and `type-end' is at the start of the first token
969 ;; after the type (and after any specifiers).
970 type-start type-end
971 ;; These store `at-type', `type-start' and `type-end' of the
972 ;; identifier before the one in those variables. The previous
973 ;; identifier might turn out to be the real type in a declaration if
974 ;; the last one has to be the declarator in it. If `prev-at-type'
975 ;; is nil then the other variables have undefined values.
976 prev-at-type prev-type-start prev-type-end
977 ;; Whether we've found a declaration or a cast. We might know this
978 ;; before we've found the type in it.
979 at-decl-or-cast
980 ;; Set when we need to back up to parse this as a declaration but
981 ;; not as a cast.
982 backup-if-not-cast
983 ;; Set if we've found a "typedef" specifier. The identifiers in the
984 ;; declaration are then fontified as types.
985 at-typedef
986 ;; Set if we've found a specifier that can start a declaration where
987 ;; there's no type.
988 maybe-typeless
989 ;; The position of the next token after the closing paren of the
990 ;; last fontified cast.
991 last-cast-end
992 ;; The same for the currently investigated cast.
993 cast-end
994 ;; The maximum of the end positions of all the checked type decl
995 ;; expressions in the successfully identified declarations. The
996 ;; position might be either before or after the syntactic whitespace
997 ;; following the last token in the type decl expression.
999 ;; Same as `max-type-decl-*', but used when we're before
1000 ;; `token-pos'.
1002 ;; Allow recording of identifier ranges in `c-forward-type' etc for
1003 ;; later fontification. Not using `c-fontify-types-and-refs' here
1004 ;; since the ranges should be fontified selectively only when a
1005 ;; declaration or cast has been successfully recognized.
1006 c-record-type-identifiers
1007 c-record-ref-identifiers
1008 ;; The font-lock package in Emacs is known to clobber
1009 ;; `parse-sexp-lookup-properties' (when it exists).
1014 ;; Below we fontify a whole declaration even when it crosses the limit,
1015 ;; to avoid gaps when lazy-lock fontifies the file a screenful at a
1016 ;; time. That is however annoying during editing, e.g. the following is
1017 ;; a common situation while the first line is being written:
1018 ;;
1019 ;; my_variable
1020 ;; some_other_variable = 0;
1021 ;;
1022 ;; font-lock will put the limit at the beginning of the second line
1023 ;; here, and if we go past it we'll fontify "my_variable" as a type and
1024 ;; "some_other_variable" as an identifier, and the latter will not
1025 ;; correct itself until the second line is changed. To avoid that we
1026 ;; narrow to the limit if the region to fontify is a single line.
1031 ;; Narrow after any operator chars following the limit though, since
1032 ;; those characters can be useful in recognizing a declaration (in
1033 ;; particular the '{' that opens a function body after the header).
1039 limit
1040 c-identifier-start
1041 c-font-lock-maybe-decl-faces
1045 ;; Don't do anything more if we're looking at a keyword
1046 ;; that can't start a declaration.
1052 ;; Set `arglist-match' and `arglist-type'. Look for "<" for the
1053 ;; sake of C++-style template arglists.
1057 ;; Find out the type of the arglist.
1062 ;; Got a cached hit in a declaration arglist.
1066 ;; Inside an angle bracket arglist.
1069 ;; Got a cached hit in some other type of arglist.
1074 ;; The point is within the range of a previously
1075 ;; encountered type decl expression, so the arglist
1076 ;; is probably one that contains declarations.
1077 ;; However, if `c-recognize-paren-inits' is set it
1078 ;; might also be an initializer arglist.
1080 ;; The result of this check is cached with a char
1081 ;; property on the match token, so that we can look
1082 ;; it up again when refontifying single lines in a
1083 ;; multiline declaration.
1090 arglist-type nil))
1093 at-decl-or-cast nil
1094 backup-if-not-cast nil
1095 at-typedef nil
1096 maybe-typeless nil
1097 c-record-type-identifiers t
1098 c-record-ref-identifiers nil
1099 ;; `start-pos' is used below to point to the start of the
1100 ;; first type, i.e. after any leading specifiers. It might
1101 ;; also point at the beginning of the preceding syntactic
1102 ;; whitespace.
1104 ;; If we're in a normal arglist context we don't want to
1105 ;; recognize commas in nested angle bracket arglists since
1106 ;; those commas could be part of our own arglist.
1107 c-restricted-<>-arglists
1113 ;; We're standing at the start of a normal arglist so remove any
1114 ;; angle bracket arglists containing commas that's been
1115 ;; recognized inside it by the preceding slightly opportunistic
1116 ;; scan in `c-font-lock-<>-arglists'.
1127 ;; Check for a type, but be prepared to skip over leading
1128 ;; specifiers like "static". Unknown symbols are treated as
1129 ;; possible types, but they could also be specifiers disguised
1130 ;; through macros like __INLINE__, so we recognize both types and
1131 ;; known specifiers after them too.
1134 ;; Don't look for a type if we already found a
1135 ;; positive one; we only loop for the
1136 ;; `c-specifier-key' check then.
1140 ;; Found a known or possible type or a prefix of a known
1141 ;; type.
1144 ;; Got two identifiers with nothing but whitespace
1145 ;; between them. That can only happen in
1146 ;; declarations.
1150 ;; If the previous identifier is a found type we
1151 ;; record it as a real one; it might be some sort of
1152 ;; alias for a prefix like "unsigned".
1159 prev-type-start type-start
1160 prev-type-end type-end
1161 at-type res
1162 type-start start
1165 ;; If the type isn't known we continue so that we'll
1166 ;; jump over all specifiers and type identifiers. The
1167 ;; reason to do this for a known type prefix is to make
1168 ;; things like "unsigned INT16" work.
1172 ;; Found a known specifier keyword. The specifier
1173 ;; keywords are restrictive, so we check for them
1174 ;; anywhere inside or around the type(s). We thereby
1175 ;; avoid having special cases for specifiers like MSVC
1176 ;; '__declspec' which can come after the type.
1187 ;; Move type-end forward if we've passed a type,
1188 ;; otherwise move start-pos forward.
1193 res)))
1197 ;; A prefix type is itself a primitive type when it's not
1198 ;; followed by another type.
1202 ;; Got no type but set things up to continue anyway to handle the
1203 ;; various cases when a declaration doesn't start with a type.
1208 ;; If it's C++ then check if the last "type" ends on the form
1209 ;; "foo::foo" or "foo::~foo", i.e. if it's the name of a
1210 ;; (con|de)structor.
1221 ;; Cheating in the handling of syntactic ws below.
1228 name))
1229 ;; It is a (con|de)structor name. In that case the
1230 ;; declaration is typeless so zap out any preceding
1231 ;; identifier(s) that we might have taken as types.
1234 prev-at-type nil
1235 type-end type-start))))))
1237 ;; Check for and step over a type decl expression after the thing
1238 ;; that is or might be a type. This can't be skipped since we need
1239 ;; the correct end position of the declarator for
1240 ;; `max-type-decl-end-*'.
1242 ;; True if there's a non-open-paren match of
1243 ;; `c-type-decl-prefix-key'.
1244 got-prefix
1245 ;; True if the declarator is surrounded by a parenthesis pair.
1246 got-parens
1247 ;; True if there is an identifier in the declarator.
1248 got-identifier
1249 ;; True if there's a non-close-paren match of
1250 ;; `c-type-decl-suffix-key'.
1251 got-suffix
1252 ;; True if there's a prefix or suffix match outside the
1253 ;; outermost paren pair that surrounds the declarator.
1254 got-prefix-before-parens
1255 got-suffix-after-parens
1256 ;; True if we've parsed the type decl to a token that
1257 ;; is known to end declarations in this context.
1258 at-decl-end
1259 ;; The earlier values of `at-type', `type-start' and
1260 ;; `type-end' if we've shifted the type backwards.
1261 identifier-type identifier-start identifier-end)
1264 ;; Skip over type decl prefix operators. (Note similar code in
1265 ;; `c-font-lock-declarators'.)
1269 ;; If the second submatch matches in C++ then
1270 ;; we're looking at an identifier that's a prefix
1271 ;; only if it specifies a member pointer.
1274 ;; We only check for a trailing "::" and
1275 ;; let the "*" that should follow be
1276 ;; matched in the next round.
1278 ;; It turned out to be the real identifier,
1279 ;; so stop.
1280 nil))
1281 t))
1293 ;; Skip over an identifier.
1298 ;; Skip over type decl suffix operators.
1304 t)
1308 t)
1312 ;; No suffix matched. We might have matched the
1313 ;; identifier as a type and the open paren of a function
1314 ;; arglist as a type decl prefix. In that case we
1315 ;; should "backtrack": Reinterpret the last type as the
1316 ;; identifier, move out of the arglist and continue
1317 ;; searching for suffix operators.
1318 ;;
1319 ;; Do this even if there's no preceding type, to cope
1320 ;; with old style function declarations in K&R C,
1321 ;; (con|de)structors in C++ and `c-typeless-decl-kwds'
1322 ;; style declarations. That isn't applicable in an
1323 ;; arglist context, though.
1328 maybe-typeless
1335 t))
1341 at-type
1343 ;; Have found no identifier but `c-typeless-decl-kwds' has
1344 ;; matched so we know we're inside a declaration. The
1345 ;; preceding type must be the identifier instead.
1349 at-decl-or-cast
1353 ;; Encountered something inside parens that isn't matched by
1354 ;; the `c-type-decl-*' regexps, so it's not a type decl
1355 ;; expression. Try to skip out to the same paren depth to
1356 ;; not confuse the cast check below.
1365 ;; Now we've collected info about various characteristics of
1366 ;; the construct we're looking at. Below follows a decision
1367 ;; tree based on that. It's ordered to check more certain
1368 ;; signs before less certain ones.
1375 ;; Got another identifier directly after the type, so
1376 ;; it's a declaration.
1383 ;; Got a declaration of the form "foo bar (gnu);"
1384 ;; where we've recognized "bar" as the type and "gnu"
1385 ;; as the declarator. In this case it's however more
1386 ;; likely that "bar" is the declarator and "gnu" a
1387 ;; function argument or initializer (if
1388 ;; `c-recognize-paren-inits' is set), since the parens
1389 ;; around "gnu" would be superfluous if it's a
1390 ;; declarator. Shift the type one step backward.
1393 ;; Found no identifier.
1400 ;; Got two types after each other, so if this isn't a
1401 ;; cast then the latter probably is the identifier and
1402 ;; we should back up to the previous type.
1407 ;; If the type is known we know that there can't be any
1408 ;; identifier somewhere else, and it's only in
1409 ;; declarations in e.g. function prototypes and in casts
1410 ;; that the identifier may be left out.
1414 ;; Only got a single identifier (parsed as a type so
1415 ;; far).
1417 ;; Check that the identifier isn't at the start of
1418 ;; an expression.
1419 at-decl-end
1422 ;; Inside an arglist that contains declarations.
1423 ;; If K&R style declarations and parenthesis
1424 ;; style initializers aren't allowed then the
1425 ;; single identifier must be a type, else we
1426 ;; require that it's known or found (primitive
1427 ;; types are handled above).
1432 ;; Inside a template arglist. Accept known and
1433 ;; found types; other identifiers could just as
1434 ;; well be constants in C++.
1440 got-parens
1445 prev-at-type
1446 maybe-typeless
1450 c-after-suffixed-type-maybe-decl-key))))))
1451 ;; Got an empty paren pair and a preceding type that
1452 ;; probably really is the identifier. Shift the type
1453 ;; backwards to make the last one the identifier. This
1454 ;; is analogous to the "backtracking" done inside the
1455 ;; `c-type-decl-suffix-key' loop above.
1456 ;;
1457 ;; Exception: In addition to the conditions in that
1458 ;; "backtracking" code, do not shift backward if we're
1459 ;; not looking at either `c-after-suffixed-type-decl-key'
1460 ;; or "[;,]". Since there's no preceding type, the
1461 ;; shift would mean that the declaration is typeless.
1462 ;; But if the regexp doesn't match then we will simply
1463 ;; fall through in the tests below and not recognize it
1464 ;; at all, so it's better to try it as an abstract
1465 ;; declarator instead.
1468 ;; Still no identifier.
1471 ;; Require `got-prefix' together with either
1472 ;; `got-parens' or `got-suffix' to recognize it as an
1473 ;; abstract declarator: `got-parens' only is probably an
1474 ;; empty function call. `got-suffix' only can build an
1475 ;; ordinary expression together with the preceding
1476 ;; identifier which we've taken as a type. We could
1477 ;; actually accept on `got-prefix' only, but that can
1478 ;; easily occur temporarily while writing an expression
1479 ;; so we avoid that case anyway. We could do a better
1480 ;; job if we knew the point when the fontification was
1481 ;; invoked.
1485 ;; By now we've located the type in the declaration that we
1486 ;; know we're in.
1496 ;; Shift the type backward in the case that
1497 ;; there's a single identifier inside parens.
1498 ;; That can only occur in K&R style function
1499 ;; declarations so it's more likely that it
1500 ;; really is a function call. Therefore we
1501 ;; only do this after
1502 ;; `c-after-suffixed-type-decl-key' has
1503 ;; matched.
1505 got-suffix-after-parens))
1506 ;; A declaration according to
1507 ;; `c-after-suffixed-type-decl-key'.
1512 ;; It's a declaration if a known type precedes it and it
1513 ;; can't be a function call.
1516 ;; If we get here we can't tell if this is a type decl or a
1517 ;; normal expression by looking at it alone. (That's under
1518 ;; the assumption that normal expressions always can look like
1519 ;; type decl expressions, which isn't really true but the
1520 ;; cases where it doesn't hold are so uncommon (e.g. some
1521 ;; placements of "const" in C++) it's not worth the effort to
1522 ;; look for them.)
1525 ;; If this is a declaration it should end here or its
1526 ;; initializer(*) should start here, so check for allowed
1527 ;; separation tokens. Note that this rule doesn't work
1528 ;; e.g. with a K&R arglist after a function header.
1529 ;;
1530 ;; *) Don't check for C++ style initializers using parens
1531 ;; since those already have been matched as suffixes.
1534 ;; Below are tests that only should be applied when we're
1535 ;; certain to not have parsed halfway through an expression.
1538 ;; The expression starts with a known type so treat it as a
1539 ;; declaration.
1543 ;; In C++ we check if the identifier is a known
1544 ;; type, since (con|de)structors use the class name
1545 ;; as identifier. We've always shifted over the
1546 ;; identifier as a type and then backed up again in
1547 ;; this case.
1548 identifier-type
1551 ;; `at-type' probably won't be 'found for
1552 ;; destructors since the "~" is then part
1553 ;; of the type name being checked against
1554 ;; the list of known types, so do a check
1555 ;; without that operator.
1560 c-identifier-syntax-table
1563 identifier-end)))))
1569 at-type
1573 ;; Got something like "foo * bar;". Since we're not
1574 ;; inside an arglist it would be a meaningless
1575 ;; expression because the result isn't used. We
1576 ;; therefore choose to recognize it as a declaration.
1577 ;; Do not allow a suffix since it could then be a
1578 ;; function call.
1585 ;; Got something like "a (*b) (c);" or "a (b) = c;".
1586 ;; It could be an odd expression or it could be a
1587 ;; declaration. Treat it as a declaration if "a" has
1588 ;; been used as a type somewhere else (if it's a known
1589 ;; type we won't get here).
1597 ;; Got a type followed by an abstract declarator. If
1598 ;; `got-prefix' is set it's something like "a *" without
1599 ;; anything after it. If `got-parens' or `got-suffix' is
1600 ;; set it's "a()", "a[]", "a()[]", or similar, which we
1601 ;; accept only if the context rules out expressions.
1604 ;; If we had a complete symbol table here (which rules out
1605 ;; `c-found-types') we should return t due to the
1606 ;; disambiguation rule (in at least C++) that anything that
1607 ;; can be parsed as a declaration is a declaration. Now we're
1608 ;; being more defensive and prefer to highlight things like
1609 ;; "foo (bar);" as a declaration only if we're inside an
1610 ;; arglist that contains declarations.
1613 ;; Point is now after the type decl expression.
1616 ;; Check for a cast.
1619 c-cast-parens
1621 ;; Should be the first type/identifier in a cast paren.
1624 ;; The closing paren should follow.
1629 ;; There should be a primary expression after it.
1638 ;; Check if the expression begins with a prefix
1639 ;; keyword.
1642 ;; Expression begins with an ambiguous operator.
1643 ;; Treat it as a cast if it's a type decl or if
1644 ;; we've recognized the type somewhere else.
1647 ;; Unless it's a keyword, it's the beginning of a
1648 ;; primary expression.
1650 ;; If `c-primary-expr-regexp' matched a nonsymbol
1651 ;; token, check that it matched a whole one so that we
1652 ;; don't e.g. confuse the operator '-' with '->'. It's
1653 ;; ok if it matches further, though, since it e.g. can
1654 ;; match the float '.5' while the operator regexp only
1655 ;; matches '.'.
1659 ;; There should either be a cast before it or something that
1660 ;; isn't an identifier or close paren.
1668 ;; It's a symbol. Accept it only if it's one of
1669 ;; the keywords that can precede an expression
1670 ;; (without surrounding parens).
1673 ;; Check that it isn't a close paren (block close
1674 ;; is ok, though).
1676 ;; Check that it isn't a nonsymbol identifier.
1679 ;; Handle the cast.
1687 ;; We're at a declaration. Highlight the type and the following
1688 ;; declarators.
1694 ;; Make sure to propagate the `c-decl-arg-start' property to
1695 ;; the next argument if it's set in this one, to cope with
1696 ;; interactive refontification.
1699 ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
1700 ;; under the assumption that we're after the first type decl
1701 ;; expression in the declaration now. That's not really true; we
1702 ;; could also be after a parenthesized initializer expression in
1703 ;; C++, but this is only used as a last resort to slant ambiguous
1704 ;; expression/declarations, and overall it's worth the risk to
1705 ;; occasionally fontify an expression as a declaration in an
1706 ;; initializer expression compared to getting ambiguous things in
1707 ;; normal function prototypes fontified as expressions.
1723 ;; Should normally not fontify a list of declarators
1724 ;; inside an arglist, but the first argument in the
1725 ;; ';' separated list of a "for" statement is an
1726 ;; exception.
1733 t)))
1735 ;; Fix the `c-decl-id-start' or `c-decl-type-start' property
1736 ;; before the first declarator if it's a list.
1737 ;; `c-font-lock-declarators' handles the rest.
1744 'c-decl-type-start
1750 ;; False alarm. Skip the fontification done below.
1753 ;; A cast or declaration has been successfully identified, so do
1754 ;; all the fontification of types and refs that's been recorded by
1755 ;; the calls to `c-forward-type' and `c-forward-name' above.
1757 nil)))
1759 nil)))
1762 "Simple font lock matchers for types and declarations. These are used
1763 on level 2 only and so aren't combined with `c-complex-decl-matchers'."
1771 ;; `parse-sexp-lookup-properties' (when it exists).
1778 nil))
1781 ;; Fontify all type names and the identifiers in the
1782 ;; declarations they might start. Use eval here since
1783 ;; `c-known-type-key' gets its value from
1784 ;; `*-font-lock-extra-types' on mode init.
1786 'c-known-type-key
1794 ;; Fontify types preceded by `c-type-prefix-kwds' and the
1795 ;; identifiers in the declarations they might start.
1811 ;; Fontify special declarations that lacks a type.
1822 ))
1825 "Complex font lock matchers for types and declarations. Used on level
1826 3 and higher."
1829 c-font-lock-complex-decl-prepare
1831 ;; Fontify angle bracket arglists like templates in C++.
1836 ;; Fontify method declarations in Objective-C, but first
1837 ;; we have to put the `c-decl-end' `c-type' property on
1838 ;; all the @-style directives that haven't been handled in
1839 ;; `c-basic-matchers-before'.
1842 ;; Exclude "@class" since that directive ends with a
1843 ;; semicolon anyway.
1847 nil)))
1851 c-font-lock-objc-methods)
1859 ;; Fontify all declarations and casts.
1860 c-font-lock-declarations
1862 ;; The first two rules here mostly find occurences that
1863 ;; `c-font-lock-declarations' has found already, but not
1864 ;; declarations containing blocks in the type (see note below).
1865 ;; It's also useful to fontify these everywhere to show e.g. when
1866 ;; a type keyword is accidentally used as an identifier.
1868 ;; Fontify basic types.
1872 ;; No symbol is a keyword after "->" in Pike.
1879 ;; Fontify types preceded by `c-type-prefix-kwds'.
1885 ;; The font-lock package in Emacs is known to clobber
1886 ;; `parse-sexp-lookup-properties' (when it exists).
1891 ;; Narrow to avoid going past the limit in
1892 ;; `c-forward-type'.
1899 limit t)
1902 ;; Handle prefix declaration specifiers.
1908 ;; In C++ we additionally check for a "class
1909 ;; X = Y" construct which is used in
1910 ;; templates, to fontify Y as a type.
1915 )))))))))
1917 ;; Fontify symbols after closing braces as declaration
1918 ;; identifiers under the assumption that they are part of
1919 ;; declarations like "class Foo { ... } foo;". It's too
1920 ;; expensive to check this accurately by skipping past the
1921 ;; brace block, so we use the heuristic that it's such a
1922 ;; declaration if the first identifier is on the same line as
1923 ;; the closing brace. `c-font-lock-declarations' will later
1924 ;; override it if it turns out to be an new declaration, but
1925 ;; it will be wrong if it's an expression (see the test
1926 ;; decls-8.cc).
1942 c-single-line-syntactic-ws-depth)))))
1945 ;; Fontify the type in C++ "new" expressions.
1949 ))
1952 ;; Fontify all the declarations from the point to LIMIT. Assumes
1953 ;; that strings and comments have been fontified already. Nil is
1954 ;; always returned.
1955 ;;
1956 ;; This function can make hidden buffer changes, but the font-lock
1957 ;; context covers that.
1960 ;; The font-lock package in Emacs is known to clobber
1961 ;; `parse-sexp-lookup-properties' (when it exists).
1980 ;; Check for a char that precedes a statement.
1982 ;; Check for a preceding label. We exploit the font
1983 ;; locking made earlier by this function.
1990 c-label-face-name))
1991 ;; Check for a keyword that precedes a statement.
1995 ;; Got a label.
1999 c-label-face-name)))
2002 nil)
2005 "Font lock matchers for various things that should be fontified after
2006 generic casts and declarations are fontified. Used on level 2 and
2007 higher."
2010 ;; name is handled by `c-simple-decl-matchers' or
2011 ;; `c-complex-decl-matchers' below.
2018 ;; Disallow various common punctuation chars that can't come
2019 ;; before the '{' of the enum list, to avoid searching too far.
2020 "[^\]\[{}();,/#=]*"
2030 ;; Fontify labels in languages that supports them.
2034 ;; (Got three different interpretation levels here,
2035 ;; which makes it a bit complicated: 1) The backquote
2036 ;; stuff is expanded when compiled or loaded, 2) the
2037 ;; eval form is evaluated at font-lock setup (to
2038 ;; substitute c-label-face-name correctly), and 3) the
2039 ;; resulting structure is interpreted during
2040 ;; fontification.)
2052 c-label-face-name nil t))))
2054 ;; Fontify normal labels.
2055 c-font-lock-labels))
2057 ;; Fontify the clauses after various keywords.
2073 ))
2091 ;; Incorporate the font lock keyword lists according to
2092 ;; `c-doc-comment-style' on the given keyword list and return it.
2093 ;; This is used in the function bindings of the
2094 ;; `*-font-lock-keywords-*' symbols since we have to build the list
2095 ;; when font-lock is initialized.
2104 c-doc-comment-style))
2116 doc-keywords
2118 base-list)))
2120 ;; Kludge: If `c-font-lock-complex-decl-prepare' is on the list we
2121 ;; move it first since the doc comment font lockers might add
2122 ;; `c-type' text properties, so they have to be cleared before that.
2128 list))
2131 ;; This is used to override the value on a `*-font-lock-keywords'
2132 ;; variable only if it's nil or has the same value as one of the
2133 ;; `*-font-lock-keywords-*' variables. Older font-lock packages
2134 ;; define a default value for `*-font-lock-keywords' which we want
2135 ;; to override, but we should otoh avoid clobbering a user setting.
2136 ;; This heuristic for that isn't perfect, but I can't think of any
2137 ;; better. /mast
2138 ;;
2139 ;; This function does not do any hidden buffer changes.
2146 suffix))))
2149 ;; The overriding is done by unbinding the variable so that the normal
2150 ;; defvar will install its default value later on.
2153 \f
2154 ;;; C.
2159 "Minimal font locking for C mode.
2160 Fontifies only preprocessor directives (in addition to the syntactic
2164 "Fast normal font locking for C mode.
2165 In addition to `c-font-lock-keywords-1', this adds fontification of
2166 keywords, simple types, declarations that are easy to recognize, the
2167 user defined types on `c-font-lock-extra-types', and the doc comment
2171 "Accurate normal font locking for C mode.
2172 Like `c-font-lock-keywords-2' but detects declarations in a more
2173 accurate way that works in most cases for arbitrary types without the
2186 \f
2187 ;;; C++.
2190 ;; Assuming point is after a "new" word, check that it isn't inside
2191 ;; a string or comment, and if so try to fontify the type in the
2192 ;; allocation expression. Nil is always returned.
2193 ;;
2194 ;; As usual, C++ takes the prize in coming up with a hard to parse
2195 ;; syntax. :P
2200 ;; A "new" keyword is followed by one to three expressions, where
2201 ;; the type is the middle one, and the only required part.
2203 ;; Enable recording of identifier ranges in `c-forward-type'
2204 ;; etc for later fontification. Not using
2205 ;; `c-fontify-types-and-refs' here since the ranges should
2206 ;; be fontified selectively only when an allocation
2207 ;; expression is successfully recognized.
2209 c-record-ref-identifiers
2210 ;; The font-lock package in Emacs is known to clobber
2211 ;; `parse-sexp-lookup-properties' (when it exists).
2217 ;; The first placement arglist is always parenthesized, if it
2218 ;; exists.
2226 ;; The second expression is either a type followed by some "*" or
2227 ;; "[...]" or similar, or a parenthesized type followed by a full
2228 ;; identifierless declarator.
2238 ;; No second expression, so the first has to be a
2239 ;; parenthesized type.
2245 ;; Got two parenthesized expressions, so we have to look
2246 ;; closer at them to decide which is the type. No need to
2247 ;; handle `c-record-ref-identifiers' since all references
2248 ;; has already been handled by other fontification rules.
2257 ;; There's something after the would-be type that
2258 ;; can't be there, so this is a placement arglist.
2267 ;; There's something after the would-be type that can't
2268 ;; be there, so this is an initialization expression.
2273 ;; If there's a third initialization expression
2274 ;; then the second one is the type, so demote the
2275 ;; first match.
2278 ;; We fontify the most likely type, with a preference for
2279 ;; the first argument since a placement arglist is more
2280 ;; unusual than an initializer.
2299 ;; If both type matches are 'maybe then we're
2300 ;; too uncertain to promote either of them.
2301 )))))
2303 ;; Fontify the type that now is recorded in
2304 ;; `c-record-type-identifiers', if any.
2306 nil)
2311 "Minimal font locking for C++ mode.
2312 Fontifies only preprocessor directives (in addition to the syntactic
2316 "Fast normal font locking for C++ mode.
2317 In addition to `c++-font-lock-keywords-1', this adds fontification of
2318 keywords, simple types, declarations that are easy to recognize, the
2319 user defined types on `c++-font-lock-extra-types', and the doc comment
2323 "Accurate normal font locking for C++ mode.
2324 Like `c++-font-lock-keywords-2' but detects declarations in a more
2325 accurate way that works in most cases for arbitrary types without the
2338 \f
2339 ;;; Objective-C.
2342 ;; Assuming the point is after an "@interface", "@implementation",
2343 ;; "@protocol" declaration, fontify all the types in the directive.
2344 ;; Return t if the directive was fully recognized. Point will then
2345 ;; be at the end of it.
2350 ;; Turn off recognition of angle bracket arglists while parsing
2351 ;; types here since the protocol reference list might then be
2352 ;; considered part of the preceding name or superclass-name.
2356 ;; Handle the name of the class itself.
2360 ;; Look for ": superclass-name" or "( category-name )".
2371 ;; Look for a protocol reference list.
2376 t)
2378 t))))
2381 ;; Assuming the point is after the + or - that starts an Objective-C
2382 ;; method declaration, fontify it. This must be done before normal
2383 ;; casts, declarations and labels are fontified since they will get
2384 ;; false matches in these things.
2394 ;; An optional method type.
2402 t))
2404 ;; The name. The first time it's the first part of
2405 ;; the function name, the rest of the time it's an
2406 ;; argument name.
2413 'font-lock-function-name-face
2417 ;; Another optional part of the function name.
2425 ;; There's another argument if a colon follows.
2431 ;; Fontify method declarations in Objective-C. Nil is always
2432 ;; returned.
2435 ;; `parse-sexp-lookup-properties' (when it exists).
2441 limit
2442 "[-+]"
2443 nil
2447 nil)
2452 "Minimal font locking for Objective-C mode.
2453 Fontifies only compiler directives (in addition to the syntactic
2457 "Fast normal font locking for Objective-C mode.
2458 In addition to `objc-font-lock-keywords-1', this adds fontification of
2459 keywords, simple types, declarations that are easy to recognize, the
2460 user defined types on `objc-font-lock-extra-types', and the doc
2464 "Accurate normal font locking for Objective-C mode.
2465 Like `objc-font-lock-keywords-2' but detects declarations in a more
2466 accurate way that works in most cases for arbitrary types without the
2479 ;; Kludge to override the default value that
2480 ;; `objc-font-lock-extra-types' might have gotten from the font-lock
2481 ;; package. The value replaced here isn't relevant now anyway since
2482 ;; those types are builtin and therefore listed directly in
2483 ;; `c-primitive-type-kwds'.
2489 \f
2490 ;;; Java.
2495 "Minimal font locking for Java mode.
2496 Fontifies nothing except the syntactic fontification of strings and
2500 "Fast normal font locking for Java mode.
2501 In addition to `java-font-lock-keywords-1', this adds fontification of
2502 keywords, simple types, declarations that are easy to recognize, the
2503 user defined types on `java-font-lock-extra-types', and the doc
2507 "Accurate normal font locking for Java mode.
2508 Like `java-font-lock-keywords-2' but detects declarations in a more
2509 accurate way that works in most cases for arbitrary types without the
2522 \f
2523 ;;; CORBA IDL.
2528 "Minimal font locking for CORBA IDL mode.
2529 Fontifies nothing except the syntactic fontification of strings and
2533 "Fast normal font locking for CORBA IDL mode.
2534 In addition to `idl-font-lock-keywords-1', this adds fontification of
2535 keywords, simple types, declarations that are easy to recognize, the
2536 user defined types on `idl-font-lock-extra-types', and the doc comment
2540 "Accurate normal font locking for CORBA IDL mode.
2541 Like `idl-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 ;;; Pike.
2561 "Minimal font locking for Pike mode.
2562 Fontifies only preprocessor directives (in addition to the syntactic
2566 "Fast normal font locking for Pike mode.
2567 In addition to `pike-font-lock-keywords-1', this adds fontification of
2568 keywords, simple types, declarations that are easy to recognize, the
2569 user defined types on `pike-font-lock-extra-types', and the doc
2573 "Accurate normal font locking for Pike mode.
2574 Like `pike-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 ;;; Doc comments.
2592 ;; Fontify the comments between the point and LIMIT whose start
2593 ;; matches PREFIX with `c-doc-face-name'. Assumes comments have been
2594 ;; fontified with `font-lock-comment-face' already. nil is always
2595 ;; returned.
2596 ;;
2597 ;; After the fontification of a matching comment, fontification
2598 ;; according to KEYWORDS is applied inside it. It's a list like
2599 ;; `font-lock-keywords' except that anchored matches and eval
2600 ;; clauses aren't supported and that some abbreviated forms can't be
2601 ;; used. The buffer is narrowed to the comment while KEYWORDS is
2602 ;; applied; leading comment starters are included but trailing
2603 ;; comment enders for block comment are not.
2604 ;;
2605 ;; Note that faces added through KEYWORDS should never replace the
2606 ;; existing `c-doc-face-name' face since the existence of that face
2607 ;; is used as a flag in other code to skip comments.
2612 ;; Handle the case when the fontified region starts inside a
2613 ;; comment.
2622 comment-beg
2624 ;; Search for the prefix until a match is found at the start
2625 ;; of a comment.
2629 c-literal-faces))
2632 c-literal-faces))))
2637 ;; Collect a sequence of doc style line comments.
2654 ;; Narrow to the doc comment. Among other things, this
2655 ;; helps by making "^" match at the start of the comment.
2656 ;; Do not include a trailing block comment ender, though.
2680 nil)
2684 ;; Used to fontify invalid markup in doc comments after the correct
2685 ;; ones have been fontified: Find the first occurence of REGEXP
2686 ;; between the point and LIMIT that only is fontified with
2687 ;; `c-doc-face-name'. If a match is found then submatch 0 surrounds
2688 ;; the first char and t is returned, otherwise nil is returned.
2693 c-doc-face-name))
2698 t)))
2713 ;; Fontify remaining markup characters as invalid. Note
2714 ;; that the Javadoc spec is hazy about when "@" is
2715 ;; allowed in non-markup use.
2723 javadoc-font-lock-doc-comments)))))
2726 ;; Adorned regexp matching the keywords that introduce declarations
2727 ;; in Pike Autodoc.
2732 ;; Adorned regexp matching the keywords that are followed by a type.
2737 ;; Fontify all line oriented keywords between the point and LIMIT.
2738 ;; Nil is always returned.
2741 c-current-comment-prefix
2752 end)
2756 ;; Put a declaration end mark at the markup keyword and
2757 ;; remove the faces from the rest of the line so that it
2758 ;; gets refontified as a declaration later on by
2759 ;; `c-font-lock-declarations'.
2775 ;; Include the final newline in the removed area. This
2776 ;; has no visual effect but it avoids some tricky special
2777 ;; cases in the testsuite wrt the differences in string
2778 ;; fontification in Emacs vs XEmacs.
2781 ;; Must handle string literals explicitly inside the declaration.
2789 ;; Fontify types after keywords that always are followed
2790 ;; by them.
2798 ;; Mark each whole line as markup, as long as the logical line
2799 ;; continues.
2803 markup-faces)
2811 nil)
2815 ;; In-text markup.
2818 ;; Fontify remaining markup characters as invalid.
2822 ))
2825 ;; Note that we depend on that `c-current-comment-prefix' has got
2826 ;; its proper value here.
2828 ;; The `c-type' text property with `c-decl-end' is used to mark the
2829 ;; end of the `autodoc-decl-keywords' occurrences to fontify the
2830 ;; following declarations.
2835 autodoc-font-lock-doc-comments)))))
2837 \f
2838 ;; AWK.
2840 ;; Awk regexps written with help from Peter Galbraith
2841 ;; <galbraith@mixing.qc.dfo.ca>.
2842 ;; Take GNU Emacs's 'words out of the following regexp-opts. They dont work
2843 ;; in Xemacs 21.4.4. acm 2002/9/19.
2848 ;; Function names.
2851 ;;
2852 ;; Variable names.
2862 ;; Special file names. (acm, 2002/7/22)
2863 ;; The following regexp was created by first evaluating this in GNU Emacs 21.1:
2864 ;; (c-regexp-opt '("/dev/stdin" "/dev/stdout" "/dev/stderr" "/dev/fd/n" "/dev/pid"
2865 ;; "/dev/ppid" "/dev/pgrpid" "/dev/user") 'words)
2866 ;; , removing the "?:" from each "\\(?:" (for backward compatibility with older Emacsen)
2867 ;; , replacing the "n" in "dev/fd/n" with "[0-9]+"
2868 ;; , removing the unwanted \\< at the beginning, and finally filling out the
2869 ;; regexp so that a " must come before, and either a " or heuristic stuff after.
2870 ;; The surrounding quotes are fontified along with the filename, since, semantically,
2871 ;; they are an indivisible unit.
2877 ;; Do the same (almost) with
2878 ;; (c-regexp-opt '("/inet/tcp/lport/rhost/rport" "/inet/udp/lport/rhost/rport"
2879 ;; "/inet/raw/lport/rhost/rport") 'words)
2880 ;; This cannot be combined with the above pattern, because the match number
2881 ;; for the (optional) closing \" would then exceed 9.
2887 ;; Keywords.
2895 ;; Builtins.
2910 ;; gawk debugging keywords. (acm, 2002/7/21)
2911 ;; (Removed, 2003/6/6. These functions are now fontified as built-ins)
2912 ;; (list (concat "\\<" (c-regexp-opt '("adump" "stopme") t) "\\>")
2913 ;; 0 'font-lock-warning-face)
2915 ;; User defined functions with an apparent spurious space before the
2916 ;; opening parenthesis. acm, 2002/5/30.
2921 ;; Space after \ in what looks like an escaped newline. 2002/5/31
2924 ;; Unbalanced string (") or regexp (/) delimiters. 2002/02/16.
2926 ;; gawk 3.1 localizable strings ( _"translate me!"). 2002/5/21
2929 ))
2932 \f
2935 ;;; arch-tag: 2f65f405-735f-4da5-8d4b-b957844c5203
2936 ;;; cc-fonts.el ends here