| blob | f360cc3355943ffef5a65af459094543f5aaef17 |
1 ;;; cc-defs.el --- compile time definitions for CC Mode
3 ;; Copyright (C) 1985, 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
4 ;; 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
5 ;; Free Software Foundation, Inc.
7 ;; Authors: 2003- Alan Mackenzie
8 ;; 1998- Martin Stjernholm
9 ;; 1992-1999 Barry A. Warsaw
10 ;; 1987 Dave Detlefs
11 ;; 1987 Stewart Clamen
12 ;; 1985 Richard M. Stallman
13 ;; Maintainer: bug-cc-mode@gnu.org
14 ;; Created: 22-Apr-1997 (split from cc-mode.el)
15 ;; Version: See cc-mode.el
16 ;; Keywords: c languages oop
18 ;; This file is part of GNU Emacs.
20 ;; GNU Emacs is free software: you can redistribute it and/or modify
21 ;; it under the terms of the GNU General Public License as published by
22 ;; the Free Software Foundation, either version 3 of the License, or
23 ;; (at your option) any later version.
25 ;; GNU Emacs is distributed in the hope that it will be useful,
26 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
27 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
28 ;; GNU General Public License for more details.
30 ;; You should have received a copy of the GNU General Public License
31 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
33 ;;; Commentary:
35 ;; This file contains macros, defsubsts, and various other things that
36 ;; must be loaded early both during compilation and at runtime.
38 ;;; Code:
45 load-path)))
51 ;; Silence the compiler.
65 \f
66 ;; cc-fix.el contains compatibility macros that should be used if
67 ;; needed.
73 ; (eval-after-load "font-lock" ; 2006-07-09. font-lock is now preloaded
74 ; '
76 ; to make the call to f-l-c-k throw an error.
83 ;; The above takes care of the delayed loading, but this is necessary
84 ;; to ensure correct byte compilation.
92 font-lock-keywords)))
95 \f
96 ;;; Variables also used at compile time.
102 ;; A little more compact and faster in comparisons.
105 "Non-nil for all buffers with a major mode derived from CC Mode.
106 Otherwise, this variable is nil. I.e. this variable is non-nil for
107 `c-mode', `c++-mode', `objc-mode', `java-mode', `idl-mode',
108 `pike-mode', `awk-mode', and any other non-CC Mode mode that calls
109 `c-initialize-cc-mode'. The value is the mode symbol itself
110 \(i.e. `c-mode' etc) of the original CC Mode mode, or just t if it's
114 ;; Have to make `c-buffer-is-cc-mode' permanently local so that it
115 ;; survives the initialization of the derived mode.
118 \f
119 ;; The following is used below during compilation.
124 "Like `progn', but evaluates the body at compile time.
125 The result of the body appears to the compiler as a quoted constant.
127 This variant works around bugs in `eval-when-compile' in various
128 \(X)Emacs versions. See cc-defs.el for details."
131 ;; XEmacs 21.4.6 has a bug in `eval-when-compile' in that it
132 ;; evaluates its body at macro expansion time if it's nested
133 ;; inside another `eval-when-compile'. So we use a dynamically
134 ;; bound variable to avoid nesting them.
138 ;; In all (X)Emacsen so far, `eval-when-compile' byte compiles
139 ;; its contents before evaluating it. That can cause forms to
140 ;; be compiled in situations they aren't intended to be
141 ;; compiled.
142 ;;
143 ;; Example: It's not possible to defsubst a primitive, e.g. the
144 ;; following will produce an error (in any emacs flavor), since
145 ;; `nthcdr' is a primitive function that's handled specially by
146 ;; the byte compiler and thus can't be redefined:
147 ;;
148 ;; (defsubst nthcdr (val) val)
149 ;;
150 ;; `defsubst', like `defmacro', needs to be evaluated at
151 ;; compile time, so this will produce an error during byte
152 ;; compilation.
153 ;;
154 ;; CC Mode occasionally needs to do things like this for
155 ;; cross-emacs compatibility. It therefore uses the following
156 ;; to conditionally do a `defsubst':
157 ;;
158 ;; (eval-when-compile
159 ;; (if (not (fboundp 'foo))
160 ;; (defsubst foo ...)))
161 ;;
162 ;; But `eval-when-compile' byte compiles its contents and
163 ;; _then_ evaluates it (in all current emacs versions, up to
164 ;; and including Emacs 20.6 and XEmacs 21.1 as of this
165 ;; writing). So this will still produce an error, since the
166 ;; byte compiler will get to the defsubst anyway. That's
167 ;; arguably a bug because the point with `eval-when-compile' is
168 ;; that it should evaluate rather than compile its contents.
169 ;;
170 ;; We get around it by expanding the body to a quoted
171 ;; constant that we eval. That otoh introduce a problem in
172 ;; that a returned lambda expression doesn't get byte
173 ;; compiled (even if `function' is used).
178 \f
179 ;;; Macros.
182 "Return the value of certain commonly referenced POSITIONs relative to POINT.
183 The current point is used if POINT isn't specified. POSITION can be
184 one of the following symbols:
186 `bol' -- beginning of line
187 `eol' -- end of line
188 `bod' -- beginning of defun
189 `eod' -- end of defun
190 `boi' -- beginning of indentation
191 `ionl' -- indentation of next line
192 `iopl' -- indentation of previous line
193 `bonl' -- beginning of next line
194 `eonl' -- end of next line
195 `bopl' -- beginning of previous line
196 `eopl' -- end of previous line
197 `bosws' -- beginning of syntactic whitespace
198 `eosws' -- end of syntactic whitespace
200 If the referenced position doesn't exist, the closest accessible point
201 to it is returned. This function does not modify the point or the mark."
303 ;; The bulk of this should perhaps be in a function to avoid large
304 ;; expansions, but this case is not used anywhere in CC Mode (and
305 ;; probably not anywhere else either) so we only have it to be on
306 ;; the safe side.
337 ;; Return t when the region is active. The determination of region
338 ;; activeness is different in both Emacs and XEmacs.
340 ;; Emacs.
341 'mark-active
342 ;; XEmacs.
346 ;; Activate the region if ACTIVE is non-nil, deactivate it
347 ;; otherwise. Covers the differences between Emacs and XEmacs.
349 ;; XEmacs.
353 ;; Emacs.
357 "Delete the text between START and END and return it."
359 ;; Emacs 21.1 and later
361 ;; XEmacs and Emacs 20.x
367 ;; safely execute BODY, return nil if an error occurred
374 ;; In GNU Emacs, a character is an integer. In XEmacs, a character is a
375 ;; type distinct from an integer. Sometimes we need to convert integers to
376 ;; characters. `c-int-to-char' makes this conversion, if necessary.
379 integer))
382 ;; Get the regular expression `sentence-end'.
384 ;; Emacs 22:
386 ;; Emacs <22 + XEmacs
390 ;; Get the default value of the variable sentence end.
392 ;; Emacs 22:
394 ;; Emacs <22 + XEmacs
397 ;; The following is essentially `save-buffer-state' from lazy-lock.el.
398 ;; It ought to be a standard macro.
400 "Bind variables according to VARLIST (in `let*' style) and eval BODY,
401 then restore the buffer state under the assumption that no significant
402 modification has been made in BODY. A change is considered
403 significant if it affects the buffer text in any way that isn't
404 completely restored again. Changes in text properties like `face' or
405 `syntax-table' are considered insignificant. This macro allows text
406 properties to be changed, even in a read-only buffer.
408 This macro should be placed around all calculations which set
410 known to be writable. That way, these text properties remain set
411 even if the user undoes the command which set them.
414 changes \(like adding a newline to calculate a text-property then
415 deleting it again\), so that the user never sees them on his
416 `buffer-undo-list'. See also `c-tentative-buffer-changes'.
418 However, any user-visible changes to the buffer \(like auto-newlines\)
419 must not be within a `c-save-buffer-state', since the user then
420 wouldn't be able to undo them.
422 The return value is the value of the last form in BODY."
425 before-change-functions after-change-functions
426 deactivate-mark
427 buffer-file-name buffer-file-truename ; Prevent primitives checking
428 ; for file modification
438 "Eval BODY and optionally restore the buffer contents to the state it
439 was in before BODY. Any changes are kept if the last form in BODY
440 returns non-nil. Otherwise it's undone using the undo facility, and
441 various other buffer state that might be affected by the changes is
442 restored. That includes the current buffer, point, mark, mark
443 activation \(similar to `save-excursion'), and the modified state.
444 The state is also restored if BODY exits nonlocally.
446 If BODY makes a change that unconditionally is undone then wrap this
447 macro inside `c-save-buffer-state'. That way the change can be done
448 even when the buffer is read-only, and without interference from
449 various buffer change hooks."
451 -tnt-chng-state)
453 ;; Insert an undo boundary for use with `undo-more'. We
454 ;; don't use `undo-boundary' since it doesn't insert one
455 ;; unconditionally.
463 ;; Used internally in `c-tentative-buffer-changes'.
466 ;; No need to use markers for the point and mark; if the
467 ;; undo got out of synch we're hosed anyway.
474 ;; Used internally in `c-tentative-buffer-changes'.
478 ;; No change was done afterall.
482 ;; Find and remove the undo boundary.
488 ;; `primitive-undo' will remove the boundary.
493 saved-undo-list))))
505 "Forward skip over syntactic whitespace.
506 Syntactic whitespace is defined as whitespace characters, comments,
507 and preprocessor directives. However if point starts inside a comment
508 or preprocessor directive, the content of it is not treated as
509 whitespace.
511 LIMIT sets an upper limit of the forward movement, if specified. If
512 LIMIT or the end of the buffer is reached inside a comment or
513 preprocessor directive, the point will be left there.
515 Note that this function might do hidden buffer changes. See the
516 comment at the start of cc-engine.el for more info."
524 "Backward skip over syntactic whitespace.
525 Syntactic whitespace is defined as whitespace characters, comments,
526 and preprocessor directives. However if point starts inside a comment
527 or preprocessor directive, the content of it is not treated as
528 whitespace.
530 LIMIT sets a lower limit of the backward movement, if specified. If
531 LIMIT is reached inside a line comment or preprocessor directive then
532 the point is moved into it past the whitespace at the end.
534 Note that this function might do hidden buffer changes. See the
535 comment at the start of cc-engine.el for more info."
543 "Move forward across COUNT balanced expressions.
544 A negative COUNT means move backward. Signal an error if the move
545 fails for any reason.
547 This is like `forward-sexp' except that it isn't interactive and does
548 not do any user friendly adjustments of the point and that it isn't
549 susceptible to user configurations such as disabling of signals in
550 certain situations."
555 "See `c-forward-sexp' and reverse directions."
560 "Like `scan-lists' but returns nil instead of signalling errors
561 for unbalanced parens.
563 A limit for the search may be given. FROM is assumed to be on the
564 right side of it."
578 res)))
580 \f
581 ;; Wrappers for common scan-lists cases, mainly because it's almost
582 ;; impossible to get a feel for how that function works.
585 "Move backward across one balanced group of parentheses.
587 Return POINT when we succeed, NIL when we fail. In the latter case, leave
588 point unmoved."
591 endpos)))
594 "Move backward across one balanced group of parentheses.
596 Return POINT when we succeed, NIL when we fail. In the latter case, leave
597 point unmoved."
600 endpos)))
603 "Return the first position after the list sexp containing POS,
604 or nil if no such position exists. The point is used if POS is left out.
606 A limit for the search may be given. The start position is assumed to
607 be before it."
611 "Return the position of the start of the list sexp containing POS,
612 or nil if no such position exists. The point is used if POS is left out.
614 A limit for the search may be given. The start position is assumed to
615 be after it."
619 "Return the first position inside the first list sexp after POS,
620 or nil if no such position exists. The point is used if POS is left out.
622 A limit for the search may be given. The start position is assumed to
623 be before it."
627 "Return the last position inside the last list sexp before POS,
628 or nil if no such position exists. The point is used if POS is left out.
630 A limit for the search may be given. The start position is assumed to
631 be after it."
635 "Move the point to the first position after the list sexp containing POS,
636 or containing the point if POS is left out. Return t if such a
637 position exists, otherwise nil is returned and the point isn't moved.
639 A limit for the search may be given. The start position is assumed to
640 be before it."
646 res)))
649 "Move the point to the position of the start of the list sexp containing POS,
650 or containing the point if POS is left out. Return t if such a
651 position exists, otherwise nil is returned and the point isn't moved.
653 A limit for the search may be given. The start position is assumed to
654 be after it."
660 res)))
663 "Move the point to the first position inside the first list sexp after POS,
664 or before the point if POS is left out. Return t if such a position
665 exists, otherwise nil is returned and the point isn't moved.
667 A limit for the search may be given. The start position is assumed to
668 be before it."
674 res)))
677 "Move the point to the last position inside the last list sexp before POS,
678 or before the point if POS is left out. Return t if such a position
679 exists, otherwise nil is returned and the point isn't moved.
681 A limit for the search may be given. The start position is assumed to
682 be after it."
688 res)))
690 \f
692 ;; Wrapper around beginning-of-defun.
693 ;;
694 ;; NOTE: This function should contain the only explicit use of
695 ;; beginning-of-defun in CC Mode. Eventually something better than
696 ;; b-o-d will be available and this should be the only place the
697 ;; code needs to change. Everything else should use
698 ;; (c-beginning-of-defun-1)
699 ;;
700 ;; This is really a bit too large to be a macro but that isn't a
701 ;; problem as long as it only is used in one place in
702 ;; `c-parse-state'.
706 c-enable-xemacs-performance-kludge-p)
708 ;; XEmacs only. This can improve the performance of
709 ;; c-parse-state to between 3 and 60 times faster when
710 ;; braces are hung. It can also degrade performance by
711 ;; about as much when braces are not hung.
713 pos)
723 ;; unbalanced parenthesis, while invalid C code,
724 ;; shouldn't cause an infloop! See unbal.c
726 ;; Punt!
733 ))
735 ;; Emacs, which doesn't have buffer-syntactic-context-depth
738 ;; if defun-prompt-regexp is non-nil, b-o-d won't leave us at the
739 ;; open brace.
744 \f
745 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
746 ;; V i r t u a l S e m i c o l o n s
747 ;;
748 ;; In most CC Mode languages, statements are terminated explicitly by
749 ;; semicolons or closing braces. In some of the CC modes (currently only AWK
750 ;; Mode (April 2004)), statements are (or can be) terminated by EOLs. Such a
751 ;; statement is said to be terminated by a "virtual semicolon" (VS). A
752 ;; statement terminated by an actual semicolon or brace is never considered to
753 ;; have a VS.
754 ;;
755 ;; The indentation engine (or whatever) tests for a VS at a specific position
756 ;; by invoking the macro `c-at-vsemi-p', which in its turn calls the mode
757 ;; specific function (if any) which is the value of the language variable
758 ;; `c-at-vsemi-p-fn'. The actual details of what constitutes a VS in a
759 ;; language are thus encapsulated in code specific to that language
760 ;; (e.g. cc-awk.el). `c-at-vsemi-p' returns non-nil if point (or the optional
761 ;; parameter POS) is at a VS, nil otherwise.
762 ;;
763 ;; The language specific function might well do extensive analysis of the
764 ;; source text, and may use a cacheing scheme to speed up repeated calls.
765 ;;
766 ;; The "virtual semicolon" lies just after the last non-ws token on the line.
767 ;; Like POINT, it is considered to lie between two characters. For example,
768 ;; at the place shown in the following AWK source line:
769 ;;
770 ;; kbyte = 1024 # 1000 if you're not picky
771 ;; ^
772 ;; |
773 ;; Virtual Semicolon
774 ;;
775 ;; In addition to `c-at-vsemi-p-fn', a mode may need to supply a function for
776 ;; `c-vsemi-status-unknown-p-fn'. The macro `c-vsemi-status-unknown-p' is a
777 ;; rather recondite kludge. It exists because the function
778 ;; `c-beginning-of-statement-1' sometimes tests for VSs as an optimisation,
779 ;; but `c-at-vsemi-p' might well need to call `c-beginning-of-statement-1' in
780 ;; its calculations, thus potentially leading to infinite recursion.
781 ;;
782 ;; The macro `c-vsemi-status-unknown-p' resolves this problem; it may return
783 ;; non-nil at any time; returning nil is a guarantee that an immediate
784 ;; invocation of `c-at-vsemi-p' at point will NOT call
785 ;; `c-beginning-of-statement-1'. `c-vsemi-status-unknown-p' may not itself
786 ;; call `c-beginning-of-statement-1'.
787 ;;
788 ;; The macro `c-vsemi-status-unknown-p' will typically check the cacheing
789 ;; scheme used by the `c-at-vsemi-p-fn', hence the name - the status is
790 ;; "unknown" if there is no cache entry current for the line.
791 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
794 ;; Is there a virtual semicolon (not a real one or a }) at POS (defaults to
795 ;; point)? Always returns nil for languages which don't have Virtual
796 ;; semicolons.
797 ;; This macro might do hidden buffer changes.
802 ;; Return NIL only if it can be guaranteed that an immediate
803 ;; (c-at-vsemi-p) will NOT call c-beginning-of-statement-1. Otherwise,
804 ;; return non-nil. (See comments above). The function invoked by this
805 ;; macro MUST NOT UNDER ANY CIRCUMSTANCES itself call
806 ;; c-beginning-of-statement-1.
807 ;; Languages which don't have EOL terminated statements always return NIL
808 ;; (they _know_ there's no vsemi ;-).
811 \f
813 ;; Formats an error message for the echo area and dings, i.e. like
814 ;; `error' but doesn't abort.
820 ;; Temporarily switches to the specified syntax table in a failsafe
821 ;; way to execute code.
831 "Skip over any whitespace following point.
832 This function skips over horizontal and vertical whitespace and line
833 continuations."
837 ;; skip-syntax-* doesn't count \n as whitespace..
852 "Skip over any whitespace preceding point.
853 This function skips over horizontal and vertical whitespace and line
854 continuations."
858 ;; skip-syntax-* doesn't count \n as whitespace..
874 "Return non-nil if the current CC Mode major mode is MODE.
875 MODE is either a mode symbol or a list of mode symbols."
878 ;; Inside a `c-lang-defconst'.
892 \f
893 ;; Macros/functions to handle so-called "char properties", which are
894 ;; properties set on a single character and that never spread to any
895 ;; other characters.
898 ;; Constant used at compile time to decide whether or not to use
899 ;; XEmacs extents. Check all the extent functions we'll use since
900 ;; some packages might add compatibility aliases for some of them in
901 ;; Emacs.
910 ;; `c-put-char-property' is complex enough in XEmacs and Emacs < 21 to
911 ;; make it a function.
915 ;; XEmacs.
925 end-open t)))))))))
928 ;; In Emacs < 21 we have to mess with the `rear-nonsticky' property.
935 'rear-nonsticky
937 ;; This won't be used for anything.
942 ;; Put the given property with the given value on the character at
943 ;; POS and make it front and rear nonsticky, or start and end open
944 ;; in XEmacs vocabulary. If the character already has the given
945 ;; property then the value is replaced, and the behavior is
946 ;; undefined if that property has been put by some other function.
947 ;; PROPERTY is assumed to be constant.
948 ;;
949 ;; If there's a `text-property-default-nonsticky' variable (Emacs
950 ;; 21) then it's assumed that the property is present on it.
951 ;;
952 ;; This macro does a hidden buffer change.
956 ;; XEmacs and Emacs < 21.
958 ;; In Emacs 21 we got the `rear-nonsticky' property covered
959 ;; by `text-property-default-nonsticky'.
964 ;; Get the value of the given property on the character at POS if
965 ;; it's been put there by `c-put-char-property'. PROPERTY is
966 ;; assumed to be constant.
969 ;; XEmacs.
972 ;; Emacs.
975 ;; `c-clear-char-property' is complex enough in Emacs < 21 to make it
976 ;; a function, since we have to mess with the `rear-nonsticky' property.
986 'rear-nonsticky
992 ;; Remove the given property on the character at POS if it's been put
993 ;; there by `c-put-char-property'. PROPERTY is assumed to be
994 ;; constant.
995 ;;
996 ;; This macro does a hidden buffer change.
999 ;; XEmacs.
1003 ;; In Emacs 21 we got the `rear-nonsticky' property covered
1004 ;; by `text-property-default-nonsticky'.
1009 ;; Emacs < 21.
1013 ;; Remove all the occurences of the given property in the given
1014 ;; region that has been put with `c-put-char-property'. PROPERTY is
1015 ;; assumed to be constant.
1016 ;;
1017 ;; Note that this function does not clean up the property from the
1018 ;; lists of the `rear-nonsticky' properties in the region, if such
1019 ;; are used. Thus it should not be used for common properties like
1020 ;; `syntax-table'.
1021 ;;
1022 ;; This macro does hidden buffer changes.
1025 ;; XEmacs.
1029 ;; Emacs.
1033 "Remove all text-properties PROPERTY from the region (FROM, TO)
1034 which have the value VALUE, as tested by `equal'. These
1035 properties are assumed to be over individual characters, having
1036 been put there by c-put-char-property. POINT remains unchanged."
1048 ;; Do we have to do anything with stickiness here?
1052 "Remove all text-properties PROPERTY from the region [FROM, TO)
1053 which have the value VALUE, as tested by `equal'. These
1054 properties are assumed to be over individual characters, having
1055 been put there by c-put-char-property. POINT remains unchanged."
1057 ;; XEmacs
1063 ;; Gnu Emacs
1065 \f
1066 ;; Macros to put overlays (Emacs) or extents (XEmacs) on buffer text.
1067 ;; For our purposes, these are characterized by being possible to
1068 ;; remove again without affecting the other text properties in the
1069 ;; buffer that got overridden when they were put.
1072 ;; Put an overlay/extent covering the given range in the current
1073 ;; buffer. It's currently undefined whether it's front/end sticky
1074 ;; or not. The overlay/extent object is returned.
1076 ;; Emacs.
1079 ol)
1080 ;; XEmacs.
1083 ext)))
1086 ;; Deletes an overlay/extent object previously retrieved using
1087 ;; `c-put-overlay'.
1089 ;; Emacs.
1091 ;; XEmacs.
1094 \f
1095 ;; Make edebug understand the macros.
1096 ;(eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
1097 ; '(progn
1126 \f
1127 ;;; Functions.
1129 ;; Note: All these after the macros, to be on safe side in avoiding
1130 ;; bugs where macros are defined too late. These bugs often only show
1131 ;; when the files are compiled in a certain order within the same
1132 ;; session.
1135 ;; Replacement for end-of-defun that use c-beginning-of-defun-1.
1137 ;; Skip forward into the next defun block. Don't bother to avoid
1138 ;; comments, literals etc, since beginning-of-defun doesn't do that
1139 ;; anyway.
1150 ;; Mark the "<" character at POS as an sexp list opener using the
1151 ;; syntax-table property.
1152 ;;
1153 ;; This function does a hidden buffer change.
1159 ;; Mark the ">" character at POS as an sexp list closer using the
1160 ;; syntax-table property.
1161 ;;
1162 ;; This function does a hidden buffer change.
1166 ;; return the element of ALIST that matches the first element found
1167 ;; in LIST. Uses assq.
1172 match))
1175 ;; first, find the first entry from LIST that is present in ALIST1,
1176 ;; then find the entry in ALIST2 for that entry.
1180 "Return the syntactic symbol in LANGELEM.
1184 form as used in `c-syntactic-element'."
1188 "Return the anchor position in LANGELEM, or nil if there is none.
1192 form as used in `c-syntactic-element'."
1198 "Return the column of the anchor position in LANGELEM.
1199 Also move the point to that position unless PRESERVE-POINT is non-nil.
1203 form as used in `c-syntactic-element'."
1215 "Return the secondary position in LANGELEM, or nil if there is none.
1218 in `c-syntactic-element'. It may also be a cons cell as passed in the
1219 first argument to lineup functions, but then the returned value always
1220 will be nil."
1224 ;; Do whatever is necessary to keep the region active in XEmacs.
1225 ;; This is not needed for Emacs.
1239 the corresponding symbol."
1245 c-buffer-is-cc-mode))
1250 the value of the variable with that name."
1254 "Return non-nil if position POS in the current buffer has any of the
1255 faces in the list FACES."
1262 pos-faces)
1266 ;; Return t if FACENAME is the name of a face. This method is
1267 ;; necessary since facep in XEmacs only returns t for the actual
1268 ;; face objects (while it's only their names that are used just
1269 ;; about anywhere else) without providing a predicate that tests
1270 ;; face names.
1274 "Like `concat' on LIST, but separate each element with SEPARATOR.
1275 Notably, null elements in LIST are ignored."
1279 "Make a regexp that matches all the strings the list.
1280 Duplicates and nil elements in the list are removed. The resulting
1281 regexp may contain zero or more submatch expressions.
1283 If ADORN is t there will be at least one submatch and the first
1284 surrounds the matched alternative, and the regexp will also not match
1285 a prefix of any identifier. Adorned regexps cannot be appended. The
1286 language variable `c-nonsymbol-key' is used to make the adornment.
1288 A value 'appendable for ADORN is like above, but all alternatives in
1290 instead, so that the regexp remains appendable. Note that this
1291 variant doesn't always guarantee that an identifier prefix isn't
1292 matched since the symbol constituent '_' is normally considered a
1295 The optional MODE specifies the language to get `c-nonsymbol-key' from
1296 when it's needed. The default is the current language taken from
1297 `c-buffer-is-cc-mode'."
1308 ;; This is kludgy but it works: Search for a string that
1309 ;; doesn't occur in any word in LIST. Append it to all
1310 ;; the alternatives where we want to add \>. Run through
1311 ;; `regexp-opt' and then replace it with \>.
1315 pos list)
1319 nil)
1320 t))
1322 found))
1336 ;; Emacs 20 and XEmacs (all versions so far) has a buggy
1337 ;; regexp-opt that doesn't always cope with strings containing
1338 ;; newlines. This kludge doesn't handle shy parens correctly
1339 ;; so we can't advice regexp-opt directly with it.
1363 ;; Add our own grouping parenthesis around re instead of
1364 ;; passing adorn to `regexp-opt', since in XEmacs it makes the
1365 ;; top level grouping "shy".
1374 re)))
1376 ;; Produce a regexp that matches nothing.
1384 "Make a character alternative string from the list of characters CHARS.
1385 The returned string is of the type that can be used with
1386 `skip-chars-forward' and `skip-chars-backward'. If INVERTED is
1387 non-nil, a caret is prepended to invert the set."
1388 ;; This function ought to be in the elisp core somewhere.
1394 ;; Quoting necessary (this method only works in the skip
1395 ;; functions).
1398 ;; Check for range.
1406 str))
1408 ;; Leftovers from (X)Emacs 19 compatibility.
1412 \f
1413 ;; Figure out what features this Emacs has
1421 ;; I've no idea what this actually is, but it's legacy. /mast
1424 ;; XEmacs uses 8-bit modify-syntax-entry flags.
1425 ;; Emacs uses a 1-bit flag. We will have to set up our
1426 ;; syntax tables differently to handle this.
1428 entry)
1431 ;; Emacs
1434 ;; In Emacs, table entries are cons cells
1436 ;; XEmacs
1439 ;; incompatible
1444 list)))
1446 ;; In Emacs >= 23, beginning-of-defun-raw passes its argument to
1447 ;; beginning-of-defun-function. Assume end-of-defun does likewise.
1451 mark-ring)
1457 parse-sexp-lookup-properties
1458 parse-sexp-ignore-comments
1459 lookup-syntax-properties)
1464 ;; For some reason we have to set some of these after the
1465 ;; buffer has been made current. (Specifically,
1466 ;; `parse-sexp-ignore-comments' in Emacs 21.)
1468 parse-sexp-ignore-comments t
1469 lookup-syntax-properties t)
1471 ;; Find out if the `syntax-table' text property works.
1482 "CC Mode is incompatible with this version of Emacs - "
1483 "support for the `syntax-table' text property "
1486 ;; Find out if generic comment delimiters work.
1492 ;; Find out if generic string delimiters work.
1498 ;; See if POSIX char classes work.
1500 ;; All versions of Emacs 21 so far haven't fixed
1501 ;; char classes in `skip-chars-forward' and
1502 ;; `skip-chars-backward'.
1511 ;; See if `open-paren-in-column-0-is-defun-start' exists and
1512 ;; isn't buggy (Emacs >= 21.4).
1520 ;; XEmacs. Afaik this is currently an Emacs-only
1521 ;; feature, but it's good to be prepared.
1525 ;; Emacs
1538 ;; See if `parse-partial-sexp' returns the eighth element.
1543 "CC Mode is incompatible with this version of Emacs - "
1546 ;;(message "c-emacs-features: %S" list)
1547 list)
1548 "A list of certain features in the (X)Emacs you are using.
1549 There are many flavors of Emacs out there, each with different
1550 features supporting those needed by CC Mode. The following values
1551 might be present:
1553 '8-bit 8 bit syntax entry flags (XEmacs style).
1554 '1-bit 1 bit syntax entry flags (Emacs style).
1555 'argumentative-bod-function beginning-of-defun passes ARG through
1556 to a non-null beginning-of-defun-function. It is assumed
1557 the end-of-defun does the same thing.
1558 'syntax-properties It works to override the syntax for specific characters
1559 in the buffer with the 'syntax-table property. It's
1560 always set - CC Mode no longer works in emacsen without
1561 this feature.
1562 'gen-comment-delim Generic comment delimiters work
1563 (i.e. the syntax class `!').
1564 'gen-string-delim Generic string delimiters work
1565 (i.e. the syntax class `|').
1566 'pps-extended-state `parse-partial-sexp' returns a list with at least 10
1567 elements, i.e. it contains the position of the start of
1568 the last comment or string. It's always set - CC Mode
1569 no longer works in emacsen without this feature.
1570 'posix-char-classes The regexp engine understands POSIX character classes.
1571 'col-0-paren It's possible to turn off the ad-hoc rule that a paren
1572 in column zero is the start of a defun.
1573 'infodock This is Infodock (based on XEmacs).
1577 \f
1578 ;;; Some helper constants.
1580 ;; If the regexp engine supports POSIX char classes then we can use
1581 ;; them to handle extended charsets correctly.
1595 \f
1596 ;;; System for handling language dependent constants.
1598 ;; This is used to set various language dependent data in a flexible
1599 ;; way: Language constants can be built from the values of other
1600 ;; language constants, also those for other languages. They can also
1601 ;; process the values of other language constants uniformly across all
1602 ;; the languages. E.g. one language constant can list all the type
1603 ;; keywords in each language, and another can build a regexp for each
1604 ;; language from those lists without code duplication.
1605 ;;
1606 ;; Language constants are defined with `c-lang-defconst', and their
1607 ;; value forms (referred to as source definitions) are evaluated only
1608 ;; on demand when requested for a particular language with
1609 ;; `c-lang-const'. It's therefore possible to refer to the values of
1610 ;; constants defined later in the file, or in another file, just as
1611 ;; long as all the relevant `c-lang-defconst' have been loaded when
1612 ;; `c-lang-const' is actually evaluated from somewhere else.
1613 ;;
1614 ;; `c-lang-const' forms are also evaluated at compile time and
1615 ;; replaced with the values they produce. Thus there's no overhead
1616 ;; for this system when compiled code is used - only the values
1617 ;; actually used in the code are present, and the file(s) containing
1618 ;; the `c-lang-defconst' forms don't need to be loaded at all then.
1619 ;; There are however safeguards to make sure that they can be loaded
1620 ;; to get the source definitions for the values if there's a mismatch
1621 ;; in compiled versions, or if `c-lang-const' is used uncompiled.
1622 ;;
1623 ;; Note that the source definitions in a `c-lang-defconst' form are
1624 ;; compiled into the .elc file where it stands; there's no need to
1625 ;; load the source file to get it.
1626 ;;
1627 ;; See cc-langs.el for more details about how this system is deployed
1628 ;; in CC Mode, and how the associated language variable system
1629 ;; (`c-lang-defvar') works. That file also contains a lot of
1630 ;; examples.
1633 "Declare a new language in the language dependent variable system.
1634 This is intended to be used by modes that inherit CC Mode to add new
1635 languages. It should be used at the top level before any calls to
1636 `c-lang-defconst'. MODE is the mode name symbol for the new language,
1637 and BASE-MODE is the mode name symbol for the language in CC Mode that
1638 is to be the template for the new mode.
1640 The exact effect of BASE-MODE is to make all language constants that
1641 haven't got a setting in the new language fall back to their values in
1642 BASE-MODE. It does not have any effect outside the language constant
1643 system."
1652 ;; This obarray is a cache to keep track of the language constants
1653 ;; defined by `c-lang-defconst' and the evaluated values returned by
1654 ;; `c-lang-const'. It's mostly used at compile time but it's not
1655 ;; stored in compiled files.
1656 ;;
1657 ;; The obarray contains all the language constants as symbols. The
1658 ;; value cells hold the evaluated values as alists where each car is
1659 ;; the mode name symbol and the corresponding cdr is the evaluated
1660 ;; value in that mode. The property lists hold the source definitions
1661 ;; and other miscellaneous data. The obarray might also contain
1662 ;; various other symbols, but those don't have any variable bindings.
1667 ;; Return the base name of the current file.
1670 ;; Being loaded.
1671 load-file-name)
1674 ;; Being compiled.
1675 byte-compile-dest-file)
1677 ;; Being evaluated interactively.
1684 "Can be used inside a VAL in `c-lang-defconst' to evaluate FORM
1685 immediately, i.e. at the same time as the `c-lang-defconst' form
1686 itself is evaluated."
1687 ;; Evaluate at macro expansion time, i.e. in the
1688 ;; `cl-macroexpand-all' inside `c-lang-defconst'.
1691 ;; Only used at compile time - suppress "might not be defined at runtime".
1695 "Set the language specific values of the language constant NAME.
1696 The second argument can optionally be a docstring. The rest of the
1697 arguments are one or more repetitions of LANG VAL where LANG specifies
1698 the language(s) that VAL applies to. LANG is the name of the
1700 of such language names, or `t' for all languages. VAL is a form to
1701 evaluate to get the value.
1703 If LANG isn't `t' or one of the core languages in CC Mode, it must
1704 have been declared with `c-add-language'.
1706 Neither NAME, LANG nor VAL are evaluated directly - they should not be
1707 quoted. `c-lang-defconst-eval-immediately' can however be used inside
1708 VAL to evaluate parts of it directly.
1710 When VAL is evaluated for some language, that language is temporarily
1711 made current so that `c-lang-const' without an explicit language can
1712 be used inside VAL to refer to the value of a language constant in the
1713 same language. That is particularly useful if LANG is `t'.
1715 VAL is not evaluated right away but rather when the value is requested
1716 with `c-lang-const'. Thus it's possible to use `c-lang-const' inside
1717 VAL to refer to language constants that haven't been defined yet.
1718 However, if the definition of a language constant is in another file
1719 then that file must be loaded \(at compile time) before it's safe to
1720 reference the constant.
1722 The assignments in ARGS are processed in sequence like `setq', so
1723 \(c-lang-const NAME) may be used inside a VAL to refer to the last
1724 assigned value to this language constant, or a value that it has
1725 gotten in another earlier loaded file.
1727 To work well with repeated loads and interactive reevaluation, only
1728 one `c-lang-defconst' for each NAME is permitted per file. If there
1729 already is one it will be completely replaced; the value in the
1730 earlier definition will not affect `c-lang-const' on the same
1731 constant. A file is identified by its base name."
1734 ;; Make `c-lang-const' expand to a straightforward call to
1735 ;; `c-get-lang-constant' in `cl-macroexpand-all' below.
1736 ;;
1737 ;; (The default behavior, i.e. to expand to a call inside
1738 ;; `eval-when-compile' should be equivalent, since that macro
1739 ;; should only expand to its content if it's used inside a
1740 ;; form that's already evaluated at compile time. It's
1741 ;; however necessary to use our cover macro
1742 ;; `cc-eval-when-compile' due to bugs in `eval-when-compile',
1743 ;; and it expands to a bulkier form that in this case only is
1744 ;; unnecessary garbage that we don't want to store in the
1745 ;; language constant source definitions.)
1748 bindings
1749 pre-files)
1755 ;; The docstring is hardly used anywhere since there's no normal
1756 ;; symbol to attach it to. It's primarily for getting the right
1757 ;; format in the source.
1764 ;; Rework ARGS to an association list to make it easier to handle.
1765 ;; It's reversed at the same time to make it easier to implement
1766 ;; the demand-driven (i.e. reversed) evaluation in `c-lang-const'.
1783 val)
1790 ;; Emacs has a weird bug where it seems to fail to read
1791 ;; backquote lists from byte compiled files correctly (,@
1792 ;; forms, to be specific), so make sure the bindings in the
1793 ;; expansion below don't contain any backquote stuff.
1794 ;; (XEmacs handles it correctly and doesn't need this for that
1795 ;; reason, but we also use this expansion handle
1796 ;; `c-lang-defconst-eval-immediately' and to register
1797 ;; dependencies on the `c-lang-const's in VAL.)
1803 ;; Compile in the other files that have provided source
1804 ;; definitions for this symbol, to make sure the order in the
1805 ;; `source' property is correct even when files are loaded out of
1806 ;; order.
1808 ;; Reverse to get the right load order.
1816 ;(eval-after-load "edebug" ; 2006-07-09: def-edebug-spec is now in subr.el.
1817 ; '
1822 ;; Used by `c-lang-defconst'.
1831 ;;(when (cdr-safe elem)
1832 ;; (message "Language constant %s redefined in %S" name file))
1834 ;; Note that the order in the source alist is relevant. Like how
1835 ;; `c-lang-defconst' reverses the bindings, this reverses the
1836 ;; order between files so that the last to evaluate comes first.
1846 ;; Bind the symbol as a variable, or clear any earlier evaluated
1847 ;; value it has.
1850 ;; Clear the evaluated values that depend on this source.
1853 ptr)
1866 name))
1869 "Get the mode specific value of the language constant NAME in language LANG.
1870 LANG is the name of the language, i.e. the mode name without the
1872 `c-lang-defvar', LANG may be left out to refer to the current
1873 language. NAME and LANG are not evaluated so they should not be
1874 quoted."
1882 mode source-files args)
1888 "Unknown language %S since it got no `c-mode-prefix' property"
1892 ;; No need to find out the source file(s) when we evaluate
1893 ;; immediately since all the info is already there in the
1894 ;; `source' property.
1899 ;; Get the source file(s) that must be loaded to get the value
1900 ;; of the constant. If the symbol isn't defined yet we assume
1901 ;; that its definition will come later in this file, and thus
1902 ;; are no file dependencies needed.
1904 ;; Reverse to get the right load order.
1908 nil ; Exclude our own file.
1912 ;; Make some effort to do a compact call to
1913 ;; `c-get-lang-constant' since it will be compiled in.
1917 args)))
1922 load-in-progress
1925 ;; Either a straight call is requested in the context, or
1926 ;; we're in an "uncontrolled" context and got no language,
1927 ;; or we're not being byte compiled so the compile time
1928 ;; stuff below is unnecessary.
1931 ;; Being compiled. If the loading and compiling version is
1932 ;; the same we use a value that is evaluated at compile time,
1933 ;; otherwise it's evaluated at runtime.
1942 ;; Used by `c-lang-const'.
1950 elem
1954 ;; Record the dependencies between this symbol and the one we're
1955 ;; being evaluated in.
1960 ;; Make sure the source files have entries on the `source'
1961 ;; property so that loading will take place when necessary.
1966 ;; Might pull in more definitions which affect the value. The
1967 ;; clearing of dependent values etc is done when the
1968 ;; definition is encountered during the load; this is just to
1969 ;; jump past the check for a cached value below.
1977 ;; Check if an evaluation of this symbol is already underway.
1978 ;; In that case we just continue with the "assignment" before
1979 ;; the one currently being evaluated, thereby creating the
1980 ;; illusion if a `setq'-like sequence of assignments.
1985 ;; Append `c-lang-constants-under-evaluation' even if an
1986 ;; earlier entry is found. It's only necessary to get
1987 ;; the recording of dependencies above correct.
1991 value
1992 ;; Make sure the recursion limits aren't very low
1993 ;; since the `c-lang-const' dependencies can go deep.
2000 ;; First try the original mode but don't accept an
2001 ;; entry matching all languages since the fallback
2002 ;; mode might have an explicit entry before that.
2005 c-lang-constants)
2006 ;; Try again with the fallback mode from the
2007 ;; original position. Note that
2008 ;; `c-buffer-is-cc-mode' still is the real mode if
2009 ;; language parameterization takes place.
2012 fallback t name))
2013 c-lang-constants)))
2014 ;; A simple lookup with no fallback mode.
2017 c-lang-constants))
2019 "`%s' got no (prior) value in %s (might be a cyclic reference)"
2020 name mode))
2025 ;; Print a message to aid in locating the error. We don't
2026 ;; print the error itself since that will be done later by
2027 ;; some caller higher up.
2029 sym mode)
2034 value))))
2037 ;; Find the first assignment entry that applies to MODE at or after
2038 ;; SOURCE-POS. If MATCH-ANY-LANG is non-nil, entries with `t' as
2039 ;; the language list are considered to match, otherwise they don't.
2040 ;; On return SOURCE-POS is updated to point to the next assignment
2041 ;; after the returned one. If no assignment is found,
2042 ;; `c-lang-constants' is returned as a magic value.
2043 ;;
2044 ;; SOURCE-POS is a vector that points out a specific assignment in
2045 ;; the double alist that's used in the `source' property. The first
2046 ;; element is the position in the top alist which is indexed with
2047 ;; the source files, and the second element is the position in the
2048 ;; nested bindings alist.
2049 ;;
2050 ;; NAME is only used for error messages.
2055 assignment)
2058 t
2059 ;; Handled the last assignment from one file, begin on the
2060 ;; next. Due to the check in `c-lang-defconst', we know
2061 ;; there's at least one.
2066 ;; The file containing the source definitions has not
2067 ;; been loaded.
2070 ;;(message (concat "Loading %s to get the source "
2071 ;; "value for language constant %s")
2072 ;; file name)
2076 ;; The load didn't fill in the source for the
2077 ;; constant as expected. The situation is
2078 ;; probably that a derived mode was written for
2079 ;; and compiled with another version of CC Mode,
2080 ;; and the requested constant isn't in the
2081 ;; currently loaded one. Put in a dummy
2082 ;; assignment that matches no language.
2087 t))
2095 match-any-lang)
2098 c-lang-constants)))
2101 ;; `c-major-mode-is' expands to a call to this function inside
2102 ;; `c-lang-defconst'. Here we also match the mode(s) against any
2103 ;; fallback modes for the one in `c-buffer-is-cc-mode', so that
2104 ;; e.g. (c-major-mode-is 'c++-mode) is true in a derived language
2105 ;; that has c++-mode as base mode.
2112 nil)
2114 match))
2116 \f
2119 ;; arch-tag: 3bb2629d-dd84-4ff0-ad39-584be0fe3cda
2120 ;;; cc-defs.el ends here