| blob | 58d61eb218218ab427cc0b745213b23a5446c531 |
1 ;;; cc-engine.el --- core syntax guessing engine for CC mode
3 ;; Copyright (C) 1985,1987,1992-2001 Free Software Foundation, Inc.
5 ;; Authors: 2000- Martin Stjernholm
6 ;; 1998-1999 Barry A. Warsaw and Martin Stjernholm
7 ;; 1992-1997 Barry A. Warsaw
8 ;; 1987 Dave Detlefs and Stewart Clamen
9 ;; 1985 Richard M. Stallman
10 ;; Maintainer: bug-cc-mode@gnu.org
11 ;; Created: 22-Apr-1997 (split from cc-mode.el)
12 ;; Version: See cc-mode.el
13 ;; Keywords: c languages oop
15 ;; This file is part of GNU Emacs.
17 ;; GNU Emacs is free software; you can redistribute it and/or modify
18 ;; it under the terms of the GNU General Public License as published by
19 ;; the Free Software Foundation; either version 2, or (at your option)
20 ;; any later version.
22 ;; GNU Emacs is distributed in the hope that it will be useful,
23 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
24 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 ;; GNU General Public License for more details.
27 ;; You should have received a copy of the GNU General Public License
28 ;; along with GNU Emacs; see the file COPYING. If not, write to
29 ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
30 ;; Boston, MA 02111-1307, USA.
32 ;;; Commentary:
34 ;; The functions which have docstring documentation can be considered
35 ;; part of an API which other packages can use in CC Mode buffers.
36 ;; Otoh, undocumented functions and functions with the documentation
37 ;; in comments are considered purely internal and can change semantics
38 ;; or even disappear in the future.
39 ;;
40 ;; (This policy applies to CC Mode as a whole, not just this file. It
41 ;; probably also applies to many other Emacs packages, but here it's
42 ;; clearly spelled out.)
44 ;;; Code:
51 load-path)))
58 ;; Silence the compiler.
61 \f
63 ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If
64 ;; arg is nil or zero, toggle the state. If arg is negative, turn
65 ;; the state off, and if arg is positive, turn the state on
71 \f
75 ;; KLUDGE ALERT: c-maybe-labelp is used to pass information between
76 ;; c-crosses-statement-barrier-p and c-beginning-of-statement-1. A
77 ;; better way should be implemented, but this will at least shut up
78 ;; the byte compiler.
81 ;; Macros used internally in c-beginning-of-statement-1 for the
82 ;; automaton actions.
85 stack)))
90 t
91 ,do-if-done
96 ;; Throw nil if stack is empty, else throw non-nil.
120 noerror comma-delim)
121 "Move to the start of the current statement or declaration, or to
122 the previous one if already at the beginning of one. Only
123 statements/declarations on the same level are considered, i.e. don't
124 move into or out of sexps (not even normal expression parentheses).
128 them. If starting at such a continuation, move to the corresponding
129 statement start. If at the beginning of a statement, move to the
130 closest containing statement if there is any. This might also stop at
131 a continuation clause.
133 Labels are treated as separate statements if IGNORE-LABELS is non-nil.
134 The function is not overly intelligent in telling labels from other
135 uses of colons; if used outside a statement context it might trip up
136 on e.g. inherit colons, so IGNORE-LABELS should be used then. There
137 should be no such mistakes in a statement context, however.
139 Macros are ignored unless point is within one, in which case the
140 content of the macro is treated as normal code. Aside from any normal
141 statement starts found in it, stop at the first token of the content
144 leaving them.
146 Return 'label if stopped at a label, 'same if stopped at the beginning
147 of the current statement, 'up if stepped to a containing statement,
148 'previous if stepped to a preceding statement, 'beginning if stepped
149 from a statement continuation clause to its start clause, or 'macro if
150 stepped to a macro start. Note that 'same and not 'label is returned
151 if stopped at the same label without crossing the colon character.
153 LIM may be given to limit the search. If the search hits the limit,
154 point will be left at the closest following token, or at the start
155 position if that is less ('same is returned in this case).
157 NOERROR turns off error logging to `c-parsing-error'.
159 Normally only ';' is considered to delimit statements, but if
160 COMMA-DELIM is non-nil then ',' is treated likewise."
162 ;; The bulk of this function is a pushdown automaton that looks at
163 ;; statement boundaries and the tokens in c-opt-block-stmt-key.
164 ;;
165 ;; Note: The position of a boundary is the following token.
166 ;;
167 ;; Begin with current token, stop when stack is empty and the
168 ;; position has been moved.
169 ;;
170 ;; Common state:
171 ;; "else": Push state, goto state `else':
172 ;; boundary: Goto state `else-boundary':
173 ;; "if": Pop state.
174 ;; boundary: Error, pop state.
175 ;; other: See common state.
176 ;; other: Error, pop state, retry token.
177 ;; "while": Push state, goto state `while':
178 ;; boundary: Save position, goto state `while-boundary':
179 ;; "do": Pop state.
180 ;; boundary: Restore position if it's not at start, pop state.
181 ;; other: See common state.
182 ;; other: Pop state, retry token.
183 ;; "catch" or "finally": Push state, goto state `catch':
184 ;; boundary: Goto state `catch-boundary':
185 ;; "try": Pop state.
186 ;; "catch": Goto state `catch'.
187 ;; boundary: Error, pop state.
188 ;; other: See common state.
189 ;; other: Error, pop state, retry token.
190 ;; other: Do nothing special.
191 ;;
192 ;; In addition to the above there is some special handling of labels
193 ;; and macros.
197 macro-start
200 c-stmt-delim-chars-with-comma
201 c-stmt-delim-chars))
202 pos ; Current position.
203 boundary-pos ; Position of last boundary.
204 after-labels-pos ; Value of tok after first found colon.
205 last-label-pos ; Value of tok after last found colon.
206 sym ; Current symbol in the alphabet.
207 state ; Current state in the automaton.
208 saved-pos ; Current saved positions.
209 stack ; Stack of conses (state . saved-pos).
213 tok ptok pptok ; Pos of last three sexps or bounds.
214 c-in-literal-cache c-maybe-labelp saved)
224 ;; Try to skip over unary operator characters, to register
225 ;; that we've moved.
231 ;; First check for bare semicolon. Later on we ignore the
232 ;; boundaries for statements that doesn't contain any sexp.
233 ;; The only thing that is affected is that the error checking
234 ;; is a little less strict, and we really don't bother.
243 pos saved)
245 ;; Begin at start and not pos to detect macros if we stand
246 ;; directly after the #.
249 ;; Record this as the first token if not starting inside it.
255 ;; Check for macro start.
270 ;; Stop at the first token in the content of the macro.
274 ret 'macro
275 ignore-labels t))
278 ;; Do a round through the automaton if we found a
279 ;; boundary or if looking at a statement keyword.
287 ;; The state handling. Continue in the common state for
288 ;; unhandled cases.
305 ;; Since this can cause backtracking we do a
306 ;; little more careful analysis to avoid it:
307 ;; If there's a label in front of the while
308 ;; it can't be part of a do-while.
337 ;; This is state common.
349 ;; Since this can cause backtracking we do a
350 ;; little more careful analysis to avoid it: If
351 ;; the while isn't followed by a semicolon it
352 ;; can't be a do-while.
361 ;; We're either past a statement boundary or at the
362 ;; start of a statement, so throw away any label data
363 ;; for the previous one.
365 last-label-pos nil
366 c-maybe-labelp nil))))
368 ;; Step to next sexp, but not if we crossed a boundary, since
369 ;; that doesn't consume a sexp.
377 ;; Step again if we hit a line continuation.
378 t)
380 ;; If we started inside a macro then this
381 ;; sexp is always interesting.
382 nil)
384 ;; Otherwise check that we didn't step
385 ;; into a macro from the end.
392 t))))))
394 ;; Check for statement boundary.
399 ;; Need to move over parens and
400 ;; in-expression blocks to get a good start
401 ;; position for the boundary check.
406 ptok tok
407 tok boundary-pos
412 ;; c-crosses-statement-barrier-p has found a colon, so
413 ;; we might be in a label now.
417 c-maybe-labelp t))
419 ;; ObjC method def?
427 pptok ptok
428 ptok tok
432 ;; If the stack isn't empty there might be errors to report.
441 ;; Need to investigate closer whether we've crossed
442 ;; between a substatement and its containing statement.
444 ptok
445 pptok))
450 ;; We're in a label. Maybe we should step to the statement
451 ;; after it.
458 ;; Skip over the unary operators that can start the statement.
465 ret)))
468 "Return non-nil if buffer positions FROM to TO cross one or more
469 statement or declaration boundaries. The returned value is actually
470 the position of the earliest boundary char.
472 The variable `c-maybe-labelp' is set to the position of the first `:' that
473 might start a label (i.e. not part of `::' and not preceded by `?'). If a
474 single `?' is found, then `c-maybe-labelp' is cleared."
476 lit-range)
488 ;; Ignore scope operators.
492 ;; A question mark. Can't be a label, so stop
493 ;; looking for more : and ?.
497 nil))))
499 \f
500 ;; This is a dynamically bound cache used together with
501 ;; c-query-macro-start and c-query-and-set-macro-start. It only works
502 ;; as long as point doesn't cross a macro boundary.
510 c-macro-start))
517 c-macro-start))
520 "Go to the beginning of a cpp macro definition.
521 Leave point at the beginning of the macro and return t if in a cpp
522 macro definition, otherwise return nil and leave point unchanged."
532 t
534 nil))))
537 "Go to the end of a cpp macro definition.
538 More accurately, move point to the end of the closest following line
539 that doesn't end with a line continuation backslash."
545 t))))
548 ;; Insulation from various idiosyncrasies in implementations of
549 ;; `forward-comment'.
550 ;;
551 ;; Note: Some emacsen considers incorrectly that any line comment
552 ;; ending with a backslash continues to the next line. I can't
553 ;; think of any way to work around that in a reliable way without
554 ;; changing the buffer, though. Suggestions welcome. ;) (No,
555 ;; temporarily changing the syntax for backslash doesn't work since
556 ;; we must treat escapes in string literals correctly.)
557 ;;
558 ;; Another note: When moving backwards over a block comment, there's
559 ;; a bug in forward-comment that can make it stop at "/*" inside a
560 ;; line comment. Haven't yet found a reasonably cheap way to kludge
561 ;; around that one either. :\
566 ;; Some emacsen (e.g. XEmacs 21) return t when moving
567 ;; forwards at eob.
568 nil
569 ;; Emacs includes the ending newline in a b-style (c++)
570 ;; comment, but XEmacs doesn't. We depend on the Emacs
571 ;; behavior (which also is symmetric).
574 t))
575 ;; When we got newline terminated comments,
576 ;; forward-comment in all supported emacsen so far will
577 ;; stop at eol of each line not ending with a comment when
578 ;; moving backwards. The following corrects for it when
579 ;; count is -1. The other common case, when count is
580 ;; large and negative, works regardless. It's too much
581 ;; work to correct for the rest of the cases.
584 ;; Some emacsen return t when moving backwards at bob.
585 nil
590 ;; XEmacs treats line continuations as whitespace (but only
591 ;; in the backward direction).
598 res)))))
601 ;; Like `c-forward-comment', but treat line continuations as
602 ;; whitespace.
612 t)
621 t)
623 t))
626 "Forward skip of syntactic whitespace.
627 Syntactic whitespace is defined as whitespace characters, comments,
628 and preprocessor directives. However if point starts inside a comment
629 or preprocessor directive, the content of it is not treated as
630 whitespace. LIM sets an upper limit of the forward movement, if
631 specified."
635 ;; If forward-comment in at least XEmacs 21 is given a large
636 ;; positive value, it'll loop all the way through if it hits eob.
640 ;; Skip line continuations.
643 ;; Skip preprocessor directives.
654 ;; Don't move past the macro if that'd take us past the limit.
656 ;; Skip in-comment line continuations (used for Pike refdoc).
662 "Backward skip of syntactic whitespace.
663 Syntactic whitespace is defined as whitespace characters, comments,
664 and preprocessor directives. However if point starts inside a comment
665 or preprocessor directive, the content of it is not treated as
666 whitespace. LIM sets a lower limit of the backward movement, if
667 specified."
671 prev-pos)
675 ;; If forward-comment in Emacs 19.34 is given a large negative
676 ;; value, it'll loop all the way through if it hits bob.
683 t
684 ;; Passed a line continuation, but not from the line we
685 ;; started on.
699 ;; Don't move past the macro if we began inside it or at
700 ;; the end of the same line, or if the move would take us
701 ;; past the limit.
704 ;; Skip in-comment line continuations (used for Pike refdoc).
709 t)
716 "Move forward by tokens.
717 A token is defined as all symbols and identifiers which aren't
719 tokens). Point is always either left at the beginning of a token or
720 not moved at all. COUNT specifies the number of tokens to move; a
721 negative COUNT moves in the opposite direction. A COUNT of 0 moves to
722 the next token beginning only if not already at one. If BALANCED is
723 true, move over balanced parens, otherwise move into them. Also, if
724 BALANCED is true, never move out of an enclosing paren. LIM sets the
725 limit for the movement and defaults to the point limit.
727 Return the number of tokens left to move \(positive or negative). If
728 BALANCED is true, a move over a balanced paren counts as one. Note
729 that if COUNT is 0 and no appropriate token beginning is found, 1 will
730 be returned. Thus, a return value of 0 guarantees that point is at
731 the requested position and a return value less \(without signs) than
732 COUNT guarantees that point is at the beginning of some token."
745 ;; Skip whitespace. Count this as a move if we did in fact
746 ;; move and aren't out of bounds.
753 ;; If count is zero we should jump if in the middle of a
754 ;; token or if there is whitespace between point and the
755 ;; following token beginning.
759 ;; Avoid having the limit tests inside the loop.
773 count)))
776 "Move backward by tokens.
777 See `c-forward-token-1' for details."
784 last)
793 ;; If count is zero we should jump if in the middle of a
794 ;; token or if there is whitespace between point and the
795 ;; following token beginning.
801 ;; Avoid having the limit tests inside the loop.
813 count)))
816 paren-level)
817 ;; Like `re-search-forward', but only report matches that are found
818 ;; in syntactically significant text. I.e. matches that begins in
819 ;; comments, macros or string literals are ignored. The start point
820 ;; is assumed to be outside any comment, macro or string literal, or
821 ;; else the content of that region is taken as syntactically
822 ;; significant text. If PAREN-LEVEL is non-nil, an additional
823 ;; restriction is added to ignore matches in nested paren sexps, and
824 ;; the search will also not go outside the current paren sexp.
830 match-pos state)
836 paren-level nil state)
839 ;; Match inside a string. Skip to the end of it
840 ;; before continuing.
845 nil nil state)
849 ;; Match inside a line comment. Skip to eol. Use
850 ;; re-search-forward for it to get the right bound
851 ;; behavior.
854 ;; Match inside a block comment. Skip to the '*/'.
857 ;; Match inside a macro. Skip to the end of it.
861 ;; Match inside a nested paren sexp. Skip out of it.
864 ;; Have exited the current paren sexp. The
865 ;; parse-partial-sexp above has left us just after
866 ;; the closing paren in this case. Just make
867 ;; re-search-forward above fail in the appropriate
868 ;; way; we'll adjust the leave off point below if
869 ;; necessary.
872 ;; A real match.
880 match-pos)
881 ;; Search failed. Set point as appropriate.
889 nil)))
891 \f
893 "Return the type of literal point is in, if any.
894 The return value is `c' if in a C-style comment, `c++' if in a C++
895 style comment, `string' if in a string literal, `pound' if DETECT-CPP
896 is non-nil and on a preprocessor line, or nil if somewhere else.
897 Optional LIM is used as the backward limit of the search. If omitted,
898 or nil, `c-beginning-of-defun' is used.
900 The last point calculated is cached if the cache is enabled, i.e. if
901 `c-in-literal-cache' is bound to a two element vector."
913 ;; cache this result if the cache is enabled
916 rtn)))
918 ;; XEmacs has a built-in function that should make this much quicker.
919 ;; I don't think we even need the cache, which makes our lives more
920 ;; complicated anyway. In this case, lim is only used to detect
921 ;; cpp directives.
934 "Return a cons of the beginning and end positions of the comment or
935 string surrounding point (including both delimiters), or nil if point
937 to start parsing from. If NEAR is non-nil, then the limits of any
940 done first in forward direction. If NOT-IN-DELIMITER is non-nil, the
941 case when point is inside a starting delimiter won't be recognized.
942 This only has effect for comments, which have starting delimiters with
943 more than one character."
949 ;; String. Search backward for the start.
956 ;; Line comment. Search from bol for the comment starter.
968 ;; Block comment. Search backward for the comment starter.
977 ;; We're standing in a comment starter.
982 ;; Search forward for a literal.
991 ;; Search backward.
999 ;; Block comment. Due to the nature of line
1000 ;; comments, they will always be covered by the
1001 ;; normal case above.
1004 ;; If LIM is bogus, beg will be bogus.
1007 ))))
1010 ;; Like c-literal-limits, but for emacsen whose `parse-partial-sexp'
1011 ;; returns the pos of the comment start.
1027 ;; We're standing in a comment starter.
1032 ;; Search forward for a literal.
1041 ;; Search backward.
1049 ;; Block comment. Due to the nature of line
1050 ;; comments, they will always be covered by the
1051 ;; normal case above.
1054 ;; If LIM is bogus, beg will be bogus.
1057 ))))
1063 "If the argument is a cons of two buffer positions (such as returned by
1064 `c-literal-limits'), and that range contains a C++ style line comment,
1065 then an extended range is returned that contains all adjacent line
1066 comments (i.e. all comments that starts in the same column with no
1067 empty lines or non-whitespace characters between them). Otherwise the
1068 argument is returned."
1078 ;; Got to take care in the backward direction to handle
1079 ;; comments which are preceded by code.
1093 range)
1097 "Convenience function that given the result of `c-literal-limits',
1098 returns nil or the type of literal that the range surrounds. It's
1099 much faster than using `c-in-literal' and is intended to be used when
1100 you need both the type of a literal and its limits."
1107 range))
1110 \f
1111 ;; utilities for moving and querying around syntactic elements
1115 ;; The state cache used by `c-parse-state' to cut down the amount of
1116 ;; searching. It's the result from some earlier `c-parse-state' call.
1117 ;; The use of the cached info is more effective if the next
1118 ;; `c-parse-state' call is on a line close by the one the cached state
1119 ;; was made at; the cache can actually slow down a little if the
1120 ;; cached state was made very far back in the buffer. The cache is
1121 ;; most effective if `c-parse-state' is used on each line while moving
1122 ;; forward.
1125 ;; This (point-min) when `c-state-cache' was calculated, to detect
1126 ;; that the start point hasn't changed due to narrowing.
1129 ;; Finds and records all noteworthy parens between some good point
1130 ;; earlier in the file and point. That good point is at least the
1131 ;; beginning of the top-level construct we are in, or the beginning
1132 ;; of the preceding top-level construct if we aren't in one.
1133 ;;
1134 ;; The returned value is a list of the noteworthy parens with the
1135 ;; last one first. If an element in the list is an integer, it's
1136 ;; the position of an open paren which has not been closed before
1137 ;; point. If an element is a cons, it gives the position of a
1138 ;; closed brace paren pair; the car is the start paren position and
1139 ;; the cdr is the position following the closing paren. Only the
1140 ;; last closed brace paren pair before each open paren is recorded,
1141 ;; and thus the state never contains two cons elements in
1142 ;; succession.
1147 old-state last-pos pairs pos)
1148 ;; Somewhat ugly use of c-check-state-cache to get rid of the
1149 ;; part of the state cache that is after point. Can't use
1150 ;; c-whack-state-after for the same reasons as in that function.
1152 ;; Get the latest position we know are directly inside the
1153 ;; closest containing paren of the cached state.
1158 ;; Check if the found last-pos is in a macro. If it is, and
1159 ;; we're not in the same macro, we must discard everything on
1160 ;; c-state-cache that is inside the macro before using it.
1167 ;; Set last-pos again, just like above.
1173 ;; Find the start position for the forward search. (Can't
1174 ;; search in the backward direction since point might be
1175 ;; in some kind of literal.)
1177 ;; There's a cached state with a containing paren. Pop
1178 ;; off the stale containing sexps from it by going
1179 ;; forward out of parens as far as possible.
1192 ;; The last paren pair we moved out from was a brace
1193 ;; pair. Modify the state to record this as a closed
1194 ;; pair now.
1198 c-state-cache))))
1199 ;; Check if the preceding balanced paren is within a
1200 ;; macro; it should be ignored if we're outside the
1201 ;; macro. There's no need to check any further upwards;
1202 ;; if the macro contains an unbalanced opening paren then
1203 ;; we're smoked anyway.
1213 last-pos))
1215 ;; go back 2 bods, but ignore any bogus positions
1216 ;; returned by beginning-of-defun (i.e. open paren in
1217 ;; column zero)
1227 ;; Find the balanced brace pairs.
1233 ;; Should ignore any pairs that are in a macro, providing
1234 ;; we're not in the same one.
1240 ;; Record the last brace pair.
1244 ;; There's a closed pair on the cached state but we've
1245 ;; found a later one, so remove it.
1250 ;; There could already be a cons first in `c-state-cache'
1251 ;; if we've jumped over an unbalanced open paren in a
1252 ;; macro below.
1256 ;; Prepare to loop, but record the open paren only if it's
1257 ;; outside a macro or within the same macro as point.
1266 ;; Found a close paren without a corresponding opening
1267 ;; one. Maybe we didn't go back far enough, so try to
1268 ;; scan backward for the start paren and then start over.
1271 c-state-cache nil)
1274 c-parsing-error
1279 c-state-cache)))
1281 ;; Debug tool to catch cache inconsistencies.
1292 res1 res2))
1293 res1))
1298 'c-debug-parse-state
1303 ;; Used on `after-change-functions' to adjust `c-state-cache'.
1304 ;; Prefer speed to finesse here, since there will be many more calls
1305 ;; to this function than times `c-state-cache' is used.
1306 ;;
1307 ;; This is much like `c-whack-state-after', but it never changes a
1308 ;; paren pair element into an open paren element. Doing that would
1309 ;; mean that the new open paren wouldn't have the required preceding
1310 ;; paren pair element.
1313 c-state-cache nil)
1323 ;; Whack off any state information from PAREN-STATE which lies
1324 ;; before BUFPOS. Not destructive on PAREN-STATE.
1327 car)
1338 ;; Whack off any state information from PAREN-STATE which lies at or
1339 ;; after BUFPOS. Not destructive on PAREN-STATE.
1344 ;; just check the car, because in a balanced brace
1345 ;; expression, it must be impossible for the corresponding
1346 ;; close brace to be before point, but the open brace to
1347 ;; be after.
1349 nil ; whack it off
1351 ;; its possible that the open brace is before
1352 ;; bufpos, but the close brace is after. In that
1353 ;; case, convert this to a non-cons element. The
1354 ;; rest of the state is before bufpos, so we're
1355 ;; done.
1357 ;; we know that both the open and close braces are
1358 ;; before bufpos, so we also know that everything else
1359 ;; on state is before bufpos.
1362 nil ; whack it off
1363 ;; it's before bufpos, so everything else should too.
1366 nil)))
1368 \f
1370 ;; Go to the first non-whitespace after the colon that starts a
1371 ;; multiple inheritance introduction. Optional LIM is the farthest
1372 ;; back we should search.
1381 ;; Return nil if we aren't in a method definition, otherwise the
1382 ;; position of the initial [+-].
1388 ))
1390 ;; Contributed by Kevin Ryde <user42@zip.com.au>.
1392 ;; Return non-nil if point is within a gcc \"asm\" block.
1393 ;;
1394 ;; This should be called with point inside an argument list.
1395 ;;
1396 ;; Only one level of enclosing parentheses is considered, so for
1397 ;; instance `nil' is returned when in a function call within an asm
1398 ;; operand.
1408 "Return a determination as to whether point is at the `top-level'.
1409 Being at the top-level means that point is either outside any
1410 enclosing block (such function definition), or inside a class,
1411 namespace or extern definition, but outside any method blocks.
1413 If point is not at the top-level (e.g. it is inside a method
1414 definition), then nil is returned. Otherwise, if point is at a
1415 top-level not enclosed within a class definition, t is returned.
1416 Otherwise, a 2-vector is returned where the zeroth element is the
1417 buffer position of the start of the class declaration, and the first
1418 element is the buffer position of the enclosing class's opening
1419 brace."
1425 ;; Assuming point is at the "#" that introduces a preprocessor
1426 ;; directive, it's moved forward to the start of the definition body
1427 ;; if it's a "#define". Non-nil is returned in this case, in all
1428 ;; other cases nil is returned and point isn't moved.
1437 ;; Return t if we are between a function's argument list closing
1438 ;; paren and its opening brace. Note that the list close brace
1439 ;; could be followed by a "const" specifier or a member init hanging
1440 ;; colon. Optional CONTAINING is position of containing s-exp open
1441 ;; brace. If not supplied, point is used as search start. LIM is
1442 ;; used as bound for some backward buffer searches; the search might
1443 ;; continue past it.
1444 ;;
1445 ;; Note: This test is easily fooled. It only works reasonably well
1446 ;; in the situations where `c-guess-basic-syntax' uses it.
1451 ;; could be looking at const specifier
1456 ;; otherwise, we could be looking at a hanging member init
1457 ;; colon
1460 ;; this will catch member inits with multiple
1461 ;; line arglists
1473 nil
1475 )
1478 ;; Check that it isn't a cpp expression, e.g. the
1479 ;; expression of an #if directive or the "function header"
1480 ;; of a #define.
1484 ;; check if we are looking at an ObjC method def
1492 ;; or a class category
1496 )))))
1497 )))
1500 ;; Return the position of the first argument declaration if point is
1501 ;; inside a K&R style argument declaration list, nil otherwise.
1502 ;; `c-recognize-knr-p' is not checked. If LIM is non-nil, it's a
1503 ;; position that bounds the backward search for the argument list.
1504 ;;
1505 ;; Note: A declaration level context is assumed; the test can return
1506 ;; false positives for statements and #define headers. This test is
1507 ;; even more easily fooled than `c-just-after-func-arglist-p'.
1510 ;; Go back to the closest preceding normal parenthesis sexp. We
1511 ;; take that as the argument list in the function header. Then
1512 ;; check that it's followed by some symbol before the next ';'
1513 ;; or '{'. If it does, it's the header of the K&R argdecl we're
1514 ;; in.
1527 ;; skip forward over conditional at point, including any predicate
1528 ;; statements in parentheses. No error checking is performed.
1530 ;; else if()
1535 ;; do, else, try, finally
1540 ;; for, if, while, switch, catch, synchronized, foreach
1544 ;; If looking at the token after a conditional then return the
1545 ;; position of its start, otherwise return nil.
1555 ;; Assuming point is at a brace that opens a statement block of some
1556 ;; kind, move to the proper anchor point for that block. It might
1557 ;; need to be adjusted further by c-add-stmt-syntax, but the
1558 ;; position at return is suitable as start position for that
1559 ;; function.
1566 ;; Assuming point is at a brace that opens the block of a top level
1567 ;; declaration of some kind, move to the proper anchor point for
1568 ;; that block.
1570 ;; What we have below is actually an extremely stripped variant of
1571 ;; c-beginning-of-statement-1.
1573 ;; Switch syntax table to avoid stopping at line continuations.
1584 ;; Search forward for the end of the "header" of the current
1585 ;; declaration. That's the position where the definition body
1586 ;; starts, or the first variable initializer, or the ending
1587 ;; semicolon. I.e. search forward for the closest following
1588 ;; (syntactically relevant) '{', '=' or ';' token. Point is left
1589 ;; _after_ the first found token, or at point-max if none is found.
1591 c++-template-syntax-table
1594 ;; In Pike it can be an operator identifier containing
1595 ;; '='.
1601 ;; Go to the beginning of the current declaration, or the beginning
1602 ;; of the previous one if already at the start of it. Point won't
1603 ;; be moved out of any surrounding paren. Return a cons cell on the
1604 ;; form (MOVE . KNR-POS). MOVE is like the return value from
1605 ;; `c-beginning-of-statement-1'. If point skipped over some K&R
1606 ;; style argument declarations (and they are to be recognized) then
1607 ;; KNR-POS is set to the start of the first such argument
1608 ;; declaration, otherwise KNR-POS is nil. If LIM is non-nil, it's a
1609 ;; position that bounds the backward search.
1610 ;;
1611 ;; NB: Cases where the declaration continues after the block, as in
1612 ;; "struct foo { ... } bar;", are currently recognized as two
1613 ;; declarations, e.g. "struct foo { ... }" and "bar;" in this case.
1623 ;; `c-beginning-of-statement-1' stops at a block start, but we
1624 ;; want to continue if the block doesn't begin a top level
1625 ;; construct, i.e. if it isn't preceded by ';', '}', ':', or bob.
1631 ;; Handle K&R argdecls. Back up after the "statement" jumped
1632 ;; over by `c-beginning-of-statement-1', unless it was the
1633 ;; function body, in which case we're sitting on the opening
1634 ;; brace now. Then test if we're in a K&R argdecl region and
1635 ;; that we started at the other side of the first argdecl in
1636 ;; it.
1646 'previous
1648 knr-argdecl-start))
1652 ;; Might have ended up before a protection label. This should
1653 ;; perhaps be checked before `c-recognize-knr-p' to be really
1654 ;; accurate, but we know that no language has both.
1662 ;; `c-beginning-of-statement-1' counts each brace block as a
1663 ;; separate statement, so the result will be 'previous if we've
1664 ;; moved over any. If they were brace list initializers we might
1665 ;; not have moved over a declaration boundary though, so change it
1666 ;; to 'same if we've moved past a '=' before '{', but not ';'.
1667 ;; (This ought to be integrated into `c-beginning-of-statement-1',
1668 ;; so we avoid this extra pass which potentially can search over a
1669 ;; large amount of text.)
1672 c++-template-syntax-table
1685 ;; Assuming point is at the start of a declaration (as detected by
1686 ;; e.g. `c-beginning-of-decl-1'), go to the end of it. Unlike
1687 ;; `c-beginning-of-decl-1', this function handles the case when a
1688 ;; block is followed by identifiers in e.g. struct declarations in C
1689 ;; or C++. If a proper end was found then t is returned, otherwise
1690 ;; point is moved as far as possible within the current sexp and nil
1691 ;; is returned. This function doesn't handle macros; use
1692 ;; `c-end-of-macro' instead in those cases.
1695 c++-template-syntax-table
1703 ;; Stopped at the ';' in a K&R argdecl section which is
1704 ;; detected using the same criteria as in
1705 ;; `c-beginning-of-decl-1'. Move to the following block
1706 ;; start.
1710 ;; Encountered a block in the declaration. Jump over it.
1721 ;; Check for `c-opt-block-decls-with-vars-key'
1722 ;; before the first paren.
1725 c-opt-block-decls-with-vars-key
1730 ;; Check that the first following paren is the block.
1733 ;; The declaration doesn't have any of the
1734 ;; `c-opt-block-decls-with-vars' keywords in the
1735 ;; beginning, so it ends here at the end of the block.
1743 nil)))
1746 ;; Goes to the beginning of a member init list (i.e. just after the
1747 ;; ':') if inside one. Returns t in that case, nil otherwise.
1756 ;; this will catch member inits with multiple
1757 ;; line arglists
1763 ;; Skip over any template arg to the class.
1769 ;; Skip backwards over a fully::qualified::name.
1776 ;; now continue checking
1782 ;; search for the containing class, returning a 2 element vector if
1783 ;; found. aref 0 contains the bufpos of the boi of the class key
1784 ;; line, and aref 1 contains the bufpos of the open brace.
1786 ;; no paren-state means we cannot be inside a class
1787 nil
1789 search-start search-end)
1791 ;; a cons cell in the first element means that there is some
1792 ;; balanced sexp before the current bufpos. this we can
1793 ;; ignore. the nth 1 and nth 2 elements define for us the
1794 ;; search boundaries
1797 ;; if the car was not a cons cell then nth 0 and nth 1 define
1798 ;; for us the search boundaries
1801 ;; if search-end is nil, or if the search-end character isn't an
1802 ;; open brace, we are definitely not in a class
1808 ;; now, we need to look more closely at search-start. if
1809 ;; search-start is nil, then our start boundary is really
1810 ;; point-min.
1813 ;; if search-start is a cons cell, then we can start
1814 ;; searching from the end of the balanced sexp just ahead of
1815 ;; us
1818 ;; now we can do a quick regexp search from search-start to
1819 ;; search-end and see if we can find a class key. watch for
1820 ;; class like strings in literals
1838 ;; check for embedded keywords
1844 ;; make sure we're really looking at the start of a
1845 ;; class definition, and not an ObjC method.
1850 ;; Check if this is an anonymous inner class.
1856 ;; We're done. Just trap this case in the cond.
1857 nil
1858 ;; False alarm; all conditions aren't satisfied.
1860 ;; Its impossible to define a regexp for this, and
1861 ;; nearly so to do it programmatically.
1862 ;;
1863 ;; ; picks up forward decls
1864 ;; = picks up init lists
1865 ;; ) picks up return types
1866 ;; > picks up templates, but remember that we can
1867 ;; inherit from templates!
1869 ;; try to see if we found the `class' keyword
1870 ;; inside a template arg list
1881 )))
1882 foundp))
1883 )))))
1886 ;; return the buffer position of the beginning of the brace list
1887 ;; statement if we're inside a brace list, otherwise return nil.
1888 ;; CONTAINING-SEXP is the buffer pos of the innermost containing
1889 ;; paren. BRACE-STATE is the remainder of the state of enclosing
1890 ;; braces
1891 ;;
1892 ;; N.B.: This algorithm can potentially get confused by cpp macros
1893 ;; places in inconvenient locations. Its a trade-off we make for
1894 ;; speed.
1896 ;; this will pick up enum lists
1909 ;; this will pick up array/aggregate init lists, even if they are nested.
1912 ;; Pike can have class definitions anywhere, so we must
1913 ;; check for the class key here.
1915 c-decl-block-key))
1916 bufpos braceassignp lim next-containing)
1918 containing-sexp)
1929 ;; We're in an in-expression block of some kind. Do not
1930 ;; check nesting. We deliberately set the limit to the
1931 ;; containing sexp, so that c-looking-at-inexpr-block
1932 ;; doesn't check for an identifier before it.
1934 ;; see if the open brace is preceded by = or [...] in
1935 ;; this statement, but watch out for operator=
1938 ;; Checks to do only on the first sexp before the brace.
1941 ;; In Java, an initialization brace list may follow
1942 ;; directly after "new Foo[]", so check for a "new"
1943 ;; earlier.
1949 ;; Carry on looking if this is an
1950 ;; identifier (may contain "." in Java)
1951 ;; or another "[]" sexp.
1954 ;; Checks to do on all sexps before the brace, up to the
1955 ;; beginning of the statement.
1963 ;; We've seen a =, but must check earlier tokens so
1964 ;; that it isn't something that should be ignored.
1970 ;; Check for operator =
1972 ;; Check for `<opchar>= in Pike.
1975 ;; Special case for Pikes
1976 ;; `[]=, since '[' is not in
1977 ;; the punctuation class.
1980 nil)
1982 ;; make sure we're not in a C++ template
1983 ;; argument assignment
1995 ))))
1996 nil)
2003 ;; Brace lists can't contain a semicolon, so we're done.
2005 ;; Go up one level.
2007 lim nil
2008 next-containing nil))
2009 ;; we've hit the beginning of the aggregate list
2013 )
2014 bufpos))
2015 ))
2018 ;; If we're looking at the start of a pike-style list, ie `({Â })',
2019 ;; `([Â ])', `(<Â >)' etc, a cons of a cons of its starting and ending
2020 ;; positions and its entry in c-special-brace-lists is returned, nil
2021 ;; otherwise. The ending position is nil if the list is still open.
2022 ;; LIM is the limit for forward search. The point may either be at
2023 ;; the `(' or at the following paren character. Tries to check the
2024 ;; matching closer, but assumes it's correct if no balanced paren is
2025 ;; found (i.e. the case `({ ... } ... )' is detected as _not_ being
2026 ;; a special brace list).
2031 end type)
2044 nil)))))
2053 ;; Kludges needed to handle inner
2054 ;; chars both with and without
2055 ;; paren syntax.
2068 ;; Return non-nil if between two statements or declarations, assuming
2069 ;; point is not inside a literal or comment.
2073 ;; Return t if at the start inside some parenthesis expression
2074 ;; too, to catch macros that have statements as arguments.
2082 ;; Returns non-nil if we're looking at the beginning of a block
2083 ;; inside an expression. The value returned is actually a cons of
2084 ;; either 'inlambda, 'inexpr-statement or 'inexpr-class and the
2085 ;; position of the beginning of the construct. LIM limits the
2086 ;; backward search. CONTAINING-SEXP is the start position of the
2087 ;; closest containing list. If it's nil, the containing paren isn't
2088 ;; used to decide whether we're inside an expression or not. If
2089 ;; both LIM and CONTAINING-SEXP is used, LIM needs to be farther
2090 ;; back.
2094 ;; Look at the character after point only as a last resort
2095 ;; when we can't disambiguate.
2108 c-opt-inexpr-class-key
2112 ;; If the class definition is at the start of
2113 ;; a statement, we don't consider it an
2114 ;; in-expression class.
2122 ;; Also, in Pike we treat it as an
2123 ;; in-expression class if it's used in an
2124 ;; object clone expression.
2139 nil)
2146 containing-sexp
2155 nil
2157 res))))
2160 ;; Returns non-nil if we're looking at the end of an in-expression
2161 ;; block, otherwise the same as `c-looking-at-inexpr-block'.
2162 ;; PAREN-STATE is the paren state relevant at the current position.
2164 ;; We currently only recognize a block.
2167 containing-sexp)
2176 paren-state)
2177 containing-sexp)))))
2180 "Return non-nil if we're on or directly after an identifier.
2181 Keywords are recognized and not considered identifiers."
2188 ;; Handle the `<operator> syntax in Pike.
2202 \f
2204 ;; Return the bufpos of the innermost enclosing brace before bufpos
2205 ;; that hasn't been narrowed out, or nil if none was found.
2217 enclosingp))
2220 ;; Return the bufpos of the outermost enclosing brace before bufpos
2221 ;; that hasn't been narrowed out, or nil if none was found.
2231 pos))
2234 ;; Return the closest known safe position higher up than BUFPOS, or
2235 ;; nil if PAREN-STATE doesn't contain one. Return nil if BUFPOS is
2236 ;; nil, which is useful to find the closest limit before a given
2237 ;; limit that might be nil.
2242 ;; Make sure bufpos is outside the macro we might be in.
2254 ;; Backed up bufpos to the macro start and got outside the
2255 ;; state. We know the macro is at the top level in this case,
2256 ;; so we can use the macro start as the safe position.
2257 c-macro-start)))))
2260 ;; Narrow the buffer so that the enclosing class is hidden. Uses
2261 ;; and returns the value from c-search-uplist-for-classkey.
2270 ;; if point is now left of the class opening brace, we're
2271 ;; hosed, so try a different tact
2277 ;; end point is the end of the current line
2281 ;; return the class vector
2282 inclass-p))
2284 \f
2285 ;; c-guess-basic-syntax implements the main decision tree for
2286 ;; determining the syntactic analysis of the current line of code.
2287 ;; Yes, it's huge and bloated!
2289 ;; It's useful to break out some parts of the decision tree to
2290 ;; separate functions, which are all collected below. Use dynamic
2291 ;; binding to propagate back the syntax results from them.
2296 stop-at-boi-only
2297 containing-sexp
2298 paren-state
2300 ;; Do the generic processing to anchor the given syntax symbol on
2301 ;; the preceding statement: Skip over any labels and containing
2302 ;; statements on the same line, and then search backward until we
2303 ;; find a statement or block start that begins at boi without a
2304 ;; label or comment.
2305 ;;
2306 ;; Point is assumed to be at the prospective anchor point for the
2307 ;; given SYNTAX-SYMBOL. More syntax entries are added if we need to
2308 ;; skip past block opens and containing statement. All the added
2309 ;; syntax elements will get the same anchor point.
2310 ;;
2311 ;; If STOP-AT-BOI-ONLY is nil, we might stop in the middle of the
2312 ;; line if another statement precedes the current one on this line.
2313 ;;
2314 ;; If AT-BLOCK-START is non-nil, point is taken to be at the
2315 ;; beginning of a block or brace list, which then might be nested
2316 ;; inside an expression. If AT-BLOCK-START is nil, this is found
2317 ;; out by checking whether the character at point is "{" or not.
2319 ;; This is by far the most common case, so let's give it special
2320 ;; treatment.
2328 step-type step-tmp at-comment add-inexpr-stmt)
2330 ;; Begin by skipping any labels and containing statements that
2331 ;; are on the same line.
2336 t
2338 nil)
2341 step-type step-tmp))
2344 ;; Loop if we have to back out of the containing block.
2347 ;; Loop if we have to back up another statement.
2351 ;; Always start by skipping over any comments that
2352 ;; stands between the statement and boi.
2365 ;; Current position might not be good enough;
2366 ;; skip backward another statement.
2368 containing-sexp))
2373 ;; If stop-at-boi-only is nil, we shouldn't
2374 ;; back up over previous or containing
2375 ;; statements to try to reach boi, so go
2376 ;; back to the last position and exit.
2379 nil)
2382 ;; If we've moved into another statement
2383 ;; then we should no longer try to stop
2384 ;; after boi.
2387 ;; Record this a substatement if we skipped up
2388 ;; one level, but not if we're still on the
2389 ;; same line. This so e.g. a sequence of "else
2390 ;; if" clauses won't indent deeper and deeper.
2400 at-comment nil))
2404 containing-sexp)
2407 paren-state)
2414 ;; Arrived at a function arglist start. Exit with
2415 ;; the position of the first argument inside it.
2418 ;; We're in an in-expression statement. Remember
2419 ;; this. We'll iterate below, but won't add any
2420 ;; syntax element.
2431 ;; If the open brace was at boi, we're always
2432 ;; done. The c-beginning-of-statement-1 call
2433 ;; above is necessary anyway, to decide the type
2434 ;; of block-intro to add.
2440 'defun-block-intro
2445 ;; Loop if the brace wasn't at boi, and we didn't
2446 ;; arrive at a defun block.
2448 ;; Avoid backing up another sexp if the point
2449 ;; we're at now is found to be good enough in
2450 ;; the loop above.
2456 )))
2463 )))
2466 ;; The inclass and class-close syntactic symbols are added in
2467 ;; several places and some work is needed to fix everything.
2468 ;; Therefore it's collected here.
2481 paren-state)
2482 containing-sexp)))
2485 anchor)))
2488 char-after-ip
2489 beg-of-same-or-containing-stmt
2490 containing-sexp
2491 paren-state)
2492 ;; This function contains the decision tree reached through both
2493 ;; cases 18 and 10. It's a continued statement or top level
2494 ;; construct of some kind.
2499 ;; (CASE A removed.)
2500 ;; CASE B: open braces for class or brace-lists
2506 ;; CASE B.1: class-open
2513 ))
2515 ;; CASE B.2: brace-list-open
2526 ;; The most semantically accurate symbol here is
2527 ;; brace-list-open, but we report it simply as a statement-cont.
2528 ;; The reason is that one normally adjusts brace-list-open for
2529 ;; brace lists as top-level constructs, and brace lists inside
2530 ;; statements is a completely different context.
2533 ;; CASE B.3: The body of a function declared inside a normal
2534 ;; block. Can occur e.g. in Pike and when using gcc
2535 ;; extensions. Might also trigger it with some macros followed
2536 ;; by blocks, and this gives sane indentation then too.
2537 ;; C.f. cases 16F and 17G.
2544 ;; CASE B.4: Continued statement with block open.
2549 ))
2550 ;; CASE C: iostream insertion or extraction operator
2556 ;; if we ended up at indent-point, then the first streamop is on a
2557 ;; separate line. Indent the line like a statement-cont instead
2560 t))))
2561 ;; CASE D: continued statement.
2565 )))
2568 "Return the syntactic context of the current line."
2575 literal containing-sexp char-before-ip char-after-ip lim
2576 syntax placeholder c-in-literal-cache step-type
2577 tmpsymbol keyword injava-inher special-brace-list
2578 ;; narrow out any enclosing class or extern "C" block
2580 indent-point))
2581 ;; c-state-cache is shadowed here. That means we must
2582 ;; not do any changes during the execution of this
2583 ;; function, since c-check-state-cache then would change
2584 ;; this local variable and leave a bogus value in the
2585 ;; global one.
2588 paren-state))
2590 inenclosing-p macro-start in-macro-expr
2591 ;; There's always at most one syntactic element which got
2592 ;; a relpos. It's stored in syntactic-relpos.
2593 syntactic-relpos
2595 ;; check for meta top-level enclosing constructs, possible
2596 ;; extern language definitions, possibly (in C++) namespace
2597 ;; definitions.
2611 )))))
2613 ;; Init some position variables:
2614 ;;
2615 ;; containing-sexp is the open paren of the closest
2616 ;; surrounding sexp or nil if there is none that hasn't been
2617 ;; narrowed out.
2618 ;;
2619 ;; lim is the position after the closest preceding brace sexp
2620 ;; (nested sexps are ignored), or the position after
2621 ;; containing-sexp if there is none, or (point-min) if
2622 ;; containing-sexp is nil.
2623 ;;
2624 ;; c-state-cache is the state from c-parse-state at
2625 ;; indent-point, without any parens outside the region
2626 ;; narrowed by c-narrow-out-enclosing-class.
2627 ;;
2628 ;; paren-state is the state from c-parse-state outside
2629 ;; containing-sexp, or at indent-point if containing-sexp is
2630 ;; nil. paren-state is not limited to the narrowed region, as
2631 ;; opposed to c-state-cache.
2640 ;; Ignore balanced paren. The next entry
2641 ;; can't be another one.
2644 ;; If there is no surrounding open paren then
2645 ;; put the last balanced pair back on paren-state.
2647 containing-sexp nil)))
2651 ;; If we're in a parenthesis list then ',' delimits the
2652 ;; "statements" rather than being an operator (with the
2653 ;; exception of the "for" clause). This difference is
2654 ;; typically only noticeable when statements are used in macro
2655 ;; arglists.
2660 ;; cache char before and after indent point, and move point to
2661 ;; the most likely position to perform the majority of tests
2669 ;; are we in a literal?
2672 ;; now figure out syntactic qualities of the current line
2674 ;; CASE 1: in a string.
2677 ;; CASE 2: in a C or C++ style comment.
2680 ;; CASE 3: in a cpp preprocessor macro continuation.
2690 ;; If at the beginning of the body of a #define
2691 ;; directive then analyze as cpp-define-intro
2692 ;; only. Go on with the syntactic analysis
2693 ;; otherwise. in-macro-expr is set if we're in a
2694 ;; cpp expression, i.e. before the #define body
2695 ;; or anywhere in a non-#define directive.
2702 nil)))))
2705 ;; CASE 11: an else clause?
2709 ;; CASE 12: while closure of a do/while construct?
2717 ;; CASE 13: A catch or finally clause? This case is simpler
2718 ;; than if-else and do-while, because a block is required
2719 ;; after every try, catch and finally.
2727 t)
2731 t)
2734 t))
2739 ;; CASE 18: A substatement we can recognize by keyword.
2748 ;; Ought to cache the result from the
2749 ;; c-beginning-of-statement-1 calls here.
2759 ;; Step up to the containing statement if we
2760 ;; stayed in the same one.
2768 ;; There was no containing statement afterall.
2770 placeholder))
2772 ;; Require a parenthesis after these keywords.
2773 ;; Necessary to catch e.g. synchronized in Java,
2774 ;; which can be used both as statement and
2775 ;; modifier.
2780 ;; CASE 18A: Simple substatement.
2786 containing-sexp paren-state))
2792 containing-sexp paren-state))
2795 containing-sexp paren-state))))
2796 ;; CASE 18B: Some other substatement. This is shared
2797 ;; with case 10.
2799 char-after-ip
2800 placeholder
2801 lim
2802 paren-state)))
2803 ;; CASE 4: In-expression statement. C.f. cases 7B, 16A and
2804 ;; 17E.
2806 c-opt-inexpr-block-key
2807 c-opt-lambda-key)
2810 containing-sexp)))
2815 ;; It's a statement block or an anonymous class.
2817 ;; It's a Pike lambda. Check whether we are between the
2818 ;; lambda keyword and the argument list or at the defun
2819 ;; opener.
2821 'inline-open
2830 ;; CASE 5: Line is at top level.
2833 ;; CASE 5A: we are looking at a defun, brace list, class,
2834 ;; or inline-inclass method opening brace
2840 ;; CASE 5A.1: extern language or namespace construct
2856 ))
2859 ;; CASE 5A.2: we are looking at a class opening brace
2866 ))
2868 ;; CASE 5A.3: brace list open
2892 ))))
2895 ;; We're in Java and have found that the open brace
2896 ;; belongs to a "new Foo[]" initialization list,
2897 ;; which means the brace list is part of an
2898 ;; expression and not a top level definition. We
2899 ;; therefore treat it as any topmost continuation
2900 ;; even though the semantically correct symbol still
2901 ;; is brace-list-open, on the same grounds as in
2902 ;; case 10B.2.
2907 ;; CASE 5A.4: inline defun open
2911 ;; CASE 5A.5: ordinary defun open
2916 ;; Bogus to use bol here, but it's the legacy.
2918 )))
2919 ;; CASE 5B: first K&R arg decl or member init
2922 ;; CASE 5B.1: a member init
2925 ;; this line should be indented relative to the beginning
2926 ;; of indentation for the topmost-intro line that contains
2927 ;; the prototype's open paren
2928 ;; TBD: is the following redundant?
2932 ;; TBD: is the preceding redundant?
2946 ;; we don't need to add any class offset since this
2947 ;; should be relative to the ctor's indentation
2948 )
2949 ;; CASE 5B.2: K&R arg decl intro
2955 ;; CASE 5B.3: Inside a member init list.
2959 ;; CASE 5B.4: Nether region after a C++ or Java func
2960 ;; decl, which could include a `throws' declaration.
2964 )))
2965 ;; CASE 5C: inheritance line. could be first inheritance
2966 ;; line, or continuation of a multiple inheritance
2974 ;; watch out for scope operator
2979 )))
2988 ;; for Java
2993 cont done)
2998 done t))
3002 )
3004 injava-inher)
3007 ))
3009 ;; CASE 5C.1: non-hanging colon on an inher intro
3013 ;; don't add inclass symbol since relative point already
3014 ;; contains any class offset
3015 )
3016 ;; CASE 5C.2: hanging colon on an inher intro
3022 ;; CASE 5C.3: in a Java implements/extends
3036 )))
3037 ;; CASE 5C.4: a continued inheritance line
3041 ;; don't add inclass symbol since relative point already
3042 ;; contains any class offset
3043 )))
3044 ;; CASE 5D: this could be a top-level initialization, a
3045 ;; member init list continuation, or a template argument
3046 ;; list continuation.
3048 c++-template-syntax-table
3051 ;; Note: We use the fact that lim is always after any
3052 ;; preceding brace sexp.
3062 ;; CASE 5D.1: hanging member init colon, but watch out
3063 ;; for bogus matches on access specifiers inside classes.
3082 )))
3086 ;; we do not need to add class offset since relative
3087 ;; point is the member init above us
3088 )
3089 ;; CASE 5D.2: non-hanging member init colon
3095 ;; CASE 5D.3: perhaps a template list continuation?
3104 ;; we can probably indent it just like an arglist-cont
3108 ;; CASE 5D.4: perhaps a multiple inheritance line?
3120 t)
3124 ;; CASE 5D.5: Continuation of the "expression part" of a
3125 ;; top level construct.
3134 ;; A preceding comma at the top level means that a
3135 ;; new variable declaration starts here. Use
3136 ;; topmost-intro-cont for it, for consistency with
3137 ;; the first variable declaration. C.f. case 5N.
3138 'topmost-intro-cont
3140 nil containing-sexp paren-state))
3141 ))
3142 ;; CASE 5E: we are looking at a access specifier
3144 c-opt-access-key
3147 paren-state))
3148 ;; Append access-label with the same anchor point as inclass gets.
3150 ;; CASE 5F: extern-lang-close or namespace-close?
3154 'extern-lang-close
3157 ;; CASE 5G: we are looking at the brace which closes the
3158 ;; enclosing nested class decl
3167 ))))
3169 ;; CASE 5H: we could be looking at subsequent knr-argdecls
3175 ;; Do an extra check to avoid tripping up on
3176 ;; statements that occur in invalid contexts
3177 ;; (e.g. in macro bodies where we don't really
3178 ;; know the context of what we're looking at).
3184 ;; CASE 5I: ObjC method definition.
3189 ;; CASE 5N: At a variable declaration that follows a class
3190 ;; definition or some other block declaration that doesn't
3191 ;; end at the closing '}'. C.f. case 5D.5.
3198 ;; Speed up the backward search a bit.
3203 ;; The '}' is unbalanced.
3204 nil
3209 containing-sexp paren-state))
3210 ;; CASE 5J: we are at the topmost level, make
3211 ;; sure we skip back past any access specifiers
3214 c-opt-access-key
3227 ;; real beginning-of-line could be narrowed out due to
3228 ;; enclosure in a class block
3232 ;; Using bol instead of boi above is highly bogus, and
3233 ;; it makes our lives hard to remain compatible. :P
3245 ))
3247 macro-start
3251 ))
3252 ;; CASE 5K: we are at an ObjC method definition
3253 ;; continuation line.
3260 ;; CASE 5L: we are at the first argument of a template
3261 ;; arglist that begins on the previous line.
3265 ;; CASE 5M: we are at a topmost continuation line
3269 ))
3270 ;; (CASE 6 has been removed.)
3271 ;; CASE 7: line is an expression, not a statement. Most
3272 ;; likely we are either in a function prototype or a function
3273 ;; call argument list
3280 ;; CASE 7A: we are looking at the arglist closing paren
3290 ;; CASE 7B: Looking at the opening brace of an
3291 ;; in-expression block or brace list. C.f. cases 4, 16A
3292 ;; and 17E.
3296 c-state-cache))
3300 placeholder
3303 paren-state)
3304 containing-sexp)))
3305 ;; placeholder is nil if it's a block directly in
3306 ;; a function arglist. That makes us skip out of
3307 ;; this case.
3308 )))
3316 ;; CASE 7C: we are looking at the first argument in an empty
3317 ;; argument list. Use arglist-close if we're actually
3318 ;; looking at a close paren or bracket.
3328 ;; CASE 7D: we are inside a conditional test clause. treat
3329 ;; these things as statements
3339 ))
3340 ;; CASE 7E: maybe a continued ObjC method call. This is the
3341 ;; case when we are inside a [] bracketed exp, and what
3342 ;; precede the opening bracket is not an identifier.
3350 )))
3351 ;; CASE 7F: we are looking at an arglist continuation line,
3352 ;; but the preceding argument is on the same line as the
3353 ;; opening paren. This case includes multi-line
3354 ;; mathematical paren groupings, but we could be on a
3355 ;; for-list continuation line
3369 ;; CASE 7G: we are looking at just a normal arglist
3370 ;; continuation line
3373 ))
3374 ;; CASE 8: func-local multi-inheritance line
3383 ;; CASE 8A: non-hanging colon on an inher intro
3387 ;; CASE 8B: hanging colon on an inher intro
3390 ;; CASE 8C: a continued inheritance line
3394 )))
3395 ;; CASE 9: we are inside a brace-list
3403 ;; CASE 9A: In the middle of a special brace list opener.
3420 ;; CASE 9B: brace-list-close brace
3422 ;; Check special brace list closer.
3429 ;; We were between the special close char and the `)'.
3432 ;; We were before the special close char.
3436 ;; Normal brace list check.
3439 t))
3447 t)))
3449 ;; Prepare for the rest of the cases below by going to the
3450 ;; token following the opening brace
3462 ;; CASE 9C: we're looking at the first line in a brace-list
3473 t)))
3474 ;; CASE 9D: this is just a later brace-list-entry or
3475 ;; brace-entry-open
3484 ))
3485 ))))
3486 ;; CASE 10: A continued statement or top level construct.
3495 ;; This is shared with case 18.
3497 char-after-ip
3498 placeholder
3499 containing-sexp
3500 paren-state))
3501 ;; CASE 14: A case or default label
3507 ;; CASE 15: any other label
3515 ;; If the surrounding statement is a switch then
3516 ;; let's analyze all labels as switch labels, so
3517 ;; that they get lined up consistently.
3518 'case-label
3522 ;; CASE 16: block close brace, possibly closing the defun or
3523 ;; the class
3525 ;; From here on we have the next containing sexp in lim.
3529 ;; CASE 16E: Closing a statement block? This catches
3530 ;; cases where it's preceded by a statement keyword,
3531 ;; which works even when used in an "invalid" context,
3532 ;; e.g. a macro argument.
3536 ;; CASE 16A: closing a lambda defun or an in-expression
3537 ;; block? C.f. cases 4, 7B and 17E.
3540 nil))
3542 'inline-close
3555 ;; CASE 16B: does this close an inline or a function in
3556 ;; an extern block or namespace?
3565 ;; CASE 16F: Can be a defun-close of a function declared
3566 ;; in a statement block, e.g. in Pike or when using gcc
3567 ;; extensions. Might also trigger it with some macros
3568 ;; followed by blocks, and this gives sane indentation
3569 ;; then too. Let it through to be handled below.
3570 ;; C.f. cases B.3 and 17G.
3572 lim
3581 ;; CASE 16C: if there an enclosing brace that hasn't
3582 ;; been narrowed out by a class, then this is a
3583 ;; block-close. C.f. case 17H.
3585 ;; If the block is preceded by a case/switch label on
3586 ;; the same line, we anchor at the first preceding label
3587 ;; at boi. The default handling in c-add-stmt-syntax is
3588 ;; really fixes it better, but we do like this to keep
3589 ;; the indentation compatible with version 5.28 and
3590 ;; earlier.
3597 ;; c-backward-to-block-anchor not necessary here; those
3598 ;; situations are handled in case 16E above.
3600 ;; CASE 16D: find out whether we're closing a top-level
3601 ;; class or a defun
3612 )))
3613 ;; CASE 17: Statement or defun catchall.
3616 ;; Back up statements until we find one that starts at boi.
3619 containing-sexp)))
3623 nil)
3627 ;; CASE 17B: continued statement
3631 containing-sexp paren-state))
3632 ;; CASE 17A: After a case/default label?
3640 'statement-case-open
3642 t containing-sexp paren-state))
3643 ;; CASE 17D: any old statement
3652 ;; CASE 17I: Inside a substatement block.
3654 ;; The following tests are all based on containing-sexp.
3656 ;; From here on we have the next containing sexp in lim.
3663 ;; CASE 17E: first statement in an in-expression block.
3664 ;; C.f. cases 4, 7B and 16A.
3667 nil))
3669 'defun-block-intro
3683 ;; CASE 17F: first statement in an inline, or first
3684 ;; statement in a top-level defun. we can tell this is it
3685 ;; if there are no enclosing braces that haven't been
3686 ;; narrowed out by a class (i.e. don't use bod here).
3687 ;; However, we first check for statements that we can
3688 ;; recognize by keywords. That increases the robustness in
3689 ;; cases where statements are used on the top level,
3690 ;; e.g. in macro definitions.
3699 ;; CASE 17G: First statement in a function declared inside
3700 ;; a normal block. This can occur in Pike and with
3701 ;; e.g. the gcc extensions. Might also trigger it with
3702 ;; some macros followed by blocks, and this gives sane
3703 ;; indentation then too. C.f. cases B.3 and 16F.
3712 ;; CASE 17H: First statement in a block. C.f. case 16C.
3714 ;; If the block is preceded by a case/switch label on the
3715 ;; same line, we anchor at the first preceding label at
3716 ;; boi. The default handling in c-add-stmt-syntax is
3717 ;; really fixes it better, but we do like this to keep the
3718 ;; indentation compatible with version 5.28 and earlier.
3725 ;; c-backward-to-block-anchor not necessary here; those
3726 ;; situations are handled in case 17I above.
3730 ))
3731 )
3732 ;; now we need to look at any modifiers
3735 ;; are we looking at a comment only line?
3739 ;; we might want to give additional offset to friends (in C++).
3743 ;; Start of or a continuation of a preprocessor directive?
3756 ;; If inside a cpp expression, i.e. anywhere in a
3757 ;; cpp directive except a #define body, we only let
3758 ;; through the syntactic analysis that is internal
3759 ;; in the expression. That means the arglist
3760 ;; elements, if they are anchored inside the cpp
3761 ;; expression.
3769 ;; Inside a #define body and the syntactic analysis is
3770 ;; anchored on the start of the #define. In this case
3771 ;; we add cpp-define-intro to get the extra
3772 ;; indentation of the #define body.
3774 ;; return the syntax
3775 syntax))))
3777 \f
3781 c-parsing-error)
3784 ;; offset can be a number, a function, a variable, a list, or one of
3785 ;; the symbols + or -
3805 done))
3807 ))
3810 "Get offset from LANGELEM which is a cons cell of the form:
3811 \(SYMBOL . RELPOS). The symbol is matched against `c-offsets-alist'
3812 and the offset found there is returned."
3822 offset
3826 ))
3829 "Apply `c-get-offset' to a list of langelem cells to get the total
3830 syntactic indentation. The anchor position, whose column is used as a
3831 base for all the collected offsets, is taken from the first element
3832 with a relpos."
3833 ;; Note that topmost-intro always has a relpos at bol, for
3834 ;; historical reasons. It's often used together with other symbols
3835 ;; that has more sane positions. Since we always use the first
3836 ;; found relpos, we rely on that these other symbols always precede
3837 ;; topmost-intro in the LANGELEMS list.
3850 (+ indent
3857 \f
3860 ;;; cc-engine.el ends here