| blob | bff1c9eb65d447e4be5613c11b2046a81c0d6b53 |
1 ;;; cc-defs.el --- compile time definitions for CC Mode
3 ;; Copyright (C) 1985, 1987, 1992-2017 Free Software Foundation, Inc.
5 ;; Authors: 2003- Alan Mackenzie
6 ;; 1998- Martin Stjernholm
7 ;; 1992-1999 Barry A. Warsaw
8 ;; 1987 Dave Detlefs
9 ;; 1987 Stewart Clamen
10 ;; 1985 Richard M. Stallman
11 ;; Maintainer: bug-cc-mode@gnu.org
12 ;; Created: 22-Apr-1997 (split from cc-mode.el)
13 ;; Keywords: c languages
14 ;; Package: cc-mode
16 ;; This file is part of GNU Emacs.
18 ;; GNU Emacs is free software: you can redistribute it and/or modify
19 ;; it under the terms of the GNU General Public License as published by
20 ;; the Free Software Foundation, either version 3 of the License, or
21 ;; (at your option) any later version.
23 ;; GNU Emacs is distributed in the hope that it will be useful,
24 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
25 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 ;; GNU General Public License for more details.
28 ;; You should have received a copy of the GNU General Public License
29 ;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
31 ;;; Commentary:
33 ;; This file contains macros, defsubsts, and various other things that
34 ;; must be loaded early both during compilation and at runtime.
36 ;;; Code:
43 load-path)))
49 'cl-lib
53 ; was (cc-external-require 'cl). ACM 2005/11/29.
54 ; Changed from (eval-when-compile (require 'cl)) back to
55 ; cc-external-require, 2015-08-12.
58 ;; Silence the compiler.
68 \f
69 ;; cc-fix.el contains compatibility macros that should be used if
70 ;; needed.
74 ;; XEmacs 21.4 doesn't have `delete-dups'.
85 font-lock-keywords))))
87 \f
88 ;;; Variables also used at compile time.
94 ;; A little more compact and faster in comparisons.
97 "Non-nil for all buffers with a major mode derived from CC Mode.
98 Otherwise, this variable is nil. I.e. this variable is non-nil for
99 `c-mode', `c++-mode', `objc-mode', `java-mode', `idl-mode',
100 `pike-mode', `awk-mode', and any other non-CC Mode mode that calls
101 `c-initialize-cc-mode'. The value is the mode symbol itself
102 \(i.e. `c-mode' etc) of the original CC Mode mode, or just t if it's
106 ;; Have to make `c-buffer-is-cc-mode' permanently local so that it
107 ;; survives the initialization of the derived mode.
110 \f
111 ;; The following is used below during compilation.
116 "Like `progn', but evaluates the body at compile time.
117 The result of the body appears to the compiler as a quoted constant.
119 This variant works around bugs in `eval-when-compile' in various
120 \(X)Emacs versions. See cc-defs.el for details."
123 ;; XEmacs 21.4.6 has a bug in `eval-when-compile' in that it
124 ;; evaluates its body at macro expansion time if it's nested
125 ;; inside another `eval-when-compile'. So we use a dynamically
126 ;; bound variable to avoid nesting them.
130 ;; In all (X)Emacsen so far, `eval-when-compile' byte compiles
131 ;; its contents before evaluating it. That can cause forms to
132 ;; be compiled in situations they aren't intended to be
133 ;; compiled.
134 ;;
135 ;; Example: It's not possible to defsubst a primitive, e.g. the
136 ;; following will produce an error (in any emacs flavor), since
137 ;; `nthcdr' is a primitive function that's handled specially by
138 ;; the byte compiler and thus can't be redefined:
139 ;;
140 ;; (defsubst nthcdr (val) val)
141 ;;
142 ;; `defsubst', like `defmacro', needs to be evaluated at
143 ;; compile time, so this will produce an error during byte
144 ;; compilation.
145 ;;
146 ;; CC Mode occasionally needs to do things like this for
147 ;; cross-emacs compatibility. It therefore uses the following
148 ;; to conditionally do a `defsubst':
149 ;;
150 ;; (eval-when-compile
151 ;; (if (not (fboundp 'foo))
152 ;; (defsubst foo ...)))
153 ;;
154 ;; But `eval-when-compile' byte compiles its contents and
155 ;; _then_ evaluates it (in all current emacs versions, up to
156 ;; and including Emacs 20.6 and XEmacs 21.1 as of this
157 ;; writing). So this will still produce an error, since the
158 ;; byte compiler will get to the defsubst anyway. That's
159 ;; arguably a bug because the point with `eval-when-compile' is
160 ;; that it should evaluate rather than compile its contents.
161 ;;
162 ;; We get around it by expanding the body to a quoted
163 ;; constant that we eval. That otoh introduce a problem in
164 ;; that a returned lambda expression doesn't get byte
165 ;; compiled (even if `function' is used).
170 \f
171 ;;; Macros.
173 ;; CC Mode equivalent of `mapcan' which bridges the difference
174 ;; between the host [X]Emacsen."
175 ;; The motivation for this macro is to avoid the irritating message
176 ;; "function `mapcan' from cl package called at runtime" produced by Emacs.
180 ;; XEmacs and Emacs >= 26.
183 ;; Emacs >= 24.3, < 26.
186 ;; Emacs <= 24.2. It would be nice to be able to distinguish between
187 ;; compile-time and run-time use here.
191 ;; Macro to smooth out the renaming of `set-difference' in Emacs 24.3.
197 ;; Macro to smooth out the renaming of `intersection' in Emacs 24.3.
204 ;; Macro to smooth out the renaming of `cl-macroexpand-all' in Emacs 24.3.
210 ;; Macro to smooth out the renaming of `delete-duplicates' in Emacs 24.3.
216 "Return the value of certain commonly referenced POSITIONs relative to POINT.
217 The current point is used if POINT isn't specified. POSITION can be
218 one of the following symbols:
220 `bol' -- beginning of line
221 `eol' -- end of line
222 `bod' -- beginning of defun
223 `eod' -- end of defun
224 `boi' -- beginning of indentation
225 `ionl' -- indentation of next line
226 `iopl' -- indentation of previous line
227 `bonl' -- beginning of next line
228 `eonl' -- end of next line
229 `bopl' -- beginning of previous line
230 `eopl' -- end of previous line
231 `bosws' -- beginning of syntactic whitespace
232 `eosws' -- end of syntactic whitespace
234 If the referenced position doesn't exist, the closest accessible point
235 to it is returned. This function does not modify the point or the mark."
337 ;; The bulk of this should perhaps be in a function to avoid large
338 ;; expansions, but this case is not used anywhere in CC Mode (and
339 ;; probably not anywhere else either) so we only have it to be on
340 ;; the safe side.
373 ;; Constant to decide at compilation time whether to use category
374 ;; properties. Currently (2010-03) they're available only on GNU Emacs.
392 ;; See the doc string for either of the defuns expanded to.
395 ;; XEmacs >= 2005-01-25
397 ;; Emacs and earlier XEmacs
401 ;; Return t when the region is active. The determination of region
402 ;; activeness is different in both Emacs and XEmacs.
404 ;; XEmacs.
406 ;; Old Emacs.
410 ;; Activate the region if ACTIVE is non-nil, deactivate it
411 ;; otherwise. Covers the differences between Emacs and XEmacs.
413 ;; XEmacs.
417 ;; Emacs.
422 ;; XEmacs
425 ;; Emacs
428 ;; incompatible
432 "Delete the text between START and END and return it."
434 ;; Emacs 21.1 and later
436 ;; XEmacs and Emacs 20.x
442 ;; safely execute BODY, return nil if an error occurred
449 ;; In Emacs, a character is an integer. In XEmacs, a character is a
450 ;; type distinct from an integer. Sometimes we need to convert integers to
451 ;; characters. `c-int-to-char' makes this conversion, if necessary.
454 integer))
457 ;; The last character just typed. Note that `last-command-event' exists in
458 ;; both Emacs and XEmacs, but with confusingly different meanings.
460 'last-command-char
464 ;; Get the regular expression `sentence-end'.
466 ;; Emacs 22:
468 ;; Emacs <22 + XEmacs
472 ;; Get the default value of the variable sentence end.
474 ;; Emacs 22:
476 ;; Emacs <22 + XEmacs
479 ;; The following is essentially `save-buffer-state' from lazy-lock.el.
480 ;; It ought to be a standard macro.
482 "Bind variables according to VARLIST (in `let*' style) and eval BODY,
483 then restore the buffer state under the assumption that no significant
484 modification has been made in BODY. A change is considered
485 significant if it affects the buffer text in any way that isn't
486 completely restored again. Changes in text properties like `face' or
487 `syntax-table' are considered insignificant. This macro allows text
488 properties to be changed, even in a read-only buffer.
490 This macro should be placed around all calculations which set
492 known to be writable. That way, these text properties remain set
493 even if the user undoes the command which set them.
496 changes \(like adding a newline to calculate a text-property then
497 deleting it again), so that the user never sees them on his
498 `buffer-undo-list'. See also `c-tentative-buffer-changes'.
500 However, any user-visible changes to the buffer \(like auto-newlines)
501 must not be within a `c-save-buffer-state', since the user then
502 wouldn't be able to undo them.
504 The return value is the value of the last form in BODY."
510 before-change-functions after-change-functions
511 deactivate-mark
512 buffer-file-name buffer-file-truename ; Prevent primitives checking
513 ; for file modification
522 "Eval BODY and optionally restore the buffer contents to the state it
523 was in before BODY. Any changes are kept if the last form in BODY
524 returns non-nil. Otherwise it's undone using the undo facility, and
525 various other buffer state that might be affected by the changes is
526 restored. That includes the current buffer, point, mark, mark
527 activation \(similar to `save-excursion'), and the modified state.
528 The state is also restored if BODY exits nonlocally.
530 If BODY makes a change that unconditionally is undone then wrap this
531 macro inside `c-save-buffer-state'. That way the change can be done
532 even when the buffer is read-only, and without interference from
533 various buffer change hooks."
535 -tnt-chng-state)
537 ;; Insert an undo boundary for use with `undo-more'. We
538 ;; don't use `undo-boundary' since it doesn't insert one
539 ;; unconditionally.
547 ;; Used internally in `c-tentative-buffer-changes'.
550 ;; No need to use markers for the point and mark; if the
551 ;; undo got out of synch we're hosed anyway.
558 ;; Used internally in `c-tentative-buffer-changes'.
562 ;; No change was done after all.
566 ;; Find and remove the undo boundary.
572 ;; `primitive-undo' will remove the boundary.
577 saved-undo-list))))
589 "Forward skip over syntactic whitespace.
590 Syntactic whitespace is defined as whitespace characters, comments,
591 and preprocessor directives. However if point starts inside a comment
592 or preprocessor directive, the content of it is not treated as
593 whitespace.
595 LIMIT sets an upper limit of the forward movement, if specified. If
596 LIMIT or the end of the buffer is reached inside a comment or
597 preprocessor directive, the point will be left there.
599 Note that this function might do hidden buffer changes. See the
600 comment at the start of cc-engine.el for more info."
608 "Backward skip over syntactic whitespace.
609 Syntactic whitespace is defined as whitespace characters, comments,
610 and preprocessor directives. However if point starts inside a comment
611 or preprocessor directive, the content of it is not treated as
612 whitespace.
614 LIMIT sets a lower limit of the backward movement, if specified. If
615 LIMIT is reached inside a line comment or preprocessor directive then
616 the point is moved into it past the whitespace at the end.
618 Note that this function might do hidden buffer changes. See the
619 comment at the start of cc-engine.el for more info."
627 "Move forward across COUNT balanced expressions.
628 A negative COUNT means move backward. Signal an error if the move
629 fails for any reason.
631 This is like `forward-sexp' except that it isn't interactive and does
632 not do any user friendly adjustments of the point and that it isn't
633 susceptible to user configurations such as disabling of signals in
634 certain situations."
639 "See `c-forward-sexp' and reverse directions."
644 "Like `scan-lists' but returns nil instead of signaling errors
645 for unbalanced parens.
647 A limit for the search may be given. FROM is assumed to be on the
648 right side of it."
663 res)))
665 \f
666 ;; Wrappers for common scan-lists cases, mainly because it's almost
667 ;; impossible to get a feel for how that function works.
670 "Move forward across one balanced group of parentheses starting at POS or
671 point. Return POINT when we succeed, NIL when we fail. In the latter case,
672 leave point unmoved.
674 A LIMIT for the search may be given. The start position is assumed to be
675 before it."
680 "Move backward across one balanced group of parentheses starting at POS or
681 point. Return POINT when we succeed, NIL when we fail. In the latter case,
682 leave point unmoved.
684 A LIMIT for the search may be given. The start position is assumed to be
685 after it."
690 "Return the first position after the list sexp containing POS,
691 or nil if no such position exists. The point is used if POS is left out.
693 A limit for the search may be given. The start position is assumed to
694 be before it."
698 "Return the position of the start of the list sexp containing POS,
699 or nil if no such position exists. The point is used if POS is left out.
701 A limit for the search may be given. The start position is assumed to
702 be after it."
706 "Return the first position inside the first list sexp after POS,
707 or nil if no such position exists. The point is used if POS is left out.
709 A limit for the search may be given. The start position is assumed to
710 be before it."
714 "Return the last position inside the last list sexp before POS,
715 or nil if no such position exists. The point is used if POS is left out.
717 A limit for the search may be given. The start position is assumed to
718 be after it."
722 "Move the point to the first position after the list sexp containing POS,
723 or containing the point if POS is left out. Return t if such a
724 position exists, otherwise nil is returned and the point isn't moved.
726 A limit for the search may be given. The start position is assumed to
727 be before it."
732 "Move the point to the position of the start of the list sexp containing POS,
733 or containing the point if POS is left out. Return t if such a
734 position exists, otherwise nil is returned and the point isn't moved.
736 A limit for the search may be given. The start position is assumed to
737 be after it."
742 "Move the point to the first position inside the first list sexp after POS,
743 or before the point if POS is left out. Return t if such a position
744 exists, otherwise nil is returned and the point isn't moved.
746 A limit for the search may be given. The start position is assumed to
747 be before it."
752 "Move the point to the last position inside the last list sexp before POS,
753 or before the point if POS is left out. Return t if such a position
754 exists, otherwise nil is returned and the point isn't moved.
756 A limit for the search may be given. The start position is assumed to
757 be after it."
760 \f
762 ;; Wrapper around beginning-of-defun.
763 ;;
764 ;; NOTE: This function should contain the only explicit use of
765 ;; beginning-of-defun in CC Mode. Eventually something better than
766 ;; b-o-d will be available and this should be the only place the
767 ;; code needs to change. Everything else should use
768 ;; (c-beginning-of-defun-1)
769 ;;
770 ;; This is really a bit too large to be a macro but that isn't a
771 ;; problem as long as it only is used in one place in
772 ;; `c-parse-state'.
776 c-enable-xemacs-performance-kludge-p)
778 ;; XEmacs only. This can improve the performance of
779 ;; c-parse-state to between 3 and 60 times faster when
780 ;; braces are hung. It can also degrade performance by
781 ;; about as much when braces are not hung.
783 pos)
793 ;; unbalanced parenthesis, while invalid C code,
794 ;; shouldn't cause an infloop! See unbal.c
796 ;; Punt!
803 ))
805 ;; Emacs, which doesn't have buffer-syntactic-context-depth
808 ;; if defun-prompt-regexp is non-nil, b-o-d won't leave us at the
809 ;; open brace.
814 \f
815 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
816 ;; V i r t u a l S e m i c o l o n s
817 ;;
818 ;; In most CC Mode languages, statements are terminated explicitly by
819 ;; semicolons or closing braces. In some of the CC modes (currently AWK Mode
820 ;; and certain user-specified #define macros in C, C++, etc. (November 2008)),
821 ;; statements are (or can be) terminated by EOLs. Such a statement is said to
822 ;; be terminated by a "virtual semicolon" (VS). A statement terminated by an
823 ;; actual semicolon or brace is never considered to have a VS.
824 ;;
825 ;; The indentation engine (or whatever) tests for a VS at a specific position
826 ;; by invoking the macro `c-at-vsemi-p', which in its turn calls the mode
827 ;; specific function (if any) which is the value of the language variable
828 ;; `c-at-vsemi-p-fn'. This function should only use "low-level" features of
829 ;; CC Mode, i.e. features which won't trigger infinite recursion. ;-) The
830 ;; actual details of what constitutes a VS in a language are thus encapsulated
831 ;; in code specific to that language (e.g. cc-awk.el). `c-at-vsemi-p' returns
832 ;; non-nil if point (or the optional parameter POS) is at a VS, nil otherwise.
833 ;;
834 ;; The language specific function might well do extensive analysis of the
835 ;; source text, and may use a caching scheme to speed up repeated calls.
836 ;;
837 ;; The "virtual semicolon" lies just after the last non-ws token on the line.
838 ;; Like POINT, it is considered to lie between two characters. For example,
839 ;; at the place shown in the following AWK source line:
840 ;;
841 ;; kbyte = 1024 # 1000 if you're not picky
842 ;; ^
843 ;; |
844 ;; Virtual Semicolon
845 ;;
846 ;; In addition to `c-at-vsemi-p-fn', a mode may need to supply a function for
847 ;; `c-vsemi-status-unknown-p-fn'. The macro `c-vsemi-status-unknown-p' is a
848 ;; rather recondite kludge. It exists because the function
849 ;; `c-beginning-of-statement-1' sometimes tests for VSs as an optimization,
850 ;; but `c-at-vsemi-p' might well need to call `c-beginning-of-statement-1' in
851 ;; its calculations, thus potentially leading to infinite recursion.
852 ;;
853 ;; The macro `c-vsemi-status-unknown-p' resolves this problem; it may return
854 ;; non-nil at any time; returning nil is a guarantee that an immediate
855 ;; invocation of `c-at-vsemi-p' at point will NOT call
856 ;; `c-beginning-of-statement-1'. `c-vsemi-status-unknown-p' may not itself
857 ;; call `c-beginning-of-statement-1'.
858 ;;
859 ;; The macro `c-vsemi-status-unknown-p' will typically check the caching
860 ;; scheme used by the `c-at-vsemi-p-fn', hence the name - the status is
861 ;; "unknown" if there is no cache entry current for the line.
862 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
865 ;; Is there a virtual semicolon (not a real one or a }) at POS (defaults to
866 ;; point)? Always returns nil for languages which don't have Virtual
867 ;; semicolons.
868 ;; This macro might do hidden buffer changes.
873 ;; Return NIL only if it can be guaranteed that an immediate
874 ;; (c-at-vsemi-p) will NOT call c-beginning-of-statement-1. Otherwise,
875 ;; return non-nil. (See comments above). The function invoked by this
876 ;; macro MUST NOT UNDER ANY CIRCUMSTANCES itself call
877 ;; c-beginning-of-statement-1.
878 ;; Languages which don't have EOL terminated statements always return NIL
879 ;; (they _know_ there's no vsemi ;-).
882 \f
884 ;; Formats an error message for the echo area and dings, i.e. like
885 ;; `error' but doesn't abort.
891 ;; Temporarily switches to the specified syntax table in a failsafe
892 ;; way to execute code.
893 ;; Maintainers' note: If TABLE is `c++-template-syntax-table', DON'T call
894 ;; any forms inside this that call `c-parse-state'. !!!!
904 "Skip over any whitespace following point.
905 This function skips over horizontal and vertical whitespace and line
906 continuations."
910 ;; skip-syntax-* doesn't count \n as whitespace..
925 "Skip over any whitespace preceding point.
926 This function skips over horizontal and vertical whitespace and line
927 continuations."
931 ;; skip-syntax-* doesn't count \n as whitespace..
947 "Return non-nil if the current CC Mode major mode is MODE.
948 MODE is either a mode symbol or a list of mode symbols."
951 ;; Inside a `c-lang-defconst'.
965 \f
966 ;; Macros/functions to handle so-called "char properties", which are
967 ;; properties set on a single character and that never spread to any
968 ;; other characters.
971 ;; Constant used at compile time to decide whether or not to use
972 ;; XEmacs extents. Check all the extent functions we'll use since
973 ;; some packages might add compatibility aliases for some of them in
974 ;; Emacs.
989 ;; `c-put-char-property' is complex enough in XEmacs and Emacs < 21 to
990 ;; make it a function.
994 ;; XEmacs.
1004 end-open t)))))))))
1007 ;; In Emacs < 21 we have to mess with the `rear-nonsticky' property.
1014 'rear-nonsticky
1016 ;; This won't be used for anything.
1021 ;; Put the given property with the given value on the character at
1022 ;; POS and make it front and rear nonsticky, or start and end open
1023 ;; in XEmacs vocabulary. If the character already has the given
1024 ;; property then the value is replaced, and the behavior is
1025 ;; undefined if that property has been put by some other function.
1026 ;; PROPERTY is assumed to be constant.
1027 ;;
1028 ;; If there's a `text-property-default-nonsticky' variable (Emacs
1029 ;; 21) then it's assumed that the property is present on it.
1030 ;;
1031 ;; This macro does a hidden buffer change.
1035 ;; XEmacs and Emacs < 21.
1037 ;; In Emacs 21 we got the `rear-nonsticky' property covered
1038 ;; by `text-property-default-nonsticky'.
1043 ;; Get the value of the given property on the character at POS if
1044 ;; it's been put there by `c-put-char-property'. PROPERTY is
1045 ;; assumed to be constant.
1048 ;; XEmacs.
1051 ;; Emacs.
1054 ;; `c-clear-char-property' is complex enough in Emacs < 21 to make it
1055 ;; a function, since we have to mess with the `rear-nonsticky' property.
1065 'rear-nonsticky
1071 ;; Remove the given property on the character at POS if it's been put
1072 ;; there by `c-put-char-property'. PROPERTY is assumed to be
1073 ;; constant.
1074 ;;
1075 ;; This macro does a hidden buffer change.
1078 ;; XEmacs.
1082 ;; In Emacs 21 we got the `rear-nonsticky' property covered
1083 ;; by `text-property-default-nonsticky'.
1088 ;; Emacs < 21.
1092 ;; Remove all the occurrences of the given property in the given
1093 ;; region that has been put with `c-put-char-property'. PROPERTY is
1094 ;; assumed to be constant.
1095 ;;
1096 ;; Note that this function does not clean up the property from the
1097 ;; lists of the `rear-nonsticky' properties in the region, if such
1098 ;; are used. Thus it should not be used for common properties like
1099 ;; `syntax-table'.
1100 ;;
1101 ;; This macro does hidden buffer changes.
1104 ;; XEmacs.
1108 ;; Emacs.
1112 "Search forward for a text-property PROPERTY having value VALUE.
1113 LIMIT bounds the search. The comparison is done with `equal'.
1115 Leave point just after the character, and set the match data on
1116 this character, and return point. If VALUE isn't found, Return
1117 nil; point is then left undefined."
1131 "Search backward for a text-property PROPERTY having value VALUE.
1132 LIMIT bounds the search. The comparison is done with `equal'.
1134 Leave point just before the character, set the match data on this
1135 character, and return point. If VALUE isn't found, Return nil;
1136 point is then left undefined."
1144 ;; XEmacs > 2005-01-25.
1145 'previous-single-char-property-change
1146 ;; Emacs and earlier XEmacs.
1155 "Remove all text-properties PROPERTY from the region (FROM, TO)
1156 which have the value VALUE, as tested by `equal'. These
1157 properties are assumed to be over individual characters, having
1158 been put there by c-put-char-property. POINT remains unchanged."
1170 ;; Do we have to do anything with stickiness here?
1174 "Remove all text-properties PROPERTY from the region [FROM, TO)
1175 which have the value VALUE, as tested by `equal'. These
1176 properties are assumed to be over individual characters, having
1177 been put there by c-put-char-property. POINT remains unchanged."
1179 ;; XEmacs
1185 ;; GNU Emacs
1190 "Search forward for a text-property PROPERTY having value VALUE on a
1191 character with value CHAR.
1192 LIMIT bounds the search. The value comparison is done with `equal'.
1193 PROPERTY must be a constant.
1195 Leave point just after the character, and set the match data on
1196 this character, and return point. If the search fails, return
1197 nil; point is then left undefined."
1212 value char)
1213 "Remove all text-properties PROPERTY with value VALUE on
1214 characters with value CHAR from the region [FROM, TO), as tested
1215 by `equal'. These properties are assumed to be over individual
1216 characters, having been put there by c-put-char-property. POINT
1217 remains unchanged."
1219 )
1230 ;; Do we have to do anything with stickiness here?
1234 "Remove all text-properties PROPERTY with value VALUE on
1235 characters with value CHAR from the region [FROM, TO), as tested
1236 by `equal'. These properties are assumed to be over individual
1237 characters, having been put there by c-put-char-property. POINT
1238 remains unchanged."
1240 ;; XEmacs
1247 -char-))
1250 ;; Gnu Emacs
1255 ;; This needs to be a macro because `property' passed to
1256 ;; `c-put-char-property' must be a constant.
1257 "Put the text property PROPERTY with value VALUE on characters
1258 with value CHAR in the region [FROM to)."
1267 \f
1268 ;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text.
1269 ;; For our purposes, these are characterized by being possible to
1270 ;; remove again without affecting the other text properties in the
1271 ;; buffer that got overridden when they were put.
1274 ;; Put an overlay/extent covering the given range in the current
1275 ;; buffer. It's currently undefined whether it's front/end sticky
1276 ;; or not. The overlay/extent object is returned.
1278 ;; Emacs.
1281 ol)
1282 ;; XEmacs.
1285 ext)))
1288 ;; Deletes an overlay/extent object previously retrieved using
1289 ;; `c-put-overlay'.
1291 ;; Emacs.
1293 ;; XEmacs.
1296 \f
1297 ;; Make edebug understand the macros.
1298 ;(eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
1299 ; '(progn
1332 \f
1333 ;;; Functions.
1335 ;; Note: All these after the macros, to be on safe side in avoiding
1336 ;; bugs where macros are defined too late. These bugs often only show
1337 ;; when the files are compiled in a certain order within the same
1338 ;; session.
1341 ;; Replacement for end-of-defun that use c-beginning-of-defun-1.
1343 ;; Skip forward into the next defun block. Don't bother to avoid
1344 ;; comments, literals etc, since beginning-of-defun doesn't do that
1345 ;; anyway.
1354 ;; Mark the "<" character at POS as a template opener using the
1355 ;; `syntax-table' property either directly (XEmacs) or via a `category'
1356 ;; property (GNU Emacs).
1357 ;;
1358 ;; This function does a hidden buffer change. Note that we use
1359 ;; indirection through the `category' text property. This allows us to
1360 ;; toggle the property in all template brackets simultaneously and
1361 ;; cheaply. We use this, for instance, in `c-parse-state'.
1368 ;; Mark the ">" character at POS as an sexp list closer using the
1369 ;; `syntax-table' property either directly (XEmacs) or via a `category'
1370 ;; property (GNU Emacs).
1371 ;;
1372 ;; This function does a hidden buffer change. Note that we use
1373 ;; indirection through the `category' text property. This allows us to
1374 ;; toggle the property in all template brackets simultaneously and
1375 ;; cheaply. We use this, for instance, in `c-parse-state'.
1381 ;; Unmark the "<" or "<" character at POS as an sexp list opener using the
1382 ;; `syntax-table' property either directly or indirectly through a
1383 ;; `category' text property.
1384 ;;
1385 ;; This function does a hidden buffer change. Note that we try to use
1386 ;; indirection through the `category' text property. This allows us to
1387 ;; toggle the property in all template brackets simultaneously and
1388 ;; cheaply. We use this, for instance, in `c-parse-state'.
1392 ;; Suppress the syntactic effect of all marked < and > as parens. Note
1393 ;; that this effect is NOT buffer local. You should probably not use
1394 ;; this directly, but only through the macro
1395 ;; `c-with-<->-as-parens-suppressed'
1400 ;; Restore the syntactic effect of all marked <s and >s as parens. This
1401 ;; has no effect on unmarked <s and >s
1406 ;; Like progn, except that the paren property is suppressed on all
1407 ;; template brackets whilst they are running. This macro does a hidden
1408 ;; buffer change.
1415 ;;;;;;;;;;;;;;;
1418 ;; This is the value of the `category' text property placed on every #
1419 ;; which introduces a CPP construct and every EOL (or EOB, or character
1420 ;; preceding //, etc.) which terminates it. We can instantly "comment
1421 ;; out" all CPP constructs by giving `c-cpp-delimiter' a syntax-table
1422 ;; property '(14) (generic comment delimiter).
1424 ;; This macro does a hidden buffer change.
1430 ;; This macro does a hidden buffer change.
1437 ;; Render all preprocessor constructs syntactically commented out.
1440 ;; Restore the syntactic visibility of preprocessor constructs.
1444 ;; Execute FORMS... whilst the syntactic effect of all characters in
1445 ;; all CPP regions is suppressed. In particular, this is to suppress
1446 ;; the syntactic significance of parens/braces/brackets to functions
1447 ;; such as `scan-lists' and `parse-partial-sexp'.
1456 ;; Execute FORMS... whilst the syntactic effect of all characters in
1457 ;; every CPP region APART FROM THE ONE BETWEEN BEG and END is
1458 ;; suppressed.
1471 ;; Bind the state cache to itself and execute the FORMS. Return the result
1472 ;; of the last FORM executed. It is assumed that no buffer changes will
1473 ;; happen in FORMS, and no hidden buffer changes which could affect the
1474 ;; parsing will be made by FORMS.
1477 ;(c-state-nonlit-pos-cache (copy-tree c-state-nonlit-pos-cache))
1478 ;(c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache-limit)
1479 ;(c-state-semi-nonlit-pos-cache (copy-tree c-state-semi-nonlit-pos-cache))
1480 ;(c-state-semi-nonlit-pos-cache-limit c-state-semi-nonlit-pos-cache)
1488 c-state-old-cpp-beg-marker))
1490 c-state-old-cpp-beg-marker
1491 c-state-old-cpp-beg))
1494 c-state-old-cpp-end-marker))
1496 c-state-old-cpp-end-marker
1497 c-state-old-cpp-end))
1506 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1507 ;; The following macros are to be used only in `c-parse-state' and its
1508 ;; subroutines. Their main purpose is to simplify the handling of C++/Java
1509 ;; template delimiters and CPP macros. In GNU Emacs, this is done slickly by
1510 ;; the judicious use of 'category properties. These don't exist in XEmacs.
1511 ;;
1512 ;; Note: in the following macros, there is no special handling for parentheses
1513 ;; inside CPP constructs. That is because CPPs are always syntactically
1514 ;; balanced, thanks to `c-neutralize-CPP-line' in cc-mode.el.
1516 ;; Do a (scan-lists FROM 1 1). Any finishing position which either (i) is
1517 ;; determined by and angle bracket; or (ii) is inside a macro whose start
1518 ;; isn't POINT-MACRO-START doesn't count as a finishing position.
1523 pos))
1526 ;; Do a (scan-lists FROM 1 -1). Any finishing position which either (i) is
1527 ;; determined by an angle bracket; or (ii) is inside a macro whose start
1528 ;; isn't POINT-MACRO-START doesn't count as a finishing position.
1534 pos))
1537 ;; Do a (scan-lists FROM -1 1). Any finishing position which either (i) is
1538 ;; determined by and angle bracket; or (ii) is inside a macro whose start
1539 ;; isn't POINT-MACRO-START doesn't count as a finishing position.
1544 pos))
1547 ;; Do a (scan-lists FROM -1 -1). Any finishing position which either (i) is
1548 ;; determined by and angle bracket; or (ii) is inside a macro whose start
1549 ;; isn't POINT-MACRO-START doesn't count as a finishing position.
1555 pos))
1573 oldstate)
1574 ;; Do a parse-partial-sexp using the supplied arguments, disregarding
1575 ;; template/generic delimiters < > and disregarding macros other than the
1576 ;; one at POINT-MACRO-START.
1577 ;;
1578 ;; NOTE that STOPBEFORE must be nil. TARGETDEPTH should be one less than
1579 ;; the depth in OLDSTATE. This function is thus a SPECIAL PURPOSE variation
1580 ;; on parse-partial-sexp, designed for calling from
1581 ;; `c-remove-stale-state-cache'.
1582 ;;
1583 ;; Any finishing position which is determined by an angle bracket delimiter
1584 ;; doesn't count as a finishing position.
1585 ;;
1586 ;; Note there is no special handling of CPP constructs here, since these are
1587 ;; always syntactically balanced (thanks to `c-neutralize-CPP-line').
1592 ;; We must have hit targetdepth.
1601 state))
1604 oldstate)
1610 \f
1614 "Are we looking at a character which isn't alphanumeric or space?"
1623 \f
1625 ;; return the element of ALIST that matches the first element found
1626 ;; in LIST. Uses assq.
1631 match))
1634 ;; first, find the first entry from LIST that is present in ALIST1,
1635 ;; then find the entry in ALIST2 for that entry.
1639 "Return the syntactic symbol in LANGELEM.
1643 form as used in `c-syntactic-element'."
1647 "Return the anchor position in LANGELEM, or nil if there is none.
1651 form as used in `c-syntactic-element'."
1657 "Return the column of the anchor position in LANGELEM.
1658 Also move the point to that position unless PRESERVE-POINT is non-nil.
1662 form as used in `c-syntactic-element'."
1674 "Return the secondary position in LANGELEM, or nil if there is none.
1677 in `c-syntactic-element'. It may also be a cons cell as passed in the
1678 first argument to lineup functions, but then the returned value always
1679 will be nil."
1683 ;; Do whatever is necessary to keep the region active in XEmacs.
1684 ;; This is not needed for Emacs.
1698 the corresponding symbol."
1704 c-buffer-is-cc-mode))
1709 the value of the variable with that name."
1713 "Return non-nil if position POS in the current buffer has any of the
1714 faces in the list FACES."
1721 pos-faces)
1725 ;; Return t if FACENAME is the name of a face. This method is
1726 ;; necessary since facep in XEmacs only returns t for the actual
1727 ;; face objects (while it's only their names that are used just
1728 ;; about anywhere else) without providing a predicate that tests
1729 ;; face names.
1733 "Like `concat' on LIST, but separate each element with SEPARATOR.
1734 Notably, null elements in LIST are ignored."
1738 "Make a regexp that matches all the strings the list.
1739 Duplicates and nil elements in the list are removed. The
1740 resulting regexp may contain zero or more submatch expressions.
1742 If ADORN is t there will be at least one submatch and the first
1743 surrounds the matched alternative, and the regexp will also not match
1744 a prefix of any identifier. Adorned regexps cannot be appended. The
1745 language variable `c-nonsymbol-key' is used to make the adornment.
1747 A value `appendable' for ADORN is like above, but all alternatives in
1749 instead, so that the regexp remains appendable. Note that this
1750 variant doesn't always guarantee that an identifier prefix isn't
1751 matched since the symbol constituent `_' is normally considered a
1754 The optional MODE specifies the language to get `c-nonsymbol-key' from
1755 when it's needed. The default is the current language taken from
1756 `c-buffer-is-cc-mode'."
1763 ;; This is kludgy but it works: Search for a string that
1764 ;; doesn't occur in any word in LIST. Append it to all
1765 ;; the alternatives where we want to add \>. Run through
1766 ;; `regexp-opt' and then replace it with \>.
1770 pos list)
1774 nil)
1775 t))
1777 found))
1791 ;; Emacs 20 and XEmacs (all versions so far) has a buggy
1792 ;; regexp-opt that doesn't always cope with strings containing
1793 ;; newlines. This kludge doesn't handle shy parens correctly
1794 ;; so we can't advice regexp-opt directly with it.
1818 ;; Add our own grouping parenthesis around re instead of
1819 ;; passing adorn to `regexp-opt', since in XEmacs it makes the
1820 ;; top level grouping "shy".
1829 re)))
1831 ;; Produce a regexp that matches nothing.
1839 "Make a character alternative string from the list of characters CHARS.
1840 The returned string is of the type that can be used with
1841 `skip-chars-forward' and `skip-chars-backward'. If INVERTED is
1842 non-nil, a caret is prepended to invert the set."
1843 ;; This function ought to be in the elisp core somewhere.
1849 ;; Quoting necessary (this method only works in the skip
1850 ;; functions).
1853 ;; Check for range.
1861 str))
1863 ;; Leftovers from (X)Emacs 19 compatibility.
1867 \f
1868 ;; Figure out what features this Emacs has
1876 ;; I've no idea what this actually is, but it's legacy. /mast
1879 ;; XEmacs uses 8-bit modify-syntax-entry flags.
1880 ;; Emacs uses a 1-bit flag. We will have to set up our
1881 ;; syntax tables differently to handle this.
1883 entry)
1886 ;; Emacs
1889 ;; In Emacs, table entries are cons cells
1891 ;; XEmacs
1894 ;; incompatible
1899 list)))
1901 ;; Check whether beginning/end-of-defun call
1902 ;; beginning/end-of-defun-function nicely, passing through the
1903 ;; argument and respecting the return code.
1923 ;; Record whether the `category' text property works.
1927 parse-sexp-lookup-properties
1928 parse-sexp-ignore-comments
1933 ;; For some reason we have to set some of these after the
1934 ;; buffer has been made current. (Specifically,
1935 ;; `parse-sexp-ignore-comments' in Emacs 21.)
1937 parse-sexp-ignore-comments t
1938 lookup-syntax-properties t)
1940 ;; Find out if the `syntax-table' text property works.
1951 "CC Mode is incompatible with this version of Emacs - "
1952 "support for the `syntax-table' text property "
1955 ;; Find out if "\\s!" (generic comment delimiters) work.
1961 ;; Find out if "\\s|" (generic string delimiters) work.
1967 ;; See if POSIX char classes work.
1969 ;; All versions of Emacs 21 so far haven't fixed
1970 ;; char classes in `skip-chars-forward' and
1971 ;; `skip-chars-backward'.
1980 ;; See if `open-paren-in-column-0-is-defun-start' exists and
1981 ;; isn't buggy (Emacs >= 21.4).
1989 ;; XEmacs. Afaik this is currently an Emacs-only
1990 ;; feature, but it's good to be prepared.
1994 ;; Emacs
2007 ;; Check how many elements `parse-partial-sexp' returns.
2017 "CC Mode is incompatible with this version of Emacs - "
2020 ;;(message "c-emacs-features: %S" list)
2021 list)
2022 "A list of certain features in the (X)Emacs you are using.
2023 There are many flavors of Emacs out there, each with different
2024 features supporting those needed by CC Mode. The following values
2025 might be present:
2027 `8-bit' 8 bit syntax entry flags (XEmacs style).
2028 `1-bit' 1 bit syntax entry flags (Emacs style).
2029 `argumentative-bod-function' beginning-of-defun and end-of-defun pass
2030 ARG through to beginning/end-of-defun-function.
2031 `syntax-properties' It works to override the syntax for specific characters
2032 in the buffer with the `syntax-table' property. It's
2033 always set - CC Mode no longer works in emacsen without
2034 this feature.
2035 `category-properties' Syntax routines can add a level of indirection to text
2036 properties using the `category' property.
2037 `gen-comment-delim' Generic comment delimiters work
2038 (i.e. the syntax class `!').
2039 `gen-string-delim' Generic string delimiters work
2040 (i.e. the syntax class `|').
2041 `pps-extended-state' `parse-partial-sexp' returns a list with at least 11
2042 elements, i.e. it indicates having stopped after the
2043 first character of a potential two-char construct.
2044 `posix-char-classes' The regexp engine understands POSIX character classes.
2045 `col-0-paren' It's possible to turn off the ad-hoc rule that a paren
2046 in column zero is the start of a defun.
2047 `infodock' This is Infodock (based on XEmacs).
2051 \f
2052 ;;; Some helper constants.
2054 ;; If the regexp engine supports POSIX char classes then we can use
2055 ;; them to handle extended charsets correctly.
2069 \f
2070 ;;; System for handling language dependent constants.
2072 ;; This is used to set various language dependent data in a flexible
2073 ;; way: Language constants can be built from the values of other
2074 ;; language constants, also those for other languages. They can also
2075 ;; process the values of other language constants uniformly across all
2076 ;; the languages. E.g. one language constant can list all the type
2077 ;; keywords in each language, and another can build a regexp for each
2078 ;; language from those lists without code duplication.
2079 ;;
2080 ;; Language constants are defined with `c-lang-defconst', and their
2081 ;; value forms (referred to as source definitions) are evaluated only
2082 ;; on demand when requested for a particular language with
2083 ;; `c-lang-const'. It's therefore possible to refer to the values of
2084 ;; constants defined later in the file, or in another file, just as
2085 ;; long as all the relevant `c-lang-defconst' have been loaded when
2086 ;; `c-lang-const' is actually evaluated from somewhere else.
2087 ;;
2088 ;; `c-lang-const' forms are also evaluated at compile time and
2089 ;; replaced with the values they produce. Thus there's no overhead
2090 ;; for this system when compiled code is used - only the values
2091 ;; actually used in the code are present, and the file(s) containing
2092 ;; the `c-lang-defconst' forms don't need to be loaded at all then.
2093 ;; There are however safeguards to make sure that they can be loaded
2094 ;; to get the source definitions for the values if there's a mismatch
2095 ;; in compiled versions, or if `c-lang-const' is used uncompiled.
2096 ;;
2097 ;; Note that the source definitions in a `c-lang-defconst' form are
2098 ;; compiled into the .elc file where it stands; there's no need to
2099 ;; load the source file to get it.
2100 ;;
2101 ;; See cc-langs.el for more details about how this system is deployed
2102 ;; in CC Mode, and how the associated language variable system
2103 ;; (`c-lang-defvar') works. That file also contains a lot of
2104 ;; examples.
2107 "Declare a new language in the language dependent variable system.
2108 This is intended to be used by modes that inherit CC Mode to add new
2109 languages. It should be used at the top level before any calls to
2110 `c-lang-defconst'. MODE is the mode name symbol for the new language,
2111 and BASE-MODE is the mode name symbol for the language in CC Mode that
2112 is to be the template for the new mode.
2114 The exact effect of BASE-MODE is to make all language constants that
2115 haven't got a setting in the new language fall back to their values in
2116 BASE-MODE. It does not have any effect outside the language constant
2117 system."
2126 ;; Obarray used as a cache to keep track of the language constants.
2127 ;; The constants stored are those defined by `c-lang-defconst' and the values
2128 ;; computed by `c-lang-const'. It's mostly used at compile time but it's not
2129 ;; stored in compiled files.
2131 ;; The obarray contains all the language constants as symbols. The
2132 ;; value cells hold the evaluated values as alists where each car is
2133 ;; the mode name symbol and the corresponding cdr is the evaluated
2134 ;; value in that mode. The property lists hold the source definitions
2135 ;; and other miscellaneous data. The obarray might also contain
2136 ;; various other symbols, but those don't have any variable bindings.
2140 ;; Ugly hack to pull in the definition of `cc-bytecomp-compiling-or-loading'
2141 ;; from cc-bytecomp to make it available at loadtime. This is the same
2142 ;; mechanism used in cc-mode.el for `c-populate-syntax-table'.
2149 ;; Return the base name of the current file.
2161 "Can be used inside a VAL in `c-lang-defconst' to evaluate FORM
2162 immediately, i.e. at the same time as the `c-lang-defconst' form
2163 itself is evaluated."
2164 ;; Evaluate at macro expansion time, i.e. in the
2165 ;; `c--macroexpand-all' inside `c-lang-defconst'.
2169 "Set the language specific values of the language constant NAME.
2170 The second argument can optionally be a docstring. The rest of the
2171 arguments are one or more repetitions of LANG VAL where LANG specifies
2172 the language(s) that VAL applies to. LANG is the name of the
2174 of such language names, or t for all languages. VAL is a form to
2175 evaluate to get the value.
2177 If LANG isn't t or one of the core languages in CC Mode, it must
2178 have been declared with `c-add-language'.
2180 Neither NAME, LANG nor VAL are evaluated directly - they should not be
2181 quoted. `c-lang-defconst-eval-immediately' can however be used inside
2182 VAL to evaluate parts of it directly.
2184 When VAL is evaluated for some language, that language is temporarily
2185 made current so that `c-lang-const' without an explicit language can
2186 be used inside VAL to refer to the value of a language constant in the
2187 same language. That is particularly useful if LANG is t.
2189 VAL is not evaluated right away but rather when the value is requested
2190 with `c-lang-const'. Thus it's possible to use `c-lang-const' inside
2191 VAL to refer to language constants that haven't been defined yet.
2192 However, if the definition of a language constant is in another file
2193 then that file must be loaded \(at compile time) before it's safe to
2194 reference the constant.
2196 The assignments in ARGS are processed in sequence like `setq', so
2197 \(c-lang-const NAME) may be used inside a VAL to refer to the last
2198 assigned value to this language constant, or a value that it has
2199 gotten in another earlier loaded file.
2201 To work well with repeated loads and interactive reevaluation, only
2202 one `c-lang-defconst' for each NAME is permitted per file. If there
2203 already is one it will be completely replaced; the value in the
2204 earlier definition will not affect `c-lang-const' on the same
2205 constant. A file is identified by its base name."
2208 ;; Make `c-lang-const' expand to a straightforward call to
2209 ;; `c-get-lang-constant' in `c--macroexpand-all' below.
2210 ;;
2211 ;; (The default behavior, i.e. to expand to a call inside
2212 ;; `eval-when-compile' should be equivalent, since that macro
2213 ;; should only expand to its content if it's used inside a
2214 ;; form that's already evaluated at compile time. It's
2215 ;; however necessary to use our cover macro
2216 ;; `cc-eval-when-compile' due to bugs in `eval-when-compile',
2217 ;; and it expands to a bulkier form that in this case only is
2218 ;; unnecessary garbage that we don't want to store in the
2219 ;; language constant source definitions.)
2225 bindings
2226 pre-files)
2232 ;; The docstring is hardly used anywhere since there's no normal
2233 ;; symbol to attach it to. It's primarily for getting the right
2234 ;; format in the source.
2241 ;; Rework ARGS to an association list to make it easier to handle.
2242 ;; It's reversed at the same time to make it easier to implement
2243 ;; the demand-driven (i.e. reversed) evaluation in `c-lang-const'.
2260 val)
2267 ;; Emacs has a weird bug where it seems to fail to read
2268 ;; backquote lists from byte compiled files correctly (,@
2269 ;; forms, to be specific), so make sure the bindings in the
2270 ;; expansion below don't contain any backquote stuff.
2271 ;; (XEmacs handles it correctly and doesn't need this for that
2272 ;; reason, but we also use this expansion handle
2273 ;; `c-lang-defconst-eval-immediately' and to register
2274 ;; dependencies on the `c-lang-const's in VAL.)
2280 ;; Compile in the other files that have provided source
2281 ;; definitions for this symbol, to make sure the order in the
2282 ;; `source' property is correct even when files are loaded out of
2283 ;; order.
2286 ;; This can happen when the source file (e.g. cc-langs.el) is first
2287 ;; loaded as source, setting a 'source property entry, and then itself
2288 ;; being compiled.
2290 ;; Reverse to get the right load order.
2298 ;(eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
2299 ; '
2304 ;; Used by `c-lang-defconst'.
2313 ;;(when (cdr-safe elem)
2314 ;; (message "Language constant %s redefined in %S" name file))
2316 ;; Note that the order in the source alist is relevant. Like how
2317 ;; `c-lang-defconst' reverses the bindings, this reverses the
2318 ;; order between files so that the last to evaluate comes first.
2328 ;; Bind the symbol as a variable, or clear any earlier evaluated
2329 ;; value it has.
2332 ;; Clear the evaluated values that depend on this source.
2335 ptr)
2348 name))
2351 "Get the mode specific value of the language constant NAME in language LANG.
2352 LANG is the name of the language, i.e. the mode name without the
2354 `c-lang-defvar', LANG may be left out to refer to the current
2355 language. NAME and LANG are not evaluated so they should not be
2356 quoted."
2368 lang))
2371 ;; No need to find out the source file(s) when we evaluate
2372 ;; immediately since all the info is already there in the
2373 ;; `source' property.
2379 ;; Get the source file(s) that must be loaded to get the value
2380 ;; of the constant. If the symbol isn't defined yet we assume
2381 ;; that its definition will come later in this file, and thus
2382 ;; are no file dependencies needed.
2384 ;; Reverse to get the right load order.
2387 nil ; Exclude our own file.
2391 ;; Make some effort to do a compact call to
2392 ;; `c-get-lang-constant' since it will be compiled in.
2402 ;; Either a straight call is requested in the context, or
2403 ;; we're in an "uncontrolled" context and got no language,
2404 ;; or we're not being byte compiled so the compile time
2405 ;; stuff below is unnecessary.
2408 ;; Being compiled. If the loading and compiling version is
2409 ;; the same we use a value that is evaluated at compile time,
2410 ;; otherwise it's evaluated at runtime.
2417 "Alist of constants in the process of being evaluated.
2418 The `cdr' of each entry indicates how far we've looked in the list
2419 of definitions, so that the def for var FOO in c-mode can be defined in
2420 terms of the def for that same var FOO (which will then rely on the
2426 ;; Used by `c-lang-const'.
2434 elem
2438 ;; Record the dependencies between this symbol and the one we're
2439 ;; being evaluated in.
2444 ;; Make sure the source files have entries on the `source'
2445 ;; property so that loading will take place when necessary.
2450 ;; Might pull in more definitions which affect the value. The
2451 ;; clearing of dependent values etc is done when the
2452 ;; definition is encountered during the load; this is just to
2453 ;; jump past the check for a cached value below.
2461 ;; Check if an evaluation of this symbol is already underway.
2462 ;; In that case we just continue with the "assignment" before
2463 ;; the one currently being evaluated, thereby creating the
2464 ;; illusion if a `setq'-like sequence of assignments.
2469 ;; Append `c-lang-constants-under-evaluation' even if an
2470 ;; earlier entry is found. It's only necessary to get
2471 ;; the recording of dependencies above correct.
2475 value
2476 ;; Make sure the recursion limits aren't very low
2477 ;; since the `c-lang-const' dependencies can go deep.
2484 ;; First try the original mode but don't accept an
2485 ;; entry matching all languages since the fallback
2486 ;; mode might have an explicit entry before that.
2489 c-lang--novalue)
2490 ;; Try again with the fallback mode from the
2491 ;; original position. Note that
2492 ;; `c-buffer-is-cc-mode' still is the real mode if
2493 ;; language parameterization takes place.
2496 fallback t name))
2497 c-lang--novalue)))
2498 ;; A simple lookup with no fallback mode.
2501 c-lang--novalue))
2503 "`%s' got no (prior) value in %S (might be a cyclic reference)"
2504 name mode))
2509 ;; Print a message to aid in locating the error. We don't
2510 ;; print the error itself since that will be done later by
2511 ;; some caller higher up.
2513 sym mode)
2518 value))))
2521 ;; Find the first assignment entry that applies to MODE at or after
2522 ;; SOURCE-POS. If MATCH-ANY-LANG is non-nil, entries with t as
2523 ;; the language list are considered to match, otherwise they don't.
2524 ;; On return SOURCE-POS is updated to point to the next assignment
2525 ;; after the returned one. If no assignment is found,
2526 ;; `c-lang--novalue' is returned as a magic value.
2527 ;;
2528 ;; SOURCE-POS is a vector that points out a specific assignment in
2529 ;; the double alist that's used in the `source' property. The first
2530 ;; element is the position in the top alist which is indexed with
2531 ;; the source files, and the second element is the position in the
2532 ;; nested bindings alist.
2533 ;;
2534 ;; NAME is only used for error messages.
2539 assignment)
2542 t
2543 ;; Handled the last assignment from one file, begin on the
2544 ;; next. Due to the check in `c-lang-defconst', we know
2545 ;; there's at least one.
2550 ;; The file containing the source definitions has not
2551 ;; been loaded.
2554 ;;(message (concat "Loading %s to get the source "
2555 ;; "value for language constant %s")
2556 ;; file name)
2560 ;; The load didn't fill in the source for the
2561 ;; constant as expected. The situation is
2562 ;; probably that a derived mode was written for
2563 ;; and compiled with another version of CC Mode,
2564 ;; and the requested constant isn't in the
2565 ;; currently loaded one. Put in a dummy
2566 ;; assignment that matches no language.
2571 t))
2579 match-any-lang)
2582 c-lang--novalue)))
2585 ;; `c-major-mode-is' expands to a call to this function inside
2586 ;; `c-lang-defconst'. Here we also match the mode(s) against any
2587 ;; fallback modes for the one in `c-buffer-is-cc-mode', so that
2588 ;; e.g. (c-major-mode-is 'c++-mode) is true in a derived language
2589 ;; that has c++-mode as base mode.
2596 nil)
2598 match))
2600 \f
2603 ;; Local Variables:
2604 ;; indent-tabs-mode: t
2605 ;; tab-width: 8
2606 ;; End:
2607 ;;; cc-defs.el ends here