| blob | 51e58c76ba127b87c427e535508fe315f6e5a6db |
1 ;;; cc-engine.el --- core syntax guessing engine for CC mode
3 ;; Copyright (C) 1985,1987,1992-2003 Free Software Foundation, Inc.
5 ;; Authors: 1998- Martin Stjernholm
6 ;; 1992-1999 Barry A. Warsaw
7 ;; 1987 Dave Detlefs and Stewart Clamen
8 ;; 1985 Richard M. Stallman
9 ;; Maintainer: bug-cc-mode@gnu.org
10 ;; Created: 22-Apr-1997 (split from cc-mode.el)
11 ;; Version: See cc-mode.el
12 ;; Keywords: c languages oop
14 ;; This file is part of GNU Emacs.
16 ;; GNU Emacs is free software; you can redistribute it and/or modify
17 ;; it under the terms of the GNU General Public License as published by
18 ;; the Free Software Foundation; either version 2, or (at your option)
19 ;; any later version.
21 ;; GNU Emacs is distributed in the hope that it will be useful,
22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 ;; GNU General Public License for more details.
26 ;; You should have received a copy of the GNU General Public License
27 ;; along with GNU Emacs; see the file COPYING. If not, write to
28 ;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
29 ;; Boston, MA 02111-1307, USA.
31 ;;; Commentary:
33 ;; The functions which have docstring documentation can be considered
34 ;; part of an API which other packages can use in CC Mode buffers.
35 ;; Otoh, undocumented functions and functions with the documentation
36 ;; in comments are considered purely internal and can change semantics
37 ;; or even disappear in the future.
38 ;;
39 ;; (This policy applies to CC Mode as a whole, not just this file. It
40 ;; probably also applies to many other Emacs packages, but here it's
41 ;; clearly spelled out.)
43 ;; Hidden buffer changes
44 ;;
45 ;; Various functions in CC Mode use text properties for caching and
46 ;; syntactic markup purposes, and those of them that might modify such
47 ;; properties are said to do "hidden buffer changes". They should be
48 ;; used within `c-save-buffer-state' or a similar function that saves
49 ;; and restores buffer modifiedness etc.
50 ;;
51 ;; Interactive functions are assumed to not do hidden buffer changes
52 ;; (this isn't applicable in the specific parts of them that do real
53 ;; changes, though).
54 ;;
55 ;; All other functions are assumed to do hidden buffer changes and
56 ;; must thus be wrapped inside `c-save-buffer-state' if they're used
57 ;; from any function that does not do hidden buffer changes.
58 ;;
59 ;; Every function, except the interactive ones, that doesn't do hidden
60 ;; buffer changes have that explicitly stated in their docstring or
61 ;; comment.
63 ;; Use of text properties
64 ;;
65 ;; CC Mode uses several text properties internally to mark up various
66 ;; positions, e.g. to improve speed and to eliminate glitches in
67 ;; interactive refontification.
68 ;;
69 ;; Note: This doc is for internal use only. Other packages should not
70 ;; assume that these text properties are used as described here.
71 ;;
72 ;; 'syntax-table
73 ;; Used to modify the syntax of some characters. Currently used to
74 ;; mark the "<" and ">" of angle bracket parens with paren syntax.
75 ;;
76 ;; This property is used on single characters and is therefore
77 ;; always treated as front and rear nonsticky (or start and end open
78 ;; in XEmacs vocabulary). It's therefore installed on
79 ;; `text-property-default-nonsticky' if that variable exists (Emacs
80 ;; >= 21).
81 ;;
82 ;; 'c-is-sws and 'c-in-sws
83 ;; Used by `c-forward-syntactic-ws' and `c-backward-syntactic-ws' to
84 ;; speed them up. See the comment blurb before `c-put-is-sws'
85 ;; below for further details.
86 ;;
87 ;; 'c-type
88 ;; This property is used on single characters to mark positions with
89 ;; special syntactic relevance of various sorts. It's primary use
90 ;; is to avoid glitches when multiline constructs are refontified
91 ;; interactively (on font lock decoration level 3). It's cleared in
92 ;; a region before it's fontified and is then put on relevant chars
93 ;; in that region as they are encountered during the fontification.
94 ;; The value specifies the kind of position:
95 ;;
96 ;; 'c-decl-arg-start
97 ;; Put on the last char of the token preceding each declaration
98 ;; inside a declaration style arglist (typically in a function
99 ;; prototype).
100 ;;
101 ;; 'c-decl-end
102 ;; Put on the last char of the token preceding a declaration.
103 ;; This is used in cases where declaration boundaries can't be
104 ;; recognized simply by looking for a token like ";" or "}".
105 ;; `c-type-decl-end-used' must be set if this is used (see also
106 ;; `c-find-decl-spots').
107 ;;
108 ;; 'c-<>-arg-sep
109 ;; Put on the commas that separate arguments in angle bracket
110 ;; arglists like C++ template arglists.
111 ;;
112 ;; 'c-decl-id-start and 'c-decl-type-start
113 ;; Put on the last char of the token preceding each declarator
114 ;; in the declarator list of a declaration. They are also used
115 ;; between the identifiers cases like enum declarations.
116 ;; 'c-decl-type-start is used when the declarators are types,
117 ;; 'c-decl-id-start otherwise.
118 ;;
119 ;; 'c-awk-NL-prop
120 ;; Used in AWK mode to mark the various kinds of newlines. See
121 ;; cc-awk.el.
123 ;;; Code:
130 load-path)))
137 ;; Some functions/constants in cc-awk.el that are called/referenced here.
138 ;; (Can't use cc-require due to cyclicity.)
150 ;; Silence the compiler.
153 \f
154 ;; Make declarations for all the `c-lang-defvar' variables in cc-langs.
167 \f
168 ;;; Internal state variables.
170 ;; Internal state of hungry delete key feature
174 ;; Internal state of auto newline feature.
178 ;; Internal auto-newline/hungry-delete designation string for mode line.
183 ;; Calculate the new state of PREVSTATE, t or nil, based on arg. If
184 ;; arg is nil or zero, toggle the state. If arg is negative, turn
185 ;; the state off, and if arg is positive, turn the state on
191 ;; Dynamically bound cache for `c-in-literal'.
194 ;; Must be set in buffers where the `c-type' text property might be used
195 ;; with the value `c-decl-end'.
199 \f
200 ;;; Basic utility functions.
203 ;; Return the given region as a string where all syntactic
204 ;; whitespace is removed or, where necessary, replaced with a single
205 ;; space.
231 ;; Return non-nil if the string KEYWORD is a known keyword. More
232 ;; precisely, the value is the symbol for the keyword in
233 ;; `c-keywords-obarray'.
237 ;; Return non-nil if the symbol KEYWORD-SYM, as returned by
238 ;; `c-keyword-sym', is a member of LANG-CONSTANT, which is the name
239 ;; of a language constant that ends with "-kwds". If KEYWORD-SYM is
240 ;; nil then the result is nil.
243 ;; String syntax chars, suitable for skip-syntax-(forward|backward).
248 ;; Regexp matching string start syntax.
253 ;; Holds formatted error strings for the few cases where parse errors
254 ;; are reported.
259 ;; This function does not do any hidden buffer changes.
262 c-parsing-error)
264 ;; Faces given to comments and string literals. This is used in some
265 ;; situations to speed up recognition; it isn't mandatory that font
266 ;; locking is in use. This variable is extended with the face in
267 ;; `c-doc-face-name' when fontification is activated in cc-fonts.el.
271 \f
272 ;; Some debug tools to visualize various special positions. This
273 ;; debug code isn't as portable as the rest of CC Mode.
309 \f
310 ;; `c-beginning-of-statement-1' and accompanying stuff.
312 ;; KLUDGE ALERT: c-maybe-labelp is used to pass information between
313 ;; c-crosses-statement-barrier-p and c-beginning-of-statement-1. A
314 ;; better way should be implemented, but this will at least shut up
315 ;; the byte compiler.
318 ;; New awk-compatible version of c-beginning-of-statement-1, ACM 2002/6/22
320 ;; Macros used internally in c-beginning-of-statement-1 for the
321 ;; automaton actions.
324 stack)))
329 t
330 ,do-if-done
335 ;; Throw nil if stack is empty, else throw non-nil.
359 noerror comma-delim)
360 "Move to the start of the current statement or declaration, or to
361 the previous one if already at the beginning of one. Only
362 statements/declarations on the same level are considered, i.e. don't
363 move into or out of sexps (not even normal expression parentheses).
367 is within the continuation. If starting at such a token, move to the
368 corresponding statement start. If at the beginning of a statement,
369 move to the closest containing statement if there is any. This might
370 also stop at a continuation clause.
372 Labels are treated as separate statements if IGNORE-LABELS is non-nil.
373 The function is not overly intelligent in telling labels from other
374 uses of colons; if used outside a statement context it might trip up
375 on e.g. inherit colons, so IGNORE-LABELS should be used then. There
376 should be no such mistakes in a statement context, however.
378 Macros are ignored unless point is within one, in which case the
379 content of the macro is treated as normal code. Aside from any normal
380 statement starts found in it, stop at the first token of the content
383 leaving them.
385 Return 'label if stopped at a label, 'same if stopped at the beginning
386 of the current statement, 'up if stepped to a containing statement,
387 'previous if stepped to a preceding statement, 'beginning if stepped
388 from a statement continuation clause to its start clause, or 'macro if
389 stepped to a macro start. Note that 'same and not 'label is returned
390 if stopped at the same label without crossing the colon character.
392 LIM may be given to limit the search. If the search hits the limit,
393 point will be left at the closest following token, or at the start
394 position if that is less ('same is returned in this case).
396 NOERROR turns off error logging to `c-parsing-error'.
398 Normally only ';' is considered to delimit statements, but if
399 COMMA-DELIM is non-nil then ',' is treated likewise."
401 ;; The bulk of this function is a pushdown automaton that looks at statement
402 ;; boundaries and the tokens (such as "while") in c-opt-block-stmt-key. Its
403 ;; purpose is to keep track of nested statements, ensuring that such
404 ;; statments are skipped over in their entirety (somewhat akin to what C-M-p
405 ;; does with nested braces/brackets/parentheses).
406 ;;
407 ;; Note: The position of a boundary is the following token.
408 ;;
409 ;; Beginning with the current token (the one following point), move back one
410 ;; sexp at a time (where a sexp is, more or less, either a token or the
411 ;; entire contents of a brace/bracket/paren pair). Each time a statement
412 ;; boundary is crossed or a "while"-like token is found, update the state of
413 ;; the PDA. Stop at the beginning of a statement when the stack (holding
414 ;; nested statement info) is empty and the position has been moved.
415 ;;
416 ;; The following variables constitute the PDA:
417 ;;
418 ;; sym: This is either the "while"-like token (e.g. 'for) we've just
419 ;; scanned back over, 'boundary if we've just gone back over a
420 ;; statement boundary, or nil otherwise.
421 ;; state: takes one of the values (nil else else-boundary while
422 ;; while-boundary catch catch-boundary).
423 ;; nil means "no "while"-like token yet scanned".
424 ;; 'else, for example, means "just gone back over an else".
425 ;; 'else-boundary means "just gone back over a statement boundary
426 ;; immediately after having gone back over an else".
427 ;; saved-pos: A vector of either saved positions (tok ptok pptok, etc.) or
428 ;; of error reporting information.
429 ;; stack: The stack onto which the PDA pushes its state. Each entry
430 ;; consists of a saved value of state and saved-pos. An entry is
431 ;; pushed when we move back over a "continuation" token (e.g. else)
432 ;; and popped when we encounter the corresponding opening token
433 ;; (e.g. if).
434 ;;
435 ;;
436 ;; The following diagram briefly outlines the PDA.
437 ;;
438 ;; Common state:
439 ;; "else": Push state, goto state `else'.
440 ;; "while": Push state, goto state `while'.
441 ;; "catch" or "finally": Push state, goto state `catch'.
442 ;; boundary: Pop state.
443 ;; other: Do nothing special.
444 ;;
445 ;; State `else':
446 ;; boundary: Goto state `else-boundary'.
447 ;; other: Error, pop state, retry token.
448 ;;
449 ;; State `else-boundary':
450 ;; "if": Pop state.
451 ;; boundary: Error, pop state.
452 ;; other: See common state.
453 ;;
454 ;; State `while':
455 ;; boundary: Save position, goto state `while-boundary'.
456 ;; other: Pop state, retry token.
457 ;;
458 ;; State `while-boundary':
459 ;; "do": Pop state.
460 ;; boundary: Restore position if it's not at start, pop state. [*see below]
461 ;; other: See common state.
462 ;;
463 ;; State `catch':
464 ;; boundary: Goto state `catch-boundary'.
465 ;; other: Error, pop state, retry token.
466 ;;
467 ;; State `catch-boundary':
468 ;; "try": Pop state.
469 ;; "catch": Goto state `catch'.
470 ;; boundary: Error, pop state.
471 ;; other: See common state.
472 ;;
473 ;; [*] In the `while-boundary' state, we had pushed a 'while state, and were
474 ;; searching for a "do" which would have opened a do-while. If we didn't
475 ;; find it, we discard the analysis done since the "while", go back to this
476 ;; token in the buffer and restart the scanning there, this time WITHOUT
477 ;; pushing the 'while state onto the stack.
478 ;;
479 ;; In addition to the above there is some special handling of labels
480 ;; and macros.
484 macro-start
487 c-stmt-delim-chars-with-comma
488 c-stmt-delim-chars))
489 pos ; Current position.
490 boundary-pos ; Position of last stmt boundary character (e.g. ;).
491 after-labels-pos ; Value of tok after first found colon.
492 last-label-pos ; Value of tok after last found colon.
493 sym ; Symbol just scanned back over (e.g. 'while or
494 ; 'boundary). See above
495 state ; Current state in the automaton. See above.
496 saved-pos ; Current saved positions. See above
497 stack ; Stack of conses (state . saved-pos).
501 tok ptok pptok ; Pos of last three sexps or bounds.
502 c-in-literal-cache c-maybe-labelp saved)
512 ;; Try to skip back over unary operator characters, to register
513 ;; that we've moved.
520 ; Make a variable in
521 ; cc-langs.el, maybe
523 ;; Skip back over any semicolon here. If it was a bare semicolon, we're
524 ;; done. Later on we ignore the boundaries for statements that doesn't
525 ;; contain any sexp. The only thing that is affected is that the error
526 ;; checking is a little less strict, and we really don't bother.
538 ;; ACM, 2002/7/20: What about giving a limit to the above function?
539 ;; ACM, 2003/6/16: The above two lines (checking for
540 ;; awk-logical-semicolon) are probably redundant after rewriting
541 ;; c-awk-backward-syntactic-ws.
543 pos saved)
545 ;; Begin at start and not pos to detect macros if we stand
546 ;; directly after the #.
549 ;; Record this as the first token if not starting inside it.
552 ;; The following while loop goes back one sexp (balanced parens,
553 ;; etc. with contents, or symbol or suchlike) each iteration. This
554 ;; movement is accomplished with a call to scan-sexps approx 130 lines
555 ;; below.
559 ;; Check for macro start. Take this out for AWK Mode (ACM, 2002/5/31)
560 ;; NO!! just make sure macro-start is nil in AWK Mode (ACM, 2002/6/22)
561 ;; It always is (ACM, 2002/6/23)
576 ;; Stop at the first token in the content of the macro.
580 ret 'macro
581 ignore-labels t))
584 ;; Do a round through the automaton if we've just passed a
585 ;; statement boundary or passed a "while"-like token.
593 ;; The PDA state handling.
594 ;;
595 ;; Refer to the description of the PDA in the openining
596 ;; comments. In the following OR form, the first leaf
597 ;; attempts to handles one of the specific actions detailed
598 ;; (e.g., finding token "if" whilst in state `else-boundary').
599 ;; We drop through to the second leaf (which handles common
600 ;; state) if no specific handler is found in the first cond.
601 ;; If a parsing error is detected (e.g. an "else" with no
602 ;; preceding "if"), we throw to the enclosing catch.
603 ;;
604 ;; Note that the (eq state 'else) means
605 ;; "we've just passed an else", NOT "we're looking for an
606 ;; else".
623 ;; Since this can cause backtracking we do a
624 ;; little more careful analysis to avoid it:
625 ;; If there's a label in front of the while
626 ;; it can't be part of a do-while.
655 ;; This is state common. We get here when the previous
656 ;; cond statement found no particular state handler.
658 ;; If we have a boundary at the start
659 ;; position we push a frame to go to the
660 ;; previous statement.
673 ;; might we be calling this from
674 ;; c-awk-after-if-do-for-while-condition-p?
675 ;; If so, avoid infinite recursion.
678 ;; The following may recursively
679 ;; call this function.
681 ;; Since this can cause backtracking we do a
682 ;; little more careful analysis to avoid it: If
683 ;; the while isn't followed by a semicolon it
684 ;; can't be a do-while.
685 ;; ACM, 2002/5/31; IT CAN IN AWK Mode. ;-(
694 ;; We're either past a statement boundary or at the
695 ;; start of a statement, so throw away any label data
696 ;; for the previous one.
698 last-label-pos nil
699 c-maybe-labelp nil))))
701 ;; Step to the previous sexp, but not if we crossed a
702 ;; boundary, since that doesn't consume an sexp.
706 ;; HERE IS THE SINGLE PLACE INSIDE THE PDA LOOP WHERE WE MOVE
707 ;; BACKWARDS THROUGH THE SOURCE. The following loop goes back
708 ;; one sexp and then only loops in special circumstances (line
709 ;; continuations and skipping past entire macros).
713 ;; Give up if we hit an unbalanced block.
714 ;; Since the stack won't be empty the code
715 ;; below will report a suitable error.
718 ;; Step again if we hit a line continuation.
719 t)
721 ;; If we started inside a macro then this
722 ;; sexp is always interesting.
723 nil)
725 ;; Otherwise check that we didn't step
726 ;; into a macro from the end.
733 t))))))
735 ;; Did the last movement by a sexp cross a statement boundary?
741 ;; Should not include the paren sexp we've
742 ;; passed over in the boundary check.
746 ;; Find its end position this way instead of
747 ;; moving forward if the sexp is large.
753 ;; Check that we didn't step into
754 ;; a macro from the end.
761 t)))))))
767 ptok tok
768 tok boundary-pos
773 ;; c-crosses-statement-barrier-p has found a colon, so
774 ;; we might be in a label now.
778 c-maybe-labelp t))
780 ;; ObjC method def?
787 ;; We've moved back by a sexp, so update the token positions.
789 pptok ptok
790 ptok tok
794 ;; If the stack isn't empty there might be errors to report.
803 ;; Need to investigate closer whether we've crossed
804 ;; between a substatement and its containing statement.
806 ptok
807 pptok))
814 after-labels-pos)
815 ;; We're in a label. Maybe we should step to the statement
816 ;; after it.
823 ;; Skip over the unary operators that can start the statement.
832 ret)))
835 "Return non-nil if buffer positions FROM to TO cross one or more
836 statement or declaration boundaries. The returned value is actually
837 the position of the earliest boundary char. FROM must not be within
838 a string or comment.
840 The variable `c-maybe-labelp' is set to the position of the first `:' that
841 might start a label (i.e. not part of `::' and not preceded by `?'). If a
842 single `?' is found, then `c-maybe-labelp' is cleared."
844 lit-range)
858 ;; Ignore scope operators.
862 ;; A question mark. Can't be a label, so stop
863 ;; looking for more : and ?.
873 nil))))
875 \f
876 ;; A set of functions that covers various idiosyncrasies in
877 ;; implementations of `forward-comment'.
879 ;; Note: Some emacsen considers incorrectly that any line comment
880 ;; ending with a backslash continues to the next line. I can't think
881 ;; of any way to work around that in a reliable way without changing
882 ;; the buffer, though. Suggestions welcome. ;) (No, temporarily
883 ;; changing the syntax for backslash doesn't work since we must treat
884 ;; escapes in string literals correctly.)
887 "Move forward past whitespace and the closest following comment, if any.
888 Return t if a comment was found, nil otherwise. In either case, the
889 point is moved past the following whitespace. Line continuations,
890 i.e. a backslashes followed by line breaks, are treated as whitespace.
891 The line breaks that end line comments are considered to be the
892 comment enders, so the point will be put on the beginning of the next
893 line if it moved past a line comment.
895 This function does not do any hidden buffer changes."
903 ;; Some emacsen (e.g. XEmacs 21) return t when moving
904 ;; forwards at eob.
905 nil
907 ;; Emacs includes the ending newline in a b-style (c++)
908 ;; comment, but XEmacs doesn't. We depend on the Emacs
909 ;; behavior (which also is symmetric).
913 t))))
916 "Move forward past all following whitespace and comments.
917 Line continuations, i.e. a backslashes followed by line breaks, are
918 treated as whitespace.
920 This function does not do any hidden buffer changes."
923 ;; If forward-comment in at least XEmacs 21 is given a large
924 ;; positive value, it'll loop all the way through if it hits
925 ;; eob.
927 ;; Some emacsen (e.g. XEmacs 21) return t when moving
928 ;; forwards at eob.
933 t))))
936 "Move backward past whitespace and the closest preceding comment, if any.
937 Return t if a comment was found, nil otherwise. In either case, the
938 point is moved past the preceding whitespace. Line continuations,
939 i.e. a backslashes followed by line breaks, are treated as whitespace.
940 The line breaks that end line comments are considered to be the
941 comment enders, so the point cannot be at the end of the same line to
942 move over a line comment.
944 This function does not do any hidden buffer changes."
947 ;; When we got newline terminated comments, forward-comment in all
948 ;; supported emacsen so far will stop at eol of each line not
949 ;; ending with a comment when moving backwards. This corrects for
950 ;; that, and at the same time handles line continuations.
959 ;; Some emacsen (e.g. Emacs 19.34) return t when moving
960 ;; backwards at bob.
961 nil
963 ;; Leave point after the closest following newline if we've
964 ;; backed up over any above, since forward-comment won't move
965 ;; backward over a line comment if point is at the end of the
966 ;; same line.
971 ;; If forward-comment above succeeded and we're at eol
972 ;; then the newline we moved over above didn't end a
973 ;; line comment, so we give it another go.
975 t))
977 ;; Emacs <= 20 and XEmacs move back over the closer of a
978 ;; block comment that lacks an opener.
981 t)))))
984 "Move backward past all preceding whitespace and comments.
985 Line continuations, i.e. a backslashes followed by line breaks, are
986 treated as whitespace. The line breaks that end line comments are
987 considered to be the comment enders, so the point cannot be at the end
988 of the same line to move over a line comment.
990 This function does not do any hidden buffer changes."
994 ;; `forward-comment' in some emacsen (e.g. Emacs 19.34)
995 ;; return t when moving backwards at bob.
1000 ;; Emacs <= 20 and XEmacs move back over the
1001 ;; closer of a block comment that lacks an opener.
1003 t)
1005 ;; XEmacs treats line continuations as whitespace but
1006 ;; only in the backward direction, which seems a bit
1007 ;; odd. Anyway, this is necessary for Emacs.
1012 t))))))
1014 \f
1015 ;; Basic handling of preprocessor directives.
1017 ;; This is a dynamically bound cache used together with
1018 ;; `c-query-macro-start' and `c-query-and-set-macro-start'. It only
1019 ;; works as long as point doesn't cross a macro boundary.
1023 ;; This function does not do any hidden buffer changes.
1028 c-macro-start))
1031 ;; This function does not do any hidden buffer changes.
1036 c-macro-start))
1039 "Go to the beginning of a preprocessor directive.
1040 Leave point at the beginning of the directive and return t if in one,
1041 otherwise return nil and leave point unchanged.
1043 This function does not do any hidden buffer changes."
1054 t
1056 nil)))))
1059 "Go to the end of a preprocessor directive.
1060 More accurately, move point to the end of the closest following line
1061 that doesn't end with a line continuation backslash.
1063 This function does not do any hidden buffer changes."
1069 t))))
1072 ;; Assuming point is at the "#" that introduces a preprocessor
1073 ;; directive, it's moved forward to the start of the definition body
1074 ;; if it's a "#define". Non-nil is returned in this case, in all
1075 ;; other cases nil is returned and point isn't moved.
1083 \f
1084 ;; Tools for skipping over syntactic whitespace.
1086 ;; The following functions use text properties to cache searches over
1087 ;; large regions of syntactic whitespace. It works as follows:
1088 ;;
1089 ;; o If a syntactic whitespace region contains anything but simple
1090 ;; whitespace (i.e. space, tab and line breaks), the text property
1091 ;; `c-in-sws' is put over it. At places where we have stopped
1092 ;; within that region there's also a `c-is-sws' text property.
1093 ;; That since there typically are nested whitespace inside that
1094 ;; must be handled separately, e.g. whitespace inside a comment or
1095 ;; cpp directive. Thus, from one point with `c-is-sws' it's safe
1096 ;; to jump to another point with that property within the same
1097 ;; `c-in-sws' region. It can be likened to a ladder where
1098 ;; `c-in-sws' marks the bars and `c-is-sws' the rungs.
1099 ;;
1100 ;; o The `c-is-sws' property is put on the simple whitespace chars at
1101 ;; a "rung position" and also maybe on the first following char.
1102 ;; As many characters as can be conveniently found in this range
1103 ;; are marked, but no assumption can be made that the whole range
1104 ;; is marked (it could be clobbered by later changes, for
1105 ;; instance).
1106 ;;
1107 ;; Note that some part of the beginning of a sequence of simple
1108 ;; whitespace might be part of the end of a preceding line comment
1109 ;; or cpp directive and must not be considered part of the "rung".
1110 ;; Such whitespace is some amount of horizontal whitespace followed
1111 ;; by a newline. In the case of cpp directives it could also be
1112 ;; two newlines with horizontal whitespace between them.
1113 ;;
1114 ;; The reason to include the first following char is to cope with
1115 ;; "rung positions" that doesn't have any ordinary whitespace. If
1116 ;; `c-is-sws' is put on a token character it does not have
1117 ;; `c-in-sws' set simultaneously. That's the only case when that
1118 ;; can occur, and the reason for not extending the `c-in-sws'
1119 ;; region to cover it is that the `c-in-sws' region could then be
1120 ;; accidentally merged with a following one if the token is only
1121 ;; one character long.
1122 ;;
1123 ;; o On buffer changes the `c-in-sws' and `c-is-sws' properties are
1124 ;; removed in the changed region. If the change was inside
1125 ;; syntactic whitespace that means that the "ladder" is broken, but
1126 ;; a later call to `c-forward-sws' or `c-backward-sws' will use the
1127 ;; parts on either side and use an ordinary search only to "repair"
1128 ;; the gap.
1129 ;;
1130 ;; Special care needs to be taken if a region is removed: If there
1131 ;; are `c-in-sws' on both sides of it which do not connect inside
1132 ;; the region then they can't be joined. If e.g. a marked macro is
1133 ;; broken, syntactic whitespace inside the new text might be
1134 ;; marked. If those marks would become connected with the old
1135 ;; `c-in-sws' range around the macro then we could get a ladder
1136 ;; with one end outside the macro and the other at some whitespace
1137 ;; within it.
1138 ;;
1139 ;; The main motivation for this system is to increase the speed in
1140 ;; skipping over the large whitespace regions that can occur at the
1141 ;; top level in e.g. header files that contain a lot of comments and
1142 ;; cpp directives. For small comments inside code it's probably
1143 ;; slower than using `forward-comment' straightforwardly, but speed is
1144 ;; not a significant factor there anyway.
1146 ; (defface c-debug-is-sws-face
1147 ; '((t (:background "GreenYellow")))
1148 ; "Debug face to mark the `c-is-sws' property.")
1149 ; (defface c-debug-in-sws-face
1150 ; '((t (:underline t)))
1151 ; "Debug face to mark the `c-in-sws' property.")
1153 ; (defun c-debug-put-sws-faces ()
1154 ; ;; Put the sws debug faces on all the `c-is-sws' and `c-in-sws'
1155 ; ;; properties in the buffer.
1156 ; (interactive)
1157 ; (save-excursion
1158 ; (let (in-face)
1159 ; (goto-char (point-min))
1160 ; (setq in-face (if (get-text-property (point) 'c-is-sws)
1161 ; (point)))
1162 ; (while (progn
1163 ; (goto-char (next-single-property-change
1164 ; (point) 'c-is-sws nil (point-max)))
1165 ; (if in-face
1166 ; (progn
1167 ; (c-debug-add-face in-face (point) 'c-debug-is-sws-face)
1168 ; (setq in-face nil))
1169 ; (setq in-face (point)))
1170 ; (not (eobp))))
1171 ; (goto-char (point-min))
1172 ; (setq in-face (if (get-text-property (point) 'c-in-sws)
1173 ; (point)))
1174 ; (while (progn
1175 ; (goto-char (next-single-property-change
1176 ; (point) 'c-in-sws nil (point-max)))
1177 ; (if in-face
1178 ; (progn
1179 ; (c-debug-add-face in-face (point) 'c-debug-in-sws-face)
1180 ; (setq in-face nil))
1181 ; (setq in-face (point)))
1182 ; (not (eobp)))))))
1185 ;;`(message ,@args)
1186 )
1220 ;; Called from `after-change-functions'. Note that if
1221 ;; `c-forward-sws' or `c-backward-sws' are used outside
1222 ;; `c-save-buffer-state' or similar then this will remove the cache
1223 ;; properties right after they're added.
1226 ;; Adjust the end to remove the properties in any following simple
1227 ;; ws up to and including the next line break, if there is any
1228 ;; after the changed region. This is necessary e.g. when a rung
1229 ;; marked empty line is converted to a line comment by inserting
1230 ;; "//" before the line break. In that case the line break would
1231 ;; keep the rung mark which could make a later `c-backward-sws'
1232 ;; move into the line comment instead of over it.
1242 ;; Ensure that an `c-in-sws' range gets broken. Note that it isn't
1243 ;; safe to keep a range that was continuous before the change. E.g:
1244 ;;
1245 ;; #define foo
1246 ;; \
1247 ;; bar
1248 ;;
1249 ;; There can be a "ladder" between "#" and "b". Now, if the newline
1250 ;; after "foo" is removed then "bar" will become part of the cpp
1251 ;; directive instead of a syntactically relevant token. In that
1252 ;; case there's no longer syntactic ws from "#" to "b".
1259 ;; Used by `c-forward-syntactic-ws' to implement the unbounded search.
1262 ;; unmarked part of the simple ws region.
1264 rung-is-marked next-rung-is-marked simple-ws-end
1265 ;; `safe-start' is set when it's safe to cache the start position.
1266 ;; It's not set if we've initially skipped over comments and line
1267 ;; continuations since we might have gone out through the end of a
1268 ;; macro then. This provision makes `c-forward-sws' not populate the
1269 ;; cache in the majority of cases, but otoh is `c-backward-sws' by far
1270 ;; more common.
1271 safe-start)
1273 ;; Skip simple ws and do a quick check on the following character to see
1274 ;; if it's anything that can't start syntactic ws, so we can bail out
1275 ;; early in the majority of cases when there just are a few ws chars.
1282 ;; Find the last rung position to avoid setting properties in all
1283 ;; the cases when the marked rung is complete.
1284 ;; (`next-single-property-change' is certain to move at least one
1285 ;; step forward.)
1288 ;; Got no marked rung here. Since the simple ws might have started
1289 ;; inside a line comment or cpp directive we must set `rung-pos' as
1290 ;; high as possible.
1299 ;; The following search is the main reason that `c-in-sws'
1300 ;; and `c-is-sws' aren't combined to one property.
1304 ;; If the `c-in-sws' region extended past the last
1305 ;; `c-is-sws' char we have to go back a bit.
1312 "c-forward-sws cached move %s -> %s (max %s)"
1319 ;; We'll loop here if there is simple ws after the last rung.
1320 ;; That means that there's been some change in it and it's
1321 ;; possible that we've stepped into another ladder, so extend
1322 ;; the previous one to join with it if there is one, and try to
1323 ;; use the cache again.
1325 "c-forward-sws extending rung with [%s..%s] (max %s)"
1328 ;; Remove any `c-in-sws' property from the last char of
1329 ;; the rung before we mark it with `c-is-sws', so that we
1330 ;; won't connect with the remains of a broken "ladder".
1336 last-put-in-sws-pos rung-pos)))
1343 ;; Skipped over comments. Don't cache at eob in case the buffer
1344 ;; is narrowed.
1355 ;; Skip a preprocessor directive.
1362 ;; Don't cache at eob in case the buffer is narrowed.
1365 ;; We've searched over a piece of non-white syntactic ws. See if this
1366 ;; can be cached.
1372 ;; Cache if we haven't skipped comments only, and if we started
1373 ;; either from a marked rung or from a completely uncached
1374 ;; position.
1379 ;; See if there's a marked rung in the encountered simple ws. If
1380 ;; so then we can cache, unless `safe-start' is nil. Even then
1381 ;; we need to do this to check if the cache can be used for the
1382 ;; next step.
1386 safe-start))
1390 "c-forward-sws caching [%s..%s] - [%s..%s] (max %s)"
1394 ;; Remove the properties for any nested ws that might be cached.
1395 ;; Only necessary for `c-is-sws' since `c-in-sws' will be set
1396 ;; anyway.
1404 last-put-in-sws-pos rung-pos))
1406 ;; Remove any `c-in-sws' property from the last char of
1407 ;; the rung before we mark it with `c-is-sws', so that we
1408 ;; won't connect with the remains of a broken "ladder".
1411 rung-end-pos))
1414 "c-forward-sws not caching [%s..%s] - [%s..%s] (max %s)"
1418 ;; Set `rung-pos' for the next rung. It's the same thing here as
1419 ;; initially, except that the rung position is set as early as
1420 ;; possible since we can't be in the ending ws of a line comment or
1421 ;; cpp directive now.
1428 ;; Make sure that the newly marked `c-in-sws' region doesn't connect to
1429 ;; another one after the point (which might occur when editing inside a
1430 ;; comment or macro).
1434 "c-forward-sws clearing at %s for cache separation"
1435 last-put-in-sws-pos)
1439 ;; If at eob we have to clear the last character before the end
1440 ;; instead since the buffer might be narrowed and there might
1441 ;; be a `c-in-sws' after (point-max). In this case it's
1442 ;; necessary to clear both properties.
1444 "c-forward-sws clearing thoroughly at %s for cache separation"
1447 last-put-in-sws-pos))))
1448 )))
1451 ;; Used by `c-backward-syntactic-ws' to implement the unbounded search.
1454 ;; part of the simple ws region.
1456 rung-is-marked simple-ws-beg cmt-skip-pos)
1458 ;; Skip simple horizontal ws and do a quick check on the preceding
1459 ;; character to see if it's anying that can't end syntactic ws, so we can
1460 ;; bail out early in the majority of cases when there just are a few ws
1461 ;; chars. Newlines are complicated in the backward direction, so we can't
1462 ;; skip over them.
1469 ;; Try to find a rung position in the simple ws preceding point, so that
1470 ;; we can get a cache hit even if the last bit of the simple ws has
1471 ;; changed recently.
1477 ;; `rung-pos' will be the earliest marked position, which means that
1478 ;; there might be later unmarked parts in the simple ws region.
1479 ;; It's not worth the effort to fix that; the last part of the
1480 ;; simple ws is also typically edited often, so it could be wasted.
1491 ;; The following search is the main reason that `c-in-sws'
1492 ;; and `c-is-sws' aren't combined to one property.
1496 ;; If the `c-in-sws' region extended past the first
1497 ;; `c-is-sws' char we have to go forward a bit.
1502 "c-backward-sws cached move %s <- %s (min %s)"
1514 t
1516 nil))
1518 ;; We'll loop here if there is simple ws before the first rung.
1519 ;; That means that there's been some change in it and it's
1520 ;; possible that we've stepped into another ladder, so extend
1521 ;; the previous one to join with it if there is one, and try to
1522 ;; use the cache again.
1524 "c-backward-sws extending rung with [%s..%s] (min %s)"
1527 ;; Remove any `c-in-sws' property from the last char of
1528 ;; the rung before we mark it with `c-is-sws', so that we
1529 ;; won't connect with the remains of a broken "ladder".
1532 rung-pos)
1536 last-put-in-sws-pos rung-pos))
1545 ;; Inside a cpp directive. See if it should be skipped over.
1548 ;; Move back over all line continuations in the region skipped
1549 ;; over by `c-backward-comments'. If we go past it then we
1550 ;; started inside the cpp directive.
1559 ;; Don't move past the cpp directive if we began inside
1560 ;; it. Note that the position at the end of the last line
1561 ;; of the macro is also considered to be within it.
1563 nil)
1565 ;; It's worthwhile to spend a little bit of effort on finding
1566 ;; the end of the macro, to get a good `simple-ws-beg'
1567 ;; position for the cache. Note that `c-backward-comments'
1568 ;; could have stepped over some comments before going into
1569 ;; the macro, and then `simple-ws-beg' must be kept on the
1570 ;; same side of those comments.
1577 ;; Might happen if comments after the macro were skipped
1578 ;; over.
1582 t)))
1587 simple-ws-beg)
1588 ;; Skipped over comments. Must put point at the end of
1589 ;; the simple ws at point since we might be after a line
1590 ;; comment or cpp directive that's been partially
1591 ;; narrowed out, and we can't risk marking the simple ws
1592 ;; at the end of it.
1594 t)))
1596 ;; We've searched over a piece of non-white syntactic ws. See if this
1597 ;; can be cached.
1602 ;; Cache if we started either from a marked rung or from a
1603 ;; completely uncached position.
1604 rung-is-marked
1607 ;; Cache if there's a marked rung in the encountered simple ws.
1615 "c-backward-sws caching [%s..%s] - [%s..%s] (min %s)"
1620 ;; Remove the properties for any nested ws that might be cached.
1621 ;; Only necessary for `c-is-sws' since `c-in-sws' will be set
1622 ;; anyway.
1627 ;; Remove any `c-in-sws' property from the last char of
1628 ;; the rung before we mark it with `c-is-sws', so that we
1629 ;; won't connect with the remains of a broken "ladder".
1632 rung-end-pos)
1635 last-put-in-sws-pos simple-ws-beg)
1636 rung-pos)
1641 "c-backward-sws not caching [%s..%s] - [%s..%s] (min %s)"
1647 ))
1649 ;; Make sure that the newly marked `c-in-sws' region doesn't connect to
1650 ;; another one before the point (which might occur when editing inside a
1651 ;; comment or macro).
1655 "c-backward-sws clearing at %s for cache separation"
1658 last-put-in-sws-pos))
1660 ;; If at bob and the buffer is narrowed, we have to clear the
1661 ;; character we're standing on instead since there might be a
1662 ;; `c-in-sws' before (point-min). In this case it's necessary
1663 ;; to clear both properties.
1665 "c-backward-sws clearing thoroughly at %s for cache separation"
1666 last-put-in-sws-pos)
1669 )))
1671 \f
1672 ;; A system for handling noteworthy parens before the point.
1676 ;; The state cache used by `c-parse-state' to cut down the amount of
1677 ;; searching. It's the result from some earlier `c-parse-state' call.
1678 ;; The use of the cached info is more effective if the next
1679 ;; `c-parse-state' call is on a line close by the one the cached state
1680 ;; was made at; the cache can actually slow down a little if the
1681 ;; cached state was made very far back in the buffer. The cache is
1682 ;; most effective if `c-parse-state' is used on each line while moving
1683 ;; forward.
1687 ;; This is (point-min) when `c-state-cache' was calculated, since a
1688 ;; change of narrowing is likely to affect the parens that are visible
1689 ;; before the point.
1692 ;; Invalidate all info on `c-state-cache' that applies to the buffer
1693 ;; at POS or higher. This is much like `c-whack-state-after', but
1694 ;; it never changes a paren pair element into an open paren element.
1695 ;; Doing that would mean that the new open paren wouldn't have the
1696 ;; required preceding paren pair element.
1697 ;;
1698 ;; This function does not do any hidden buffer changes.
1708 ;; Finds and records all noteworthy parens between some good point
1709 ;; earlier in the file and point. That good point is at least the
1710 ;; beginning of the top-level construct we are in, or the beginning
1711 ;; of the preceding top-level construct if we aren't in one.
1712 ;;
1713 ;; The returned value is a list of the noteworthy parens with the
1714 ;; last one first. If an element in the list is an integer, it's
1715 ;; the position of an open paren which has not been closed before
1716 ;; the point. If an element is a cons, it gives the position of a
1717 ;; closed brace paren pair; the car is the start paren position and
1718 ;; the cdr is the position following the closing paren. Only the
1719 ;; last closed brace paren pair before each open paren is recorded,
1720 ;; and thus the state never contains two cons elements in
1721 ;; succession.
1722 ;;
1723 ;; Currently no characters which are given paren syntax with the
1724 ;; syntax-table property are recorded, i.e. angle bracket arglist
1725 ;; parens are never present here. Note that this might change.
1726 ;;
1727 ;; This function does not do any hidden buffer changes.
1733 old-state last-pos pairs pos save-pos)
1736 ;; If the minimum position has changed due to narrowing then we
1737 ;; have to fix the tail of `c-state-cache' accordingly.
1740 ;; If point-min has moved forward then we just need to cut
1741 ;; off a bit of the tail.
1751 ;; If point-min has moved backward then we drop the state
1752 ;; completely. It's possible to do a better job here and
1753 ;; recalculate the top only.
1757 ;; Get the latest position we know are directly inside the
1758 ;; closest containing paren of the cached state.
1764 ;; Check if the found last-pos is in a macro. If it is, and
1765 ;; we're not in the same macro, we must discard everything on
1766 ;; c-state-cache that is inside the macro before using it.
1773 ;; Set last-pos again, just like above.
1780 ;; Find the start position for the forward search. (Can't
1781 ;; search in the backward direction since point might be
1782 ;; in some kind of literal.)
1785 ;; There's a cached state with a containing paren. Pop
1786 ;; off the stale containing sexps from it by going
1787 ;; forward out of parens as far as possible.
1801 ;; The last paren pair we moved out from was a brace
1802 ;; pair. Modify the state to record this as a closed
1803 ;; pair now.
1807 c-state-cache))))
1809 ;; Check if the preceding balanced paren is within a
1810 ;; macro; it should be ignored if we're outside the
1811 ;; macro. There's no need to check any further upwards;
1812 ;; if the macro contains an unbalanced opening paren then
1813 ;; we're smoked anyway.
1824 last-pos))
1827 ;; go back 2 bods, but ignore any bogus positions
1828 ;; returned by beginning-of-defun (i.e. open paren in
1829 ;; column zero)
1841 ;; Find the balanced brace pairs.
1843 pairs nil)
1849 ;; Should ignore any pairs that are in a macro, providing
1850 ;; we're not in the same one.
1857 ;; Record the last brace pair.
1861 ;; There's a closed pair on the cached state but we've
1862 ;; found a later one, so remove it.
1867 ;; There could already be a cons first in `c-state-cache'
1868 ;; if we've e.g. jumped over an unbalanced open paren in a
1869 ;; macro below.
1874 ;; Prepare to loop, but record the open paren only if it's
1875 ;; outside a macro or within the same macro as point, and
1876 ;; if it is a "real" open paren and not some character
1877 ;; that got an open paren syntax-table property.
1888 ;; Found a close paren without a corresponding opening
1889 ;; one. Maybe we didn't go back far enough, so try to
1890 ;; scan backward for the start paren and then start over.
1893 c-state-cache nil)
1895 ;; Emacs (up to at least 21.2) can get confused by
1896 ;; open parens in column zero inside comments: The
1897 ;; sexp functions can then misbehave and bring us
1898 ;; back to the same point again. Check this so that
1899 ;; we don't get an infinite loop.
1902 c-parsing-error
1908 c-state-cache)))
1910 ;; Debug tool to catch cache inconsistencies.
1921 res1 res2))
1922 res1))
1927 'c-debug-parse-state
1932 ;; Whack off any state information from PAREN-STATE which lies
1933 ;; before BUFPOS. Not destructive on PAREN-STATE.
1934 ;;
1935 ;; This function does not do any hidden buffer changes.
1938 car)
1949 ;; Whack off any state information from PAREN-STATE which lies at or
1950 ;; after BUFPOS. Not destructive on PAREN-STATE.
1951 ;;
1952 ;; This function does not do any hidden buffer changes.
1957 ;; just check the car, because in a balanced brace
1958 ;; expression, it must be impossible for the corresponding
1959 ;; close brace to be before point, but the open brace to
1960 ;; be after.
1962 nil ; whack it off
1964 ;; its possible that the open brace is before
1965 ;; bufpos, but the close brace is after. In that
1966 ;; case, convert this to a non-cons element. The
1967 ;; rest of the state is before bufpos, so we're
1968 ;; done.
1970 ;; we know that both the open and close braces are
1971 ;; before bufpos, so we also know that everything else
1972 ;; on state is before bufpos.
1975 nil ; whack it off
1976 ;; it's before bufpos, so everything else should too.
1979 nil)))
1982 ;; Return the bufpos of the innermost enclosing open paren before
1983 ;; bufpos that hasn't been narrowed out, or nil if none was found.
1984 ;;
1985 ;; This function does not do any hidden buffer changes.
1997 enclosingp))
2000 ;; Return the bufpos of the outermost enclosing open paren before
2001 ;; bufpos that hasn't been narrowed out, or nil if none was found.
2002 ;;
2003 ;; This function does not do any hidden buffer changes.
2013 pos))
2016 ;; Return the closest known safe position higher up than BUFPOS, or
2017 ;; nil if PAREN-STATE doesn't contain one. Return nil if BUFPOS is
2018 ;; nil, which is useful to find the closest limit before a given
2019 ;; limit that might be nil.
2020 ;;
2021 ;; This function does not do any hidden buffer changes.
2031 ;; See below.
2034 ;; elem is the position at and not after the opening paren, so
2035 ;; we can go forward one more step unless it's equal to
2036 ;; bufpos. This is useful in some cases avoid an extra paren
2037 ;; level between the safe position and bufpos.
2042 ;; This is used for `font-lock-beginning-of-syntax-function'. It
2043 ;; goes to the closest previous point that is known to be outside
2044 ;; any string literal or comment. `c-state-cache' is used if it has
2045 ;; a position in the vicinity.
2047 elem
2050 ;; Note: Similar code in `c-safe-position'. The
2051 ;; difference is that we accept a safe position at
2052 ;; the point and don't bother to go forward past open
2053 ;; parens.
2068 ;; The position is far back. Try `c-beginning-of-defun-1'
2069 ;; (although we can't be entirely sure it will go to a position
2070 ;; outside a comment or string in current emacsen). FIXME:
2071 ;; Consult `syntax-ppss' here.
2076 \f
2077 ;; Tools for scanning identifiers and other tokens.
2080 "Return non-nil if the point is on or directly after an identifier.
2081 Keywords are recognized and not considered identifiers. If an
2082 identifier is detected, the returned value is its starting position.
2083 If an identifier both starts and stops at the point \(can only happen
2084 in Pike) then the point for the preceding one is returned.
2086 This function does not do any hidden buffer changes."
2092 ;; Handle the `<operator> syntax in Pike.
2096 t
2107 ;; If the point is at the end of a symbol then skip backward to the
2108 ;; beginning of it. Don't move otherwise. Return non-nil if point
2109 ;; moved.
2112 ;; Handle the `<operator> syntax in Pike.
2118 t
2120 nil)))))
2123 ;; Move to the beginning of the current token. Do not move if not
2124 ;; in the middle of one. BACK-LIMIT may be used to bound the
2125 ;; backward search; if given it's assumed to be at the boundary
2126 ;; between two tokens.
2133 ;; `c-nonsymbol-token-regexp' should always match
2134 ;; since we've skipped backward over punctuator
2135 ;; or paren syntax, but consume one char in case
2136 ;; it doesn't so that we don't leave point before
2137 ;; some earlier incorrect token.
2144 ;; Move to the end of the current token. Do not move if not in the
2145 ;; middle of one. BACK-LIMIT may be used to bound the backward
2146 ;; search; if given it's assumed to be at the boundary between two
2147 ;; tokens. Return non-nil if the point is moved, nil otherwise.
2155 ;; `c-nonsymbol-token-regexp' should always match since
2156 ;; we've skipped backward over punctuator or paren
2157 ;; syntax, but move forward in case it doesn't so that
2158 ;; we don't leave point earlier than we started with.
2174 "Move forward by tokens.
2175 A token is defined as all symbols and identifiers which aren't
2177 treated properly). Point is always either left at the beginning of a
2178 token or not moved at all. COUNT specifies the number of tokens to
2179 move; a negative COUNT moves in the opposite direction. A COUNT of 0
2180 moves to the next token beginning only if not already at one. If
2181 BALANCED is true, move over balanced parens, otherwise move into them.
2182 Also, if BALANCED is true, never move out of an enclosing paren.
2184 LIMIT sets the limit for the movement and defaults to the point limit.
2185 The case when LIMIT is set in the middle of a token, comment or macro
2186 is handled correctly, i.e. the point won't be left there.
2188 Return the number of tokens left to move \(positive or negative). If
2189 BALANCED is true, a move over a balanced paren counts as one. Note
2190 that if COUNT is 0 and no appropriate token beginning is found, 1 will
2191 be returned. Thus, a return value of 0 guarantees that point is at
2192 the requested position and a return value less \(without signs) than
2193 COUNT guarantees that point is at the beginning of some token."
2200 c-jump-syntax-balanced
2201 c-jump-syntax-unbalanced))
2206 ;; If count is zero we should jump if in the middle of a token.
2213 ;; Skip whitespace. Count this as a move if we did in
2214 ;; fact move.
2218 ;; Moved out of bounds. Make sure the returned count isn't zero.
2223 ;; Use `condition-case' to avoid having the limit tests
2224 ;; inside the loop.
2232 t)
2235 t)
2236 ;; `c-nonsymbol-token-regexp' above should always
2237 ;; match if there are correct tokens. Try to
2238 ;; widen to see if the limit was set in the
2239 ;; middle of one, else fall back to treating
2240 ;; the offending thing as a one character token.
2245 nil)
2248 t))))
2258 count)))
2261 "Move backward by tokens.
2262 See `c-forward-token-2' for details."
2270 c-jump-syntax-balanced
2271 c-jump-syntax-unbalanced))
2275 ;; The count is zero so try to skip to the beginning of the
2276 ;; current token.
2280 ;; The limit is inside the same token, so return 1.
2283 ;; We're not in the middle of a token. If there's
2284 ;; whitespace after the point then we must move backward,
2285 ;; so set count to 1 in that case.
2287 ;; If we're looking at a '#' that might start a cpp
2288 ;; directive then we have to do a more elaborate check.
2301 ;; Use `condition-case' to avoid having to check for buffer
2302 ;; limits in `backward-char', `scan-sexps' and `goto-char' below.
2311 ;; This can be very inefficient if there's a long
2312 ;; sequence of operator tokens without any separation.
2313 ;; That doesn't happen in practice, anyway.
2323 count)))
2326 "Like `c-forward-token-2' but doesn't treat multicharacter operator
2328 characters are jumped over character by character. This function is
2329 for compatibility only; it's only a wrapper over `c-forward-token-2'."
2334 "Like `c-backward-token-2' but doesn't treat multicharacter operator
2336 characters are jumped over character by character. This function is
2337 for compatibility only; it's only a wrapper over `c-backward-token-2'."
2341 \f
2342 ;; Tools for doing searches restricted to syntactically relevant text.
2345 paren-level not-inside-token
2346 lookbehind-submatch)
2347 "Like `re-search-forward', but only report matches that are found
2348 in syntactically significant text. I.e. matches in comments, macros
2349 or string literals are ignored. The start point is assumed to be
2350 outside any comment, macro or string literal, or else the content of
2351 that region is taken as syntactically significant text.
2353 If PAREN-LEVEL is non-nil, an additional restriction is added to
2354 ignore matches in nested paren sexps, and the search will also not go
2355 outside the current paren sexp.
2357 If NOT-INSIDE-TOKEN is non-nil, matches in the middle of tokens are
2358 ignored. Things like multicharacter operators and special symbols
2360 constants.
2362 If LOOKBEHIND-SUBMATCH is non-nil, it's taken as a number of a
2363 subexpression in REGEXP. The end of that submatch is used as the
2364 position to check for syntactic significance. If LOOKBEHIND-SUBMATCH
2365 isn't used or if that subexpression didn't match then the start
2367 subexpression is never tested before the starting position, so it
2371 subexpression should match the end of nonwhite syntactic whitespace,
2372 i.e. the end of comments or cpp directives. This since the function
2373 skips over such things before resuming the search. It's also not safe
2375 syntactic whitespace."
2380 ;;(message "c-syntactic-re-search-forward %s %s %S" (point) bound regexp)
2385 match-pos found state check-pos check-state tmp)
2400 pos check-pos paren-level nil state))
2402 check-state state))
2404 ;; If we got a look behind subexpression and get an
2405 ;; insignificant match in something that isn't
2406 ;; syntactic whitespace (i.e. strings or in nested
2407 ;; parentheses), then we can never skip more than a
2408 ;; single character from the match position before
2409 ;; continuing the search. That since the look behind
2410 ;; subexpression might match the end of the
2411 ;; insignificant region.
2415 ;; Match inside a string.
2419 ;; Skip to the end of the string before continuing.
2428 continue)))
2431 ;; Match inside a line comment. Skip to eol. Use
2432 ;; `re-search-forward' instead of `skip-chars-forward' to get
2433 ;; the right bound behavior.
2437 ;; Match inside a block comment. Skip to the '*/'.
2443 ;; Match in the middle of the opener of a block or line
2444 ;; comment.
2451 (< check-pos
2456 ;; Match inside a token.
2459 t)
2466 ;; Match inside a macro. Skip to the end of it.
2475 ;; Match inside a nested paren sexp.
2478 ;; Skip out of the paren quickly.
2481 ;; Have exited the current paren sexp. The
2482 ;; `parse-partial-sexp' above has left us just after the
2483 ;; closing paren in this case. Just make
2484 ;; `re-search-forward' above fail in the appropriate way;
2485 ;; we'll adjust the leave off point below if necessary.
2489 ;; A real match.
2491 nil)))))
2497 ;;(message "c-syntactic-re-search-forward done %s" (or match-pos (point)))
2502 match-pos)
2504 ;; Search failed. Set point as appropriate.
2512 nil)))
2515 "Like `skip-chars-backward' but only look at syntactically relevant chars,
2516 i.e. don't stop at positions inside syntactic whitespace or string
2517 literals. Preprocessor directives are also ignored, with the exception
2518 of the one that the point starts within, if any. If LIMIT is given,
2519 it's assumed to be at a syntactically relevant position.
2521 This function does not do any hidden buffer changes."
2524 ;; A list of syntactically relevant positions in descending
2525 ;; order. It's used to avoid scanning repeatedly over
2526 ;; potentially large regions with `parse-partial-sexp' to verify
2527 ;; each position.
2528 safe-pos-list
2529 ;; The result from `c-beginning-of-macro' at the start position or the
2530 ;; start position itself if it isn't within a macro. Evaluated on
2531 ;; demand.
2532 start-macro-beg)
2538 ;; Use `parse-partial-sexp' from a safe position down to
2539 ;; the point to check if it's outside comments and
2540 ;; strings.
2542 ;; Pick a safe position as close to the point as
2543 ;; possible.
2544 ;;
2545 ;; FIXME: Consult `syntax-ppss' here if our
2546 ;; cache doesn't give a good position.
2562 ;; Cache positions along the way to use if we have to
2563 ;; back up more. Every closing paren on the same
2564 ;; level seems like fairly well spaced positions.
2570 ;; Inside string or comment. Continue search at the
2571 ;; beginning of it.
2573 ;; It's an emacs where `parse-partial-sexp'
2574 ;; supplies the starting position.
2577 t)
2580 ;; Inside a macro.
2588 t
2589 ;; It's inside the same macro we started in so it's
2590 ;; a relevant match.
2592 nil))))))
2596 ;; Skip syntactic ws afterwards so that we don't stop at the
2597 ;; end of a comment if `skip-chars' is something like "^/".
2603 \f
2604 ;; Tools for handling comments and string literals.
2607 "Return the type of literal point is in, if any.
2608 The return value is `c' if in a C-style comment, `c++' if in a C++
2609 style comment, `string' if in a string literal, `pound' if DETECT-CPP
2610 is non-nil and in a preprocessor line, or nil if somewhere else.
2611 Optional LIM is used as the backward limit of the search. If omitted,
2612 or nil, `c-beginning-of-defun' is used.
2614 The last point calculated is cached if the cache is enabled, i.e. if
2615 `c-in-literal-cache' is bound to a two element vector.
2617 This function does not do any hidden buffer changes."
2632 ;; cache this result if the cache is enabled
2635 rtn)))
2637 ;; XEmacs has a built-in function that should make this much quicker.
2638 ;; I don't think we even need the cache, which makes our lives more
2639 ;; complicated anyway. In this case, lim is only used to detect
2640 ;; cpp directives.
2641 ;;
2642 ;; Note that there is a bug in Xemacs's buffer-syntactic-context when used in
2643 ;; conjunction with syntax-table-properties. The bug is present in, e.g.,
2644 ;; Xemacs 21.4.4. It manifested itself thus:
2645 ;;
2646 ;; Starting with an empty AWK Mode buffer, type
2647 ;; /regexp/ {<C-j>
2648 ;; Point gets wrongly left at column 0, rather than being indented to tab-width.
2649 ;;
2650 ;; AWK Mode is designed such that when the first / is typed, it gets the
2651 ;; syntax-table property "string fence". When the second / is typed, BOTH /s
2652 ;; are given the s-t property "string". However, buffer-syntactic-context
2653 ;; fails to take account of the change of the s-t property on the opening / to
2654 ;; "string", and reports that the { is within a string started by the second /.
2655 ;;
2656 ;; The workaround for this is for the AWK Mode initialisation to switch the
2657 ;; defalias for c-in-literal to c-slow-in-literal. This will slow down other
2658 ;; cc-modes in Xemacs whenever an awk-buffer has been initialised.
2659 ;;
2660 ;; (Alan Mackenzie, 2003/4/30).
2675 ;; The defalias above isn't enough to shut up the byte compiler.
2679 "Return a cons of the beginning and end positions of the comment or
2680 string surrounding point (including both delimiters), or nil if point
2682 to start parsing from. If NEAR is non-nil, then the limits of any
2684 spaces and tabs between point and the literal. The search for such a
2685 literal is done first in forward direction. If NOT-IN-DELIMITER is
2686 non-nil, the case when point is inside a starting delimiter won't be
2687 recognized. This only has effect for comments, which have starting
2688 delimiters with more than one character.
2690 This function does not do any hidden buffer changes."
2700 ;; String. Search backward for the start.
2708 ;; Line comment. Search from bol for the comment starter.
2721 ;; Block comment. Search backward for the comment starter.
2731 ;; We're standing in a comment starter.
2738 ;; Search forward for a literal.
2750 ;; Search backward.
2761 ;; Block comment. Due to the nature of line
2762 ;; comments, they will always be covered by the
2763 ;; normal case above.
2766 ;; If LIM is bogus, beg will be bogus.
2770 ))))
2773 ;; Like c-literal-limits, but for emacsen whose `parse-partial-sexp'
2774 ;; returns the pos of the comment start.
2776 "Return a cons of the beginning and end positions of the comment or
2777 string surrounding point (including both delimiters), or nil if point
2779 to start parsing from. If NEAR is non-nil, then the limits of any
2781 spaces and tabs between point and the literal. The search for such a
2782 literal is done first in forward direction. If NOT-IN-DELIMITER is
2783 non-nil, the case when point is inside a starting delimiter won't be
2784 recognized. This only has effect for comments, which have starting
2785 delimiters with more than one character.
2787 This function does not do any hidden buffer changes."
2809 ;; We're standing in a comment starter.
2816 ;; Search forward for a literal.
2828 ;; Search backward.
2839 ;; Block comment. Due to the nature of line
2840 ;; comments, they will always be covered by the
2841 ;; normal case above.
2844 ;; If LIM is bogus, beg will be bogus.
2848 ))))
2854 "If the argument is a cons of two buffer positions (such as returned by
2855 `c-literal-limits'), and that range contains a C++ style line comment,
2856 then an extended range is returned that contains all adjacent line
2857 comments (i.e. all comments that starts in the same column with no
2858 empty lines or non-whitespace characters between them). Otherwise the
2859 argument is returned.
2861 This function does not do any hidden buffer changes."
2871 ;; Got to take care in the backward direction to handle
2872 ;; comments which are preceded by code.
2886 range)
2890 "Convenience function that given the result of `c-literal-limits',
2891 returns nil or the type of literal that the range surrounds. It's
2892 much faster than using `c-in-literal' and is intended to be used when
2893 you need both the type of a literal and its limits.
2895 This function does not do any hidden buffer changes."
2905 range))
2907 \f
2908 ;; `c-find-decl-spots' and accompanying stuff.
2910 ;; Variables used in `c-find-decl-spots' to cache the search done for
2911 ;; the first declaration in the last call. When that function starts,
2912 ;; it needs to back up over syntactic whitespace to look at the last
2913 ;; token before the region being searched. That can sometimes cause
2914 ;; moves back and forth over a quite large region of comments and
2915 ;; macros, which would be repeated for each changed character when
2916 ;; we're called during fontification, since font-lock refontifies the
2917 ;; current line for each change. Thus it's worthwhile to cache the
2918 ;; first match.
2919 ;;
2920 ;; `c-find-decl-syntactic-pos' is a syntactically relevant position in
2921 ;; the syntactic whitespace less or equal to some start position.
2922 ;; There's no cached value if it's nil.
2923 ;;
2924 ;; `c-find-decl-match-pos' is the match position if
2925 ;; `c-find-decl-prefix-search' matched before the syntactic whitespace
2926 ;; at `c-find-decl-syntactic-pos', or nil if there's no such match.
2937 ; (defface c-debug-decl-spot-face
2938 ; '((t (:background "Turquoise")))
2939 ; "Debug face to mark the spots where `c-find-decl-spots' stopped.")
2940 ; (defface c-debug-decl-sws-face
2941 ; '((t (:background "Khaki")))
2942 ; "Debug face to mark the syntactic whitespace between the declaration
2943 ; spots and the preceding token end.")
2959 ;; Macro used inside `c-find-decl-spots'. It ought to be a defun,
2960 ;; but it contains lots of free variables that refer to things
2961 ;; inside `c-find-decl-spots'. The point is left at `cfd-match-pos'
2962 ;; if there is a match, otherwise at `cfd-limit'.
2965 ;; Find the next property match position if we haven't got one already.
2976 ;; Find the next `c-decl-prefix-re' match if we haven't got one already.
2981 c-literal-faces))
2982 ;; Search again if the match is within a comment or a string literal.
2992 ;; Choose whichever match is closer to the start.
2995 cfd-re-match nil)
2997 cfd-prop-match nil))
3002 ;; Skip forward past comments only so we don't skip macros.
3004 ;; Set the position to continue at. We can avoid going over
3005 ;; the comments skipped above a second time, but it's possible
3006 ;; that the comment skipping has taken us past `cfd-prop-match'
3007 ;; since the property might be used inside comments.
3013 ;; Call CFD-FUN for each possible spot for a declaration from the
3014 ;; point to CFD-LIMIT. A spot for a declaration is the first token
3015 ;; in the buffer and each token after the ones matched by
3016 ;; `c-decl-prefix-re' and after the occurrences of the `c-type'
3017 ;; property with the value `c-decl-end' (if `c-type-decl-end-used'
3018 ;; is set). Only a spot that match CFD-DECL-RE and whose face is in
3019 ;; the CFD-FACE-CHECKLIST list causes CFD-FUN to be called. The
3020 ;; face check is disabled if CFD-FACE-CHECKLIST is nil.
3021 ;;
3022 ;; If the match is inside a macro then the buffer is narrowed to the
3023 ;; end of it, so that CFD-FUN can investigate the following tokens
3024 ;; without matching something that begins inside a macro and ends
3025 ;; outside it. It's to avoid this work that the CFD-DECL-RE and
3026 ;; CFD-FACE-CHECKLIST checks exist.
3027 ;;
3028 ;; CFD-FUN is called with point at the start of the spot. It's
3029 ;; passed two arguments: The first is the end position of the token
3030 ;; that `c-decl-prefix-re' matched, or 0 for the implicit match at
3031 ;; bob. The second is a flag that is t when the match is inside a
3032 ;; macro.
3033 ;;
3034 ;; It's assumed that comment and strings are fontified in the
3035 ;; searched range.
3036 ;;
3037 ;; This is mainly used in fontification, and so has an elaborate
3038 ;; cache to handle repeated calls from the same start position; see
3039 ;; the variables above.
3040 ;;
3041 ;; All variables in this function begin with `cfd-' to avoid name
3042 ;; collision with the (dynamically bound) variables used in CFD-FUN.
3045 ;; The last regexp match found by `c-find-decl-prefix-search'.
3046 cfd-re-match
3047 ;; The last `c-decl-end' found by `c-find-decl-prefix-search'.
3048 ;; If searching for the property isn't needed then we disable
3049 ;; it by faking a first match at the limit.
3051 ;; The position of the last match found by
3052 ;; `c-find-decl-prefix-search'. For regexp matches it's the
3053 ;; end of the matched token, for property matches it's the end
3054 ;; of the property. 0 for the implicit match at bob.
3055 ;; `cfd-limit' if there's no match.
3057 ;; The position to continue searching at.
3058 cfd-continue-pos
3059 ;; The position of the last "real" token we've stopped at.
3060 ;; This can be greater than `cfd-continue-pos' when we get
3061 ;; hits inside macros or at `c-decl-end' positions inside
3062 ;; comments.
3064 ;; The end position of the last entered macro.
3067 ;; Initialize by finding a syntactically relevant start position
3068 ;; before the point, and do the first `c-decl-prefix-re' search
3069 ;; unless we're at bob.
3072 ;; Must back up a bit since we look for the end of the previous
3073 ;; statement or declaration, which is earlier than the first
3074 ;; returned match.
3077 ;; But first we need to move to a syntactically relevant
3078 ;; position. Use the faces to back up to the start of the
3079 ;; comment or string literal.
3088 ;; XEmacs doesn't fontify the quotes surrounding string
3089 ;; literals.
3098 ;; The font lock package might not have fontified the start of
3099 ;; the literal at all so check that we have arrived at
3100 ;; something that looks like a start or else resort to
3101 ;; `c-literal-limits'.
3106 ;; Must back out of any macro so that we don't miss any
3107 ;; declaration that could follow after it, unless the limit is
3108 ;; inside the macro. We only check that for the current line to
3109 ;; save some time; it's enough for the by far most common case
3110 ;; when font-lock refontifies the current line only.
3118 ;; Clear the cache if it applied further down.
3124 ;; If we hit `c-find-decl-syntactic-pos' and
3125 ;; `c-find-decl-match-pos' is set then we install the cached
3126 ;; values. If we hit `c-find-decl-syntactic-pos' and
3127 ;; `c-find-decl-match-pos' is nil then we know there's no decl
3128 ;; prefix in the whitespace before `c-find-decl-syntactic-pos'
3129 ;; and so we can continue the search from this point. If we
3130 ;; didn't hit `c-find-decl-syntactic-pos' then we're now in the
3131 ;; right spot to begin searching anyway.
3133 c-find-decl-match-pos)
3136 ;; The match is always outside macros and comments so we
3137 ;; start at the next token. The loop below will later go
3138 ;; back using `cfd-continue-pos' to fix declarations inside
3139 ;; the syntactic ws.
3143 cfd-continue-pos syntactic-pos)
3150 ;; Always consider bob a match to get the first declaration
3151 ;; in the file. Do this separately instead of letting
3152 ;; `c-decl-prefix-re' match bob, so that it always can
3153 ;; consume at least one character to ensure that we won't
3154 ;; get stuck in an infinite loop.
3159 ;; Do an initial search now. In the bob case above it's only done
3160 ;; to search for the `c-type' property.
3163 ;; Advance `cfd-continue-pos' if we got a hit before the start
3164 ;; position. The earliest position that could affect after
3165 ;; the start position is the char before the preceding
3166 ;; comments.
3175 ;; If we got a match it's always outside macros and comments so
3176 ;; advance to the next token and set `cfd-token-pos'. The loop
3177 ;; below will later go back using `cfd-continue-pos' to fix
3178 ;; declarations inside the syntactic ws.
3187 cfd-match-pos))))
3189 ;; Now loop. We already got the first match.
3196 ;; Kludge to filter out matches on the "<" that
3197 ;; aren't open parens, for the sake of languages
3198 ;; that got `c-recognize-<>-arglists' set.
3203 ;; If `cfd-continue-pos' is less or equal to
3204 ;; `cfd-token-pos', we've got a hit inside a macro
3205 ;; that's in the syntactic whitespace before the last
3206 ;; "real" declaration we've checked. If they're equal
3207 ;; we've arrived at the declaration a second time, so
3208 ;; there's nothing to do.
3212 ;; If `cfd-continue-pos' is less than `cfd-token-pos'
3213 ;; we're still searching for declarations embedded in
3214 ;; the syntactic whitespace. In that case we need
3215 ;; only to skip comments and not macros, since they
3216 ;; can't be nested, and that's already been done in
3217 ;; `c-find-decl-prefix-search'.
3222 ;; Continue if the following token fails the
3223 ;; CFD-DECL-RE and CFD-FACE-CHECKLIST checks.
3230 t)))
3238 ;; Narrow to the end of the macro if we got a hit inside
3239 ;; one, to avoid recognizing things that start inside
3240 ;; the macro and end outside it.
3242 ;; Not in the same macro as in the previous round.
3253 t
3256 t)
3257 ;; The matched token was the last thing in the
3258 ;; macro, so the whole match is bogus.
3260 nil)))
3266 ;; Restore limits if we did macro narrowment above.
3274 \f
3275 ;; A cache for found types.
3277 ;; Buffer local variable that contains an obarray with the types we've
3278 ;; found. If a declaration is recognized somewhere we record the
3279 ;; fully qualified identifier in it to recognize it as a type
3280 ;; elsewhere in the file too. This is not accurate since we do not
3281 ;; bother with the scoping rules of the languages, but in practice the
3282 ;; same name is seldom used as both a type and something else in a
3283 ;; file, and we only use this as a last resort in ambiguous cases (see
3284 ;; `c-font-lock-declarations').
3289 ;; Clears `c-found-types'.
3290 ;;
3291 ;; This function does not do any hidden buffer changes.
3295 ;; Add the given region as a type in `c-found-types'. If the region
3296 ;; doesn't match an existing type but there is a type which is equal
3297 ;; to the given one except that the last character is missing, then
3298 ;; the shorter type is removed. That's done to avoid adding all
3299 ;; prefixes of a type as it's being entered and font locked. This
3300 ;; doesn't cover cases like when characters are removed from a type
3301 ;; or added in the middle. We'd need the position of point when the
3302 ;; font locking is invoked to solve this well.
3307 ;; To avoid storing very long strings, do not add a type that
3308 ;; contains '<' in languages with angle bracket arglists, since
3309 ;; the type then probably contains a C++ template spec and those
3310 ;; can be fairly sized programs in themselves.
3317 ;; Return non-nil if the given region contains a type in
3318 ;; `c-found-types'.
3322 ;; Return all the types in `c-found-types' as a sorted list of
3323 ;; strings.
3327 type-list)))
3328 c-found-types)
3331 \f
3332 ;; Handling of small scale constructs like types and names.
3335 ;; Remove all the properties put by `c-forward-<>-arglist' in the
3336 ;; specified region. Point is clobbered.
3346 ;; Dynamically bound variable that instructs `c-forward-type' to also
3347 ;; treat possible types (i.e. those that it normally returns 'maybe or
3348 ;; 'found for) as actual types (and always return 'found for them).
3349 ;; This means that it records them in `c-record-type-identifiers' if
3350 ;; that is set, and that it adds them to `c-found-types'.
3353 ;; Dynamically bound variable that instructs `c-forward-<>-arglist' to
3354 ;; not accept arglists that contain more than one argument. It's used
3355 ;; to handle ambiguous cases like "foo (a < b, c > d)" better.
3358 ;; Dynamically bound variables that instructs `c-forward-name',
3359 ;; `c-forward-type' and `c-forward-<>-arglist' to record the ranges of
3360 ;; all the type and reference identifiers they encounter. They will
3361 ;; build lists on these variables where each element is a cons of the
3362 ;; buffer positions surrounding each identifier. This recording is
3363 ;; only activated when `c-record-type-identifiers' is non-nil.
3364 ;;
3365 ;; All known types that can't be identifiers are recorded, and also
3366 ;; other possible types if `c-promote-possible-types' is set.
3367 ;; Recording is however disabled inside angle bracket arglists that
3368 ;; are encountered inside names and other angle bracket arglists.
3369 ;; Such occurences are taken care of by `c-font-lock-<>-arglists'
3370 ;; instead.
3371 ;;
3372 ;; Only the names in C++ template style references (e.g. "tmpl" in
3373 ;; "tmpl<a,b>::foo") are recorded as references, other references
3374 ;; aren't handled here.
3378 ;; If `c-record-type-identifiers' is set, this will receive a cons
3379 ;; cell of the range of the last single identifier symbol stepped over
3380 ;; by `c-forward-name' if it's successful. This is the range that
3381 ;; should be put on one of the record lists by the caller. It's
3382 ;; assigned nil if there's no such symbol in the name.
3387 ;; Always true.
3397 ;; Always true.
3405 ;; Dynamically bound variable that instructs `c-forward-type' to
3406 ;; record the ranges of types that only are found. Behaves otherwise
3407 ;; like `c-record-type-identifiers'.
3411 ;; Used internally in `c-forward-keyword-clause' to move forward
3412 ;; over a type (if TYPE is 'type) or a name (otherwise) which
3413 ;; possibly is prefixed by keywords and their associated clauses.
3414 ;; Try with a type/name first to not trip up on those that begin
3415 ;; with a keyword. Return t if a known or found type is moved
3416 ;; over. The point is clobbered if nil is returned. If range
3417 ;; recording is enabled, the identifier is recorded on as a type
3418 ;; if TYPE is 'type or as a reference if TYPE is 'ref.
3423 nil
3430 t)))
3433 ;; Used internally in `c-forward-keyword-clause' to move forward
3434 ;; over a comma separated list of types or names using
3435 ;; `c-forward-keyword-prefixed-id'.
3445 ;; The first submatch in the current match data is assumed to
3446 ;; surround a token. If it's a keyword, move over it and any
3447 ;; following clauses associated with it, stopping at the next
3448 ;; following token. t is returned in that case, otherwise the point
3449 ;; stays and nil is returned. The kind of clauses that are
3450 ;; recognized are those specified by `c-type-list-kwds',
3451 ;; `c-ref-list-kwds', `c-colon-type-list-kwds',
3452 ;; `c-paren-nontype-kwds', `c-paren-type-kwds', `c-<>-type-kwds',
3453 ;; and `c-<>-arglist-kwds'.
3464 ;; There's a type directly after a keyword in `c-type-list-kwds'.
3469 ;; There's a name directly after a keyword in `c-ref-list-kwds'.
3474 ;; There's an open paren after a keyword in `c-paren-any-kwds'.
3481 ;; Use `c-forward-type' on every identifier we can find
3482 ;; inside the paren, to record the types.
3509 ;; If a keyword matched both one of the types above and
3510 ;; this one, we match `c-colon-type-list-re' after the
3511 ;; clause matched above.
3518 ;; There's a type after the `c-colon-type-list-re'
3519 ;; match after a keyword in `c-colon-type-list-kwds'.
3523 t)))
3526 ;; The point is assumed to be at a '<'. Try to treat it as the open
3527 ;; paren of an angle bracket arglist and move forward to the the
3528 ;; corresponding '>'. If successful, the point is left after the
3529 ;; '>' and t is returned, otherwise the point isn't moved and nil is
3530 ;; returned. If ALL-TYPES is t then all encountered arguments in
3531 ;; the arglist that might be types are treated as found types.
3532 ;;
3533 ;; The surrounding '<' and '>' are given syntax-table properties to
3534 ;; make them behave like parentheses. Each argument separating ','
3535 ;; is also set to `c-<>-arg-sep' in the `c-type' property. These
3536 ;; properties are also cleared in a relevant region forward from the
3537 ;; point if they seems to be set and it turns out to not be an
3538 ;; arglist.
3539 ;;
3540 ;; If the arglist has been successfully parsed before then paren
3541 ;; syntax properties will be exploited to quickly jump to the end,
3542 ;; but that can be disabled by setting REPARSE to t. That is
3543 ;; necessary if the various side effects, e.g. recording of type
3544 ;; ranges, are important. Setting REPARSE to t only applies
3545 ;; recursively to nested angle bracket arglists if
3546 ;; `c-disallow-comma-in-<>-arglists' is set.
3547 ;;
3548 ;; This is primarily used in C++ to mark up template arglists. C++
3549 ;; disambiguates them by checking whether the preceding name is a
3550 ;; template or not. We can't do that, so we assume it is a template
3551 ;; if it can be parsed as one. This usually works well since
3552 ;; comparison expressions on the forms "a < b > c" or "a < b, c > d"
3553 ;; in almost all cases would be pointless. Cases like function
3554 ;; calls on the form "foo (a < b, c > d)" needs to be handled
3555 ;; specially through the `c-disallow-comma-in-<>-arglists' variable.
3558 ;; If `c-record-type-identifiers' is set then activate
3559 ;; recording of any found types that constitute an argument in
3560 ;; the arglist.
3568 ;; `nconc' doesn't mind that the tail of
3569 ;; `c-record-found-types' is t.
3571 t)
3574 nil)))
3577 ;; Recursive part of `c-forward-<>-arglist'.
3580 ;; Cover this so that any recorded found type ranges are
3581 ;; automatically lost if it turns out to not be an angle
3582 ;; bracket arglist. It's propagated through the return value
3583 ;; on successful completion.
3585 ;; List that collects the positions after the argument
3586 ;; separating ',' in the arglist.
3587 arg-start-pos)
3589 ;; If the '<' has paren open syntax then we've marked it as an
3590 ;; angle bracket arglist before, so try to skip to the end and see
3591 ;; that the close paren matches.
3608 nil)))
3616 ;; Got an arglist that appears to be valid.
3618 ;; Reparsing is requested, so zap the properties in the
3619 ;; region and go on to redo it. It's done here to
3620 ;; avoid leaving it behind if we exit through
3621 ;; `angle-bracket-arglist-escape' below.
3625 nil)
3626 t)
3628 ;; Got unmatched paren brackets or either paren was
3629 ;; actually some other token. Recover by clearing the
3630 ;; syntax properties on all the '<' and '>' in the
3631 ;; range where we'll search for the arglist below.
3642 nil)))
3643 t
3653 ;; All encountered identifiers are types, so set the
3654 ;; promote flag and parse the type.
3661 ;; Check if this arglist argument is a sole type. If
3662 ;; it's known then it's recorded in
3663 ;; `c-record-type-identifiers'. If it only is found
3664 ;; then it's recorded in `c-record-found-types' which we
3665 ;; might roll back if it turns out that this isn't an
3666 ;; angle bracket arglist afterall.
3672 ;; A found type was recorded but it's not the
3673 ;; only thing in the arglist argument, so reset
3674 ;; `c-record-found-types'.
3676 orig-record-found-types))))))
3680 ;; Must check for '>' at the very start separately,
3681 ;; since the regexp below has to avoid ">>" without
3682 ;; using \\=.
3684 t)
3686 ;; Note: This regexp exploits the match order in
3687 ;; \| so that "<>" is matched by "<" rather than
3688 ;; "[^>:-]>".
3692 ;; If the arglist starter has lost its open paren
3693 ;; syntax but not the closer, we won't find the
3694 ;; closer above since we only search in the
3695 ;; balanced sexp. In that case we stop just short
3696 ;; of it so check if the following char is the closer.
3698 ;; Remove its syntax so that we don't enter the
3699 ;; recovery code below. That's not necessary
3700 ;; since there's no real reason to suspect that
3701 ;; things inside the arglist are unbalanced.
3704 t)))
3708 ;; Either an operator starting with '>' or the end of
3709 ;; the angle bracket arglist.
3717 ;; We've skipped past a list that ended with '>'. It
3718 ;; must be unbalanced since nested arglists are handled
3719 ;; in the case below. Recover by removing all paren
3720 ;; properties on '<' and '>' in the searched region and
3721 ;; redo the search.
3725 t)
3734 t)
3736 ;; The angle bracket arglist is finished.
3744 nil)))
3747 ;; Either an operator starting with '<' or a nested arglist.
3759 ;; There's always an identifier before a angle
3760 ;; bracket arglist, or a keyword in
3761 ;; `c-<>-type-kwds' or `c-<>-arglist-kwds'.
3780 )))
3782 ;; It was not an angle bracket arglist.
3787 ;; Got an invalid open paren syntax on this
3788 ;; '<'. We'll probably get an unbalanced '>'
3789 ;; further ahead if we just remove the syntax
3790 ;; here, so recover by removing all paren
3791 ;; properties up to and including the
3792 ;; balancing close paren.
3798 ;; It was an angle bracket arglist.
3801 ;; Record the identifier before the template as a type
3802 ;; or reference depending on whether the arglist is last
3803 ;; in a qualified identifier.
3812 t)
3816 ;; Just another argument. Record the position. The
3817 ;; type check stuff that made us stop at it is at
3818 ;; the top of the loop.
3822 ;; Got a character that can't be in an angle bracket
3823 ;; arglist argument. Abort using `throw', since
3824 ;; it's useless to try to find a surrounding arglist
3825 ;; if we're nested.
3832 ;; Move forward over a complete name if at the beginning of one,
3833 ;; stopping at the next following token. If the point is not at
3834 ;; something that are recognized as name then it stays put. A name
3835 ;; could be something as simple as "foo" in C or something as
3836 ;; complex as "X<Y<class A<int>::B, BIT_MAX >> b>, ::operator<> ::
3837 ;; Z<(a>b)> :: operator const X<&foo>::T Q::G<unsigned short
3838 ;; int>::*volatile const" in C++ (this function is actually little
3839 ;; more than a `looking-at' call in all modes except those that,
3840 ;; like C++, have `c-recognize-<>-arglists' set). Return nil if no
3841 ;; name is found, 'template if it's an identifier ending with an
3842 ;; angle bracket arglist, 'operator of it's an operator identifier,
3843 ;; or t if it's some other kind of name.
3846 ;; Turn off `c-promote-possible-types' here since we might
3847 ;; call `c-forward-<>-arglist' and we don't want it to promote
3848 ;; every suspect thing in the arglist to a type. We're
3849 ;; typically called from `c-forward-type' in this case, and
3850 ;; the caller only wants the top level type that it finds to
3851 ;; be promoted.
3852 c-promote-possible-types)
3858 ;; Check for keyword. We go to the last symbol in
3859 ;; `c-identifier-key' first.
3875 ;; "template" is only valid inside an
3876 ;; identifier if preceded by "::".
3881 t))
3883 ;; Handle a C++ operator or template identifier.
3887 ;; Got "... ::template".
3891 res subres))))
3894 ;; Got a cast operator.
3898 ;; Now we should match a sequence of either
3899 ;; '*', '&' or a name followed by ":: *",
3900 ;; where each can be followed by a sequence
3901 ;; of `c-opt-type-modifier-key'.
3904 t)
3914 t))))
3922 ;; Got some other operator.
3931 nil)
3939 res t)))
3949 ;; Got a concatenated identifier. This handles the
3950 ;; cases with tricky syntactic whitespace that aren't
3951 ;; covered in `c-identifier-key'.
3954 t)
3958 ;; Maybe an angle bracket arglist.
3967 ;; Continue if there's an identifier concatenation
3968 ;; operator after the template argument.
3975 t)
3976 ;; `c-add-type' isn't called here since we don't
3977 ;; want to add types containing angle bracket
3978 ;; arglists.
3983 nil)))
3984 )))))
3987 res))
3990 ;; Move forward over a type spec if at the beginning of one,
3991 ;; stopping at the next following token. Return t if it's a known
3992 ;; type that can't be a name, 'known if it's an otherwise known type
3993 ;; (according to `*-font-lock-extra-types'), 'prefix if it's a known
3994 ;; prefix of a type, 'found if it's a type that matches one in
3995 ;; `c-found-types', 'maybe if it's an identfier that might be a
3996 ;; type, or nil if it can't be a type (the point isn't moved then).
3997 ;; The point is assumed to be at the beginning of a token.
3998 ;;
3999 ;; Note that this function doesn't skip past the brace definition
4000 ;; that might be considered part of the type, e.g.
4001 ;; "enum {a, b, c} foo".
4004 ;; Skip leading type modifiers. If any are found we know it's a
4005 ;; prefix of a type.
4014 ;; Looking at a keyword that prefixes a type identifier,
4015 ;; e.g. "class".
4022 ;; In many languages the name can be used without the
4023 ;; prefix, so we add it to `c-found-types'.
4028 ;; Invalid syntax.
4040 id-range c-last-identifier-range))))
4052 id-end)
4054 ;; Looking at a primitive or known type identifier. We've
4055 ;; checked for a name first so that we don't go here if the
4056 ;; known type match only is a prefix of another name.
4067 ;; There might be more keywords for the type.
4095 ;; A normal identifier.
4105 ;; It's an identifier that has been used as
4106 ;; a type somewhere else.
4107 'found
4108 ;; It's an identifier that might be a type.
4111 ;; A template is a type.
4115 ;; Otherwise it's an operator identifier, which is not a type.
4120 ;; Skip trailing type modifiers. If any are found we know it's
4121 ;; a type.
4128 ;; Step over any type suffix operator. Do not let the existence
4129 ;; of these alter the classification of the found type, since
4130 ;; these operators typically are allowed in normal expressions
4131 ;; too.
4138 ;; Look for a trailing operator that concatenate the type with
4139 ;; a following one, and if so step past that one through a
4140 ;; recursive call.
4143 c-promote-possible-types))
4144 ;; If we can't promote then set `c-record-found-types' so that
4145 ;; we can merge in the types from the second part afterwards if
4146 ;; it turns out to be a known type there.
4157 ;; If either operand certainly is a type then both are, but we
4158 ;; don't let the existence of the operator itself promote two
4159 ;; uncertain types to a certain one.
4174 ;; Merge in the ranges of any types found by the second
4175 ;; `c-forward-type'.
4177 ;; `nconc' doesn't mind that the tail of
4178 ;; `c-record-found-types' is t.
4180 c-record-type-identifiers))))
4188 ;;(message "c-forward-type %s -> %s: %s" start (point) res)
4190 res))
4192 \f
4193 ;; Handling of large scale constructs like statements and declarations.
4196 ;; Go to the first non-whitespace after the colon that starts a
4197 ;; multiple inheritance introduction. Optional LIM is the farthest
4198 ;; back we should search.
4210 ;; Return nil if we aren't in a method definition, otherwise the
4211 ;; position of the initial [+-].
4217 ))
4219 ;; Contributed by Kevin Ryde <user42@zip.com.au>.
4221 ;; Return non-nil if point is within a gcc \"asm\" block.
4222 ;;
4223 ;; This should be called with point inside an argument list.
4224 ;;
4225 ;; Only one level of enclosing parentheses is considered, so for
4226 ;; instance `nil' is returned when in a function call within an asm
4227 ;; operand.
4237 "Return a determination as to whether point is at the `top-level'.
4238 Being at the top-level means that point is either outside any
4239 enclosing block (such function definition), or only inside a class,
4240 namespace or other block that contains another declaration level.
4242 If point is not at the top-level (e.g. it is inside a method
4243 definition), then nil is returned. Otherwise, if point is at a
4244 top-level not enclosed within a class definition, t is returned.
4245 Otherwise, a 2-vector is returned where the zeroth element is the
4246 buffer position of the start of the class declaration, and the first
4247 element is the buffer position of the enclosing class's opening
4248 brace."
4254 ;; Return non-nil if we are between a function's argument list closing
4255 ;; paren and its opening brace. Note that the list close brace
4256 ;; could be followed by a "const" specifier or a member init hanging
4257 ;; colon. LIM is used as bound for some backward buffer searches;
4258 ;; the search might continue past it.
4259 ;;
4260 ;; Note: This test is easily fooled. It only works reasonably well
4261 ;; in the situations where `c-guess-basic-syntax' uses it.
4267 ;; could be looking at const specifier
4272 ;; otherwise, we could be looking at a hanging member init
4273 ;; colon
4277 ;; this will catch member inits with multiple
4278 ;; line arglists
4291 nil
4293 )
4296 ;; Check that it isn't a cpp expression, e.g. the
4297 ;; expression of an #if directive or the "function header"
4298 ;; of a #define.
4302 ;; Check if we are looking at an ObjC method def or a class
4303 ;; category.
4313 ;; Pike has compound types that include parens,
4314 ;; e.g. "array(string)". Check that we aren't after one.
4320 ))))
4323 ;; Return the position of the first argument declaration if point is
4324 ;; inside a K&R style argument declaration list, nil otherwise.
4325 ;; `c-recognize-knr-p' is not checked. If LIM is non-nil, it's a
4326 ;; position that bounds the backward search for the argument list.
4327 ;;
4328 ;; Note: A declaration level context is assumed; the test can return
4329 ;; false positives for statements. This test is even more easily
4330 ;; fooled than `c-just-after-func-arglist-p'.
4335 ;; Go back to the closest preceding normal parenthesis sexp. We
4336 ;; take that as the argument list in the function header. Then
4337 ;; check that it's followed by some symbol before the next ';'
4338 ;; or '{'. If it does, it's the header of the K&R argdecl we're
4339 ;; in.
4342 paren-end)
4360 ;; If it's a K&R declaration then we're now at the
4361 ;; beginning of the function arglist. Check that there
4362 ;; isn't a '=' before it in this statement since that
4363 ;; means it some kind of initialization instead.
4370 ;; skip forward over conditional at point, including any predicate
4371 ;; statements in parentheses. No error checking is performed.
4373 ;; else if()
4378 ;; do, else, try, finally
4383 ;; for, if, while, switch, catch, synchronized, foreach
4387 ;; If looking at the token after a conditional then return the
4388 ;; position of its start, otherwise return nil.
4398 ;; Assuming point is at a brace that opens a statement block of some
4399 ;; kind, move to the proper anchor point for that block. It might
4400 ;; need to be adjusted further by c-add-stmt-syntax, but the
4401 ;; position at return is suitable as start position for that
4402 ;; function.
4409 ;; Assuming point is at a brace that opens the block of a top level
4410 ;; declaration of some kind, move to the proper anchor point for
4411 ;; that block.
4413 ;; What we have below is actually an extremely stripped variant of
4414 ;; c-beginning-of-statement-1.
4416 ;; Switch syntax table to avoid stopping at line continuations.
4428 ;; Search forward for the end of the "header" of the current
4429 ;; declaration. That's the position where the definition body
4430 ;; starts, or the first variable initializer, or the ending
4431 ;; semicolon. I.e. search forward for the closest following
4432 ;; (syntactically relevant) '{', '=' or ';' token. Point is left
4433 ;; _after_ the first found token, or at point-max if none is found.
4438 ;; In C++ we need to take special care to handle operator
4439 ;; tokens and those pesky template brackets.
4444 ;; Handle operator identifiers, i.e. ignore any
4445 ;; operator token preceded by "operator".
4452 t
4454 nil)))))
4463 ;; Go to the beginning of the current declaration, or the beginning
4464 ;; of the previous one if already at the start of it. Point won't
4465 ;; be moved out of any surrounding paren. Return a cons cell on the
4466 ;; form (MOVE . KNR-POS). MOVE is like the return value from
4467 ;; `c-beginning-of-statement-1'. If point skipped over some K&R
4468 ;; style argument declarations (and they are to be recognized) then
4469 ;; KNR-POS is set to the start of the first such argument
4470 ;; declaration, otherwise KNR-POS is nil. If LIM is non-nil, it's a
4471 ;; position that bounds the backward search.
4472 ;;
4473 ;; NB: Cases where the declaration continues after the block, as in
4474 ;; "struct foo { ... } bar;", are currently recognized as two
4475 ;; declarations, e.g. "struct foo { ... }" and "bar;" in this case.
4481 ;; `c-beginning-of-statement-1' stops at a block start, but we
4482 ;; want to continue if the block doesn't begin a top level
4483 ;; construct, i.e. if it isn't preceded by ';', '}', ':', or bob.
4486 ;; Must check with c-opt-method-key in ObjC mode.
4493 ;; Check that we don't move from the first thing in a
4494 ;; macro to its header.
4500 move tentative-move))
4505 ;; Handle K&R argdecls. Back up after the "statement" jumped
4506 ;; over by `c-beginning-of-statement-1', unless it was the
4507 ;; function body, in which case we're sitting on the opening
4508 ;; brace now. Then test if we're in a K&R argdecl region and
4509 ;; that we started at the other side of the first argdecl in
4510 ;; it.
4520 'previous
4522 knr-argdecl-start))
4526 ;; Might have ended up before a protection label. This should
4527 ;; perhaps be checked before `c-recognize-knr-p' to be really
4528 ;; accurate, but we know that no language has both.
4536 ;; `c-beginning-of-statement-1' counts each brace block as a
4537 ;; separate statement, so the result will be 'previous if we've
4538 ;; moved over any. If they were brace list initializers we might
4539 ;; not have moved over a declaration boundary though, so change it
4540 ;; to 'same if we've moved past a '=' before '{', but not ';'.
4541 ;; (This ought to be integrated into `c-beginning-of-statement-1',
4542 ;; so we avoid this extra pass which potentially can search over a
4543 ;; large amount of text.)
4546 c++-template-syntax-table
4559 ;; Assuming point is at the start of a declaration (as detected by
4560 ;; e.g. `c-beginning-of-decl-1'), go to the end of it. Unlike
4561 ;; `c-beginning-of-decl-1', this function handles the case when a
4562 ;; block is followed by identifiers in e.g. struct declarations in C
4563 ;; or C++. If a proper end was found then t is returned, otherwise
4564 ;; point is moved as far as possible within the current sexp and nil
4565 ;; is returned. This function doesn't handle macros; use
4566 ;; `c-end-of-macro' instead in those cases.
4569 c++-template-syntax-table
4577 ;; Stopped at the ';' in a K&R argdecl section which is
4578 ;; detected using the same criteria as in
4579 ;; `c-beginning-of-decl-1'. Move to the following block
4580 ;; start.
4584 ;; Encountered a block in the declaration. Jump over it.
4595 ;; Check for `c-opt-block-decls-with-vars-key'
4596 ;; before the first paren.
4599 c-opt-block-decls-with-vars-key
4601 lim t t t)
4604 ;; Check that the first following paren is
4605 ;; the block.
4607 lim t t t)
4609 ;; The declaration doesn't have any of the
4610 ;; `c-opt-block-decls-with-vars' keywords in the
4611 ;; beginning, so it ends here at the end of the block.
4619 nil)))
4622 ;; Goes to the beginning of a member init list (i.e. just after the
4623 ;; ':') if inside one. Returns t in that case, nil otherwise.
4636 ;; this will catch member inits with multiple
4637 ;; line arglists
4645 ;; Skip over any template arg to the class. This way with a
4646 ;; syntax table is bogus but it'll have to do for now.
4655 ;; Skip backwards over a fully::qualified::name.
4663 ;; If we've stepped over a number then this is a bitfield.
4668 ;; now continue checking
4675 ;; search for the containing class, returning a 2 element vector if
4676 ;; found. aref 0 contains the bufpos of the boi of the class key
4677 ;; line, and aref 1 contains the bufpos of the open brace.
4679 ;; no paren-state means we cannot be inside a class
4680 nil
4682 search-start search-end)
4684 ;; a cons cell in the first element means that there is some
4685 ;; balanced sexp before the current bufpos. this we can
4686 ;; ignore. the nth 1 and nth 2 elements define for us the
4687 ;; search boundaries
4690 ;; if the car was not a cons cell then nth 0 and nth 1 define
4691 ;; for us the search boundaries
4694 ;; if search-end is nil, or if the search-end character isn't an
4695 ;; open brace, we are definitely not in a class
4699 nil
4700 ;; now, we need to look more closely at search-start. if
4701 ;; search-start is nil, then our start boundary is really
4702 ;; point-min.
4705 ;; if search-start is a cons cell, then we can start
4706 ;; searching from the end of the balanced sexp just ahead of
4707 ;; us
4710 ;; Otherwise we start searching within the surrounding paren sexp.
4712 ;; now we can do a quick regexp search from search-start to
4713 ;; search-end and see if we can find a class key. watch for
4714 ;; class like strings in literals
4723 ;; Add one to the search limit, to allow
4724 ;; matching of the "{" in the regexp.
4727 t))
4736 ;; check for embedded keywords
4742 ;; make sure we're really looking at the start of a
4743 ;; class definition, and not an ObjC method.
4748 ;; Check if this is an anonymous inner class.
4754 ;; We're done. Just trap this case in the cond.
4755 nil
4756 ;; False alarm; all conditions aren't satisfied.
4758 ;; Its impossible to define a regexp for this, and
4759 ;; nearly so to do it programmatically.
4760 ;;
4761 ;; ; picks up forward decls
4762 ;; = picks up init lists
4763 ;; ) picks up return types
4764 ;; > picks up templates, but remember that we can
4765 ;; inherit from templates!
4767 ;; try to see if we found the `class' keyword
4768 ;; inside a template arg list
4779 )))
4780 foundp))
4781 )))))
4784 ;; return the buffer position of the beginning of the brace list
4785 ;; statement if we're inside a brace list, otherwise return nil.
4786 ;; CONTAINING-SEXP is the buffer pos of the innermost containing
4787 ;; paren. BRACE-STATE is the remainder of the state of enclosing
4788 ;; braces
4789 ;;
4790 ;; N.B.: This algorithm can potentially get confused by cpp macros
4791 ;; places in inconvenient locations. Its a trade-off we make for
4792 ;; speed.
4794 ;; This will pick up brace list declarations.
4807 ;; this will pick up array/aggregate init lists, even if they are nested.
4810 ;; Pike can have class definitions anywhere, so we must
4811 ;; check for the class key here.
4813 c-decl-block-key))
4814 bufpos braceassignp lim next-containing)
4816 containing-sexp)
4827 ;; We're in an in-expression block of some kind. Do not
4828 ;; check nesting. We deliberately set the limit to the
4829 ;; containing sexp, so that c-looking-at-inexpr-block
4830 ;; doesn't check for an identifier before it.
4832 ;; see if the open brace is preceded by = or [...] in
4833 ;; this statement, but watch out for operator=
4836 ;; Checks to do only on the first sexp before the brace.
4839 ;; In Java, an initialization brace list may follow
4840 ;; directly after "new Foo[]", so check for a "new"
4841 ;; earlier.
4847 ;; Carry on looking if this is an
4848 ;; identifier (may contain "." in Java)
4849 ;; or another "[]" sexp.
4852 ;; Checks to do on all sexps before the brace, up to the
4853 ;; beginning of the statement.
4861 ;; We've seen a =, but must check earlier tokens so
4862 ;; that it isn't something that should be ignored.
4868 ;; Check for operator =
4870 ;; Check for `<opchar>= in Pike.
4873 ;; Special case for Pikes
4874 ;; `[]=, since '[' is not in
4875 ;; the punctuation class.
4878 nil)
4880 ;; make sure we're not in a C++ template
4881 ;; argument assignment
4893 ))))
4894 nil)
4901 ;; Brace lists can't contain a semicolon, so we're done.
4903 ;; Go up one level.
4905 lim nil
4906 next-containing nil))
4907 ;; we've hit the beginning of the aggregate list
4911 )
4912 bufpos))
4913 ))
4916 ;; If we're looking at the start of a pike-style list, ie `({Â })',
4917 ;; `([Â ])', `(<Â >)' etc, a cons of a cons of its starting and ending
4918 ;; positions and its entry in c-special-brace-lists is returned, nil
4919 ;; otherwise. The ending position is nil if the list is still open.
4920 ;; LIM is the limit for forward search. The point may either be at
4921 ;; the `(' or at the following paren character. Tries to check the
4922 ;; matching closer, but assumes it's correct if no balanced paren is
4923 ;; found (i.e. the case `({ ... } ... )' is detected as _not_ being
4924 ;; a special brace list).
4929 end type)
4942 nil)))))
4951 ;; Kludges needed to handle inner
4952 ;; chars both with and without
4953 ;; paren syntax.
4966 ;; Return non-nil if between two statements or declarations, assuming
4967 ;; point is not inside a literal or comment.
4971 ;; Return t if at the start inside some parenthesis expression
4972 ;; too, to catch macros that have statements as arguments.
4980 ;; Returns non-nil if we're looking at the beginning of a block
4981 ;; inside an expression. The value returned is actually a cons of
4982 ;; either 'inlambda, 'inexpr-statement or 'inexpr-class and the
4983 ;; position of the beginning of the construct. LIM limits the
4984 ;; backward search. CONTAINING-SEXP is the start position of the
4985 ;; closest containing list. If it's nil, the containing paren isn't
4986 ;; used to decide whether we're inside an expression or not. If
4987 ;; both LIM and CONTAINING-SEXP is used, LIM needs to be farther
4988 ;; back.
4992 ;; Look at the character after point only as a last resort
4993 ;; when we can't disambiguate.
5006 c-opt-inexpr-class-key
5010 ;; If the class definition is at the start of
5011 ;; a statement, we don't consider it an
5012 ;; in-expression class.
5020 ;; Also, in Pike we treat it as an
5021 ;; in-expression class if it's used in an
5022 ;; object clone expression.
5037 nil)
5044 containing-sexp
5053 nil
5055 res))))
5058 ;; Returns non-nil if we're looking at the end of an in-expression
5059 ;; block, otherwise the same as `c-looking-at-inexpr-block'.
5060 ;; PAREN-STATE is the paren state relevant at the current position.
5062 ;; We currently only recognize a block.
5065 containing-sexp)
5074 paren-state)
5075 containing-sexp)))))
5078 ;; Narrow the buffer so that the enclosing class is hidden. Uses
5079 ;; and returns the value from c-search-uplist-for-classkey.
5088 ;; if point is now left of the class opening brace, we're
5089 ;; hosed, so try a different tact
5095 ;; end point is the end of the current line
5099 ;; return the class vector
5100 inclass-p))
5102 \f
5103 ;; `c-guess-basic-syntax' and the functions that precedes it below
5104 ;; implements the main decision tree for determining the syntactic
5105 ;; analysis of the current line of code.
5107 ;; Dynamically bound to t when `c-guess-basic-syntax' is called during
5108 ;; auto newline analysis.
5112 ;; A simple function to prepend a new syntax element to
5113 ;; `c-syntactic-context'. Using `setq' on it is unsafe since it
5114 ;; should always be dynamically bound but since we read it first
5115 ;; we'll fail properly anyway if this function is misused.
5117 c-syntactic-context)))
5120 ;; Like `c-add-syntax' but appends to the end of the syntax list.
5121 ;; (Normally not necessary.)
5126 syntax-extra-args
5127 stop-at-boi-only
5128 at-block-start
5129 containing-sexp
5130 paren-state)
5131 ;; Do the generic processing to anchor the given syntax symbol on
5132 ;; the preceding statement: Skip over any labels and containing
5133 ;; statements on the same line, and then search backward until we
5134 ;; find a statement or block start that begins at boi without a
5135 ;; label or comment.
5136 ;;
5137 ;; Point is assumed to be at the prospective anchor point for the
5138 ;; given SYNTAX-SYMBOL. More syntax entries are added if we need to
5139 ;; skip past open parens and containing statements. All the added
5140 ;; syntax elements will get the same anchor point.
5141 ;;
5142 ;; SYNTAX-EXTRA-ARGS are a list of the extra arguments for the
5143 ;; syntax symbol. They are appended after the anchor point.
5144 ;;
5145 ;; If STOP-AT-BOI-ONLY is nil, we might stop in the middle of the
5146 ;; line if another statement precedes the current one on this line.
5147 ;;
5148 ;; If AT-BLOCK-START is non-nil, point is taken to be at the
5149 ;; beginning of a block or brace list, which then might be nested
5150 ;; inside an expression. If AT-BLOCK-START is nil, this is found
5151 ;; out by checking whether the character at point is "{" or not.
5153 ;; This is by far the most common case, so let's give it special
5154 ;; treatment.
5161 step-type step-tmp at-comment special-list)
5164 ;; Begin by skipping any labels and containing statements that
5165 ;; are on the same line.
5170 t
5172 nil)
5175 step-type step-tmp))
5178 ;; Loop if we have to back out of the containing block.
5182 ;; Loop if we have to back up another statement.
5186 ;; Always start by skipping over any comments that
5187 ;; stands between the statement and boi.
5200 ;; Current position might not be good enough;
5201 ;; skip backward another statement.
5203 containing-sexp))
5208 ;; If stop-at-boi-only is nil, we shouldn't
5209 ;; back up over previous or containing
5210 ;; statements to try to reach boi, so go
5211 ;; back to the last position and exit.
5214 nil)
5217 ;; If we've moved into another statement
5218 ;; then we should no longer try to stop
5219 ;; after boi.
5222 ;; Record this a substatement if we skipped up
5223 ;; one level, but not if we're still on the
5224 ;; same line. This so e.g. a sequence of "else
5225 ;; if" clauses won't indent deeper and deeper.
5234 at-comment nil))
5238 containing-sexp)
5241 ;; Don't stop in the middle of a special brace list opener
5242 ;; like "({".
5250 paren-state)
5267 ;; We're in an in-expression statement.
5268 ;; This syntactic element won't get an anchor pos.
5284 ;; If the open brace was at boi, we're always
5285 ;; done. The c-beginning-of-statement-1 call
5286 ;; above is necessary anyway, to decide the type
5287 ;; of block-intro to add.
5293 'defun-block-intro
5295 nil))
5298 ;; Loop if the brace wasn't at boi, and we didn't
5299 ;; arrive at a defun block.
5301 ;; Avoid backing up another sexp if the point
5302 ;; we're at now is found to be good enough in
5303 ;; the loop above.
5309 )))
5311 ;; Fill in the current point as the anchor for all the symbols
5312 ;; added above.
5319 )))
5322 ;; The inclass and class-close syntactic symbols are added in
5323 ;; several places and some work is needed to fix everything.
5324 ;; Therefore it's collected here.
5337 paren-state)
5338 containing-sexp)))
5341 anchor)))
5344 char-after-ip
5345 beg-of-same-or-containing-stmt
5346 containing-sexp
5347 paren-state)
5348 ;; This function contains the decision tree reached through both
5349 ;; cases 18 and 10. It's a continued statement or top level
5350 ;; construct of some kind.
5357 ;; (CASE A removed.)
5358 ;; CASE B: open braces for class or brace-lists
5365 ;; CASE B.1: class-open
5371 ))
5374 ;; CASE B.2: brace-list-open
5379 indent-point t t t)))
5380 ;; The most semantically accurate symbol here is
5381 ;; brace-list-open, but we normally report it simply as a
5382 ;; statement-cont. The reason is that one normally adjusts
5383 ;; brace-list-open for brace lists as top-level constructs,
5384 ;; and brace lists inside statements is a completely different
5385 ;; context. C.f. case 5A.3.
5388 ;; Turn off the dwim above when we're
5389 ;; analyzing the nature of the brace
5390 ;; for the auto newline feature.
5391 'brace-list-open
5393 nil nil nil
5394 containing-sexp paren-state))
5396 ;; CASE B.3: The body of a function declared inside a normal
5397 ;; block. Can occur e.g. in Pike and when using gcc
5398 ;; extensions. Might also trigger it with some macros followed
5399 ;; by blocks, and this gives sane indentation then too.
5400 ;; C.f. cases E, 16F and 17G.
5405 containing-sexp paren-state))
5407 ;; CASE B.4: Continued statement with block open.
5411 containing-sexp paren-state)
5413 ))
5415 ;; CASE C: iostream insertion or extraction operator
5419 ;; If there is no preceding streamop in the statement
5420 ;; then indent this line as a normal statement-cont.
5424 t))))
5426 ;; CASE E: In the "K&R region" of a function declared inside a
5427 ;; normal block. C.f. case B.3.
5429 ;; Check that the next token is a '{'. This works as
5430 ;; long as no language that allows nested function
5431 ;; definitions doesn't allow stuff like member init
5432 ;; lists, K&R declarations or throws clauses there.
5433 ;;
5434 ;; Note that we do a forward search for something ahead
5435 ;; of the indentation line here. That's not good since
5436 ;; the user might not have typed it yet. Unfortunately
5437 ;; it's exceedingly tricky to recognize a function
5438 ;; prototype in a code block without resorting to this.
5445 containing-sexp paren-state))
5447 ;; CASE D: continued statement.
5451 containing-sexp paren-state))
5452 )))
5455 "Return the syntactic context of the current line.
5456 This function does not do any hidden buffer changes."
5464 literal containing-sexp char-before-ip char-after-ip lim
5465 c-syntactic-context placeholder c-in-literal-cache step-type
5466 tmpsymbol keyword injava-inher special-brace-list
5467 ;; narrow out any enclosing class or extern "C" block
5469 indent-point))
5470 ;; `c-state-cache' is shadowed here so that we don't
5471 ;; throw it away due to the narrowing that might be done
5472 ;; by the function above. That means we must not do any
5473 ;; changes during the execution of this function, since
5474 ;; `c-invalidate-state-cache' then would change this local
5475 ;; variable and leave a bogus value in the global one.
5478 paren-state))
5480 inenclosing-p macro-start in-macro-expr
5481 ;; There's always at most one syntactic element which got
5482 ;; a relpos. It's stored in syntactic-relpos.
5483 syntactic-relpos
5485 ;; Check for meta top-level enclosing constructs such as
5486 ;; extern language definitions.
5496 ;; Compatibility with legacy choice of name for the
5497 ;; extern-lang syntactic symbols.
5500 ;; Init some position variables:
5501 ;;
5502 ;; containing-sexp is the open paren of the closest
5503 ;; surrounding sexp or nil if there is none that hasn't been
5504 ;; narrowed out.
5505 ;;
5506 ;; lim is the position after the closest preceding brace sexp
5507 ;; (nested sexps are ignored), or the position after
5508 ;; containing-sexp if there is none, or (point-min) if
5509 ;; containing-sexp is nil.
5510 ;;
5511 ;; c-state-cache is the state from c-parse-state at
5512 ;; indent-point, without any parens outside the region
5513 ;; narrowed by c-narrow-out-enclosing-class.
5514 ;;
5515 ;; paren-state is the state from c-parse-state outside
5516 ;; containing-sexp, or at indent-point if containing-sexp is
5517 ;; nil. paren-state is not limited to the narrowed region, as
5518 ;; opposed to c-state-cache.
5527 ;; Ignore balanced paren. The next entry
5528 ;; can't be another one.
5531 ;; If there is no surrounding open paren then
5532 ;; put the last balanced pair back on paren-state.
5534 containing-sexp nil)))
5538 ;; If we're in a parenthesis list then ',' delimits the
5539 ;; "statements" rather than being an operator (with the
5540 ;; exception of the "for" clause). This difference is
5541 ;; typically only noticeable when statements are used in macro
5542 ;; arglists.
5547 ;; cache char before and after indent point, and move point to
5548 ;; the most likely position to perform the majority of tests
5556 ;; are we in a literal?
5559 ;; now figure out syntactic qualities of the current line
5561 ;; CASE 1: in a string.
5564 ;; CASE 2: in a C or C++ style comment.
5566 ;; This is a kludge for XEmacs where we use
5567 ;; `buffer-syntactic-context', which doesn't correctly
5568 ;; recognize "\*/" to end a block comment.
5569 ;; `parse-partial-sexp' which is used by
5570 ;; `c-literal-limits' will however do that in most
5571 ;; versions, which results in that we get nil from
5572 ;; `c-literal-limits' even when `c-in-literal' claims
5573 ;; we're inside a comment.
5576 ;; CASE 3: in a cpp preprocessor macro continuation.
5586 ;; If at the beginning of the body of a #define
5587 ;; directive then analyze as cpp-define-intro
5588 ;; only. Go on with the syntactic analysis
5589 ;; otherwise. in-macro-expr is set if we're in a
5590 ;; cpp expression, i.e. before the #define body
5591 ;; or anywhere in a non-#define directive.
5598 nil)))))
5601 ;; CASE 11: an else clause?
5605 containing-sexp paren-state))
5606 ;; CASE 12: while closure of a do/while construct?
5614 containing-sexp paren-state))
5615 ;; CASE 13: A catch or finally clause? This case is simpler
5616 ;; than if-else and do-while, because a block is required
5617 ;; after every try, catch and finally.
5625 t)
5629 t)
5632 t))
5637 containing-sexp paren-state))
5638 ;; CASE 18: A substatement we can recognize by keyword.
5649 ;; Ought to cache the result from the
5650 ;; c-beginning-of-statement-1 calls here.
5660 ;; Step up to the containing statement if we
5661 ;; stayed in the same one.
5669 ;; There was no containing statement afterall.
5671 placeholder))
5673 ;; Require a parenthesis after these keywords.
5674 ;; Necessary to catch e.g. synchronized in Java,
5675 ;; which can be used both as statement and
5676 ;; modifier.
5681 ;; CASE 18A: Simple substatement.
5687 containing-sexp paren-state))
5693 containing-sexp paren-state))
5696 containing-sexp paren-state))))
5697 ;; CASE 18B: Some other substatement. This is shared
5698 ;; with case 10.
5700 char-after-ip
5701 placeholder
5702 lim
5703 paren-state)))
5704 ;; CASE 4: In-expression statement. C.f. cases 7B, 16A and
5705 ;; 17E.
5707 c-opt-inexpr-block-key
5708 c-opt-lambda-key)
5711 containing-sexp)))
5716 ;; It's a statement block or an anonymous class.
5718 ;; It's a Pike lambda. Check whether we are between the
5719 ;; lambda keyword and the argument list or at the defun
5720 ;; opener.
5722 'inline-open
5731 ;; CASE 5: Line is at top level.
5734 ;; CASE 5A: we are looking at a defun, brace list, class,
5735 ;; or inline-inclass method opening brace
5741 ;; CASE 5A.1: Non-class declaration block open.
5750 ;; Special case for extern-lang-open. The
5751 ;; check for a following string is disabled
5752 ;; since it doesn't disambiguate anything.
5754 ;; (c-forward-sexp 1)
5755 ;; (c-forward-syntactic-ws)
5756 ;; (eq (char-after) ?\"))
5759 ))
5762 ;; CASE 5A.2: we are looking at a class opening brace
5769 ))
5771 ;; CASE 5A.3: brace list open
5796 ))))
5800 ;; We're in Java and have found that the open brace
5801 ;; belongs to a "new Foo[]" initialization list,
5802 ;; which means the brace list is part of an
5803 ;; expression and not a top level definition. We
5804 ;; therefore treat it as any topmost continuation
5805 ;; even though the semantically correct symbol still
5806 ;; is brace-list-open, on the same grounds as in
5807 ;; case B.2.
5812 ;; CASE 5A.4: inline defun open
5816 ;; CASE 5A.5: ordinary defun open
5821 ;; Bogus to use bol here, but it's the legacy.
5823 )))
5824 ;; CASE 5B: first K&R arg decl or member init
5827 ;; CASE 5B.1: a member init
5830 ;; this line should be indented relative to the beginning
5831 ;; of indentation for the topmost-intro line that contains
5832 ;; the prototype's open paren
5833 ;; TBD: is the following redundant?
5837 ;; TBD: is the preceding redundant?
5851 ;; we don't need to add any class offset since this
5852 ;; should be relative to the ctor's indentation
5853 )
5854 ;; CASE 5B.2: K&R arg decl intro
5860 ;; CASE 5B.3: Inside a member init list.
5864 ;; CASE 5B.4: Nether region after a C++ or Java func
5865 ;; decl, which could include a `throws' declaration.
5869 )))
5870 ;; CASE 5C: inheritance line. could be first inheritance
5871 ;; line, or continuation of a multiple inheritance
5879 ;; watch out for scope operator
5884 )))
5893 ;; for Java
5898 cont done)
5903 done t))
5907 )
5909 injava-inher)
5912 ))
5914 ;; CASE 5C.1: non-hanging colon on an inher intro
5918 ;; don't add inclass symbol since relative point already
5919 ;; contains any class offset
5920 )
5921 ;; CASE 5C.2: hanging colon on an inher intro
5927 ;; CASE 5C.3: in a Java implements/extends
5941 )))
5942 ;; CASE 5C.4: a continued inheritance line
5946 ;; don't add inclass symbol since relative point already
5947 ;; contains any class offset
5948 )))
5949 ;; CASE 5D: this could be a top-level initialization, a
5950 ;; member init list continuation, or a template argument
5951 ;; list continuation.
5953 c++-template-syntax-table
5956 ;; Note: We use the fact that lim is always after any
5957 ;; preceding brace sexp.
5968 ;; CASE 5D.1: hanging member init colon, but watch out
5969 ;; for bogus matches on access specifiers inside classes.
5989 )))
5993 ;; we do not need to add class offset since relative
5994 ;; point is the member init above us
5995 )
5996 ;; CASE 5D.2: non-hanging member init colon
6002 ;; CASE 5D.3: perhaps a template list continuation?
6011 ;; we can probably indent it just like an arglist-cont
6015 ;; CASE 5D.4: perhaps a multiple inheritance line?
6027 t)
6031 ;; CASE 5D.5: Continuation of the "expression part" of a
6032 ;; top level construct.
6041 ;; A preceding comma at the top level means that a
6042 ;; new variable declaration starts here. Use
6043 ;; topmost-intro-cont for it, for consistency with
6044 ;; the first variable declaration. C.f. case 5N.
6045 'topmost-intro-cont
6047 nil nil nil containing-sexp paren-state))
6048 ))
6049 ;; CASE 5E: we are looking at a access specifier
6051 c-opt-access-key
6054 paren-state))
6055 ;; Append access-label with the same anchor point as inclass gets.
6057 ;; CASE 5F: Close of a non-class declaration level block.
6062 ;; CASE 5G: we are looking at the brace which closes the
6063 ;; enclosing nested class decl
6072 ))))
6074 ;; CASE 5H: we could be looking at subsequent knr-argdecls
6080 ;; Do an extra check to avoid tripping up on
6081 ;; statements that occur in invalid contexts
6082 ;; (e.g. in macro bodies where we don't really
6083 ;; know the context of what we're looking at).
6089 ;; CASE 5I: ObjC method definition.
6094 ;; CASE 5P: AWK pattern or function or continuation
6095 ;; thereof.
6101 'topmost-intro-cont
6103 nil nil nil
6104 containing-sexp paren-state))
6105 ;; CASE 5N: At a variable declaration that follows a class
6106 ;; definition or some other block declaration that doesn't
6107 ;; end at the closing '}'. C.f. case 5D.5.
6114 ;; Speed up the backward search a bit.
6119 ;; The '}' is unbalanced.
6120 nil
6125 containing-sexp paren-state))
6126 ;; CASE 5J: we are at the topmost level, make
6127 ;; sure we skip back past any access specifiers
6130 c-opt-access-key
6145 ;; real beginning-of-line could be narrowed out due to
6146 ;; enclosure in a class block
6150 ;; Using bol instead of boi above is highly bogus, and
6151 ;; it makes our lives hard to remain compatible. :P
6161 ))
6163 macro-start
6167 ))
6168 ;; CASE 5K: we are at an ObjC method definition
6169 ;; continuation line.
6176 ;; CASE 5L: we are at the first argument of a template
6177 ;; arglist that begins on the previous line.
6181 ;; CASE 5M: we are at a topmost continuation line
6185 ))
6186 ;; (CASE 6 has been removed.)
6187 ;; CASE 7: line is an expression, not a statement. Most
6188 ;; likely we are either in a function prototype or a function
6189 ;; call argument list
6196 ;; CASE 7A: we are looking at the arglist closing paren.
6197 ;; C.f. case 7F.
6210 ;; CASE 7B: Looking at the opening brace of an
6211 ;; in-expression block or brace list. C.f. cases 4, 16A
6212 ;; and 17E.
6216 c-state-cache))
6220 placeholder
6223 paren-state)
6224 containing-sexp)))
6225 ;; placeholder is nil if it's a block directly in
6226 ;; a function arglist. That makes us skip out of
6227 ;; this case.
6228 )))
6236 ;; CASE 7C: we are looking at the first argument in an empty
6237 ;; argument list. Use arglist-close if we're actually
6238 ;; looking at a close paren or bracket.
6248 ;; CASE 7D: we are inside a conditional test clause. treat
6249 ;; these things as statements
6259 ))
6260 ;; CASE 7E: maybe a continued ObjC method call. This is the
6261 ;; case when we are inside a [] bracketed exp, and what
6262 ;; precede the opening bracket is not an identifier.
6270 )))
6271 ;; CASE 7F: we are looking at an arglist continuation line,
6272 ;; but the preceding argument is on the same line as the
6273 ;; opening paren. This case includes multi-line
6274 ;; mathematical paren groupings, but we could be on a
6275 ;; for-list continuation line. C.f. case 7A.
6290 t nil
6293 ;; CASE 7G: we are looking at just a normal arglist
6294 ;; continuation line
6297 ))
6298 ;; CASE 8: func-local multi-inheritance line
6307 ;; CASE 8A: non-hanging colon on an inher intro
6311 ;; CASE 8B: hanging colon on an inher intro
6314 ;; CASE 8C: a continued inheritance line
6318 )))
6319 ;; CASE 9: we are inside a brace-list
6328 ;; CASE 9A: In the middle of a special brace list opener.
6347 ;; CASE 9B: brace-list-close brace
6349 ;; Check special brace list closer.
6356 ;; We were between the special close char and the `)'.
6359 ;; We were before the special close char.
6363 ;; Normal brace list check.
6374 ;; Prepare for the rest of the cases below by going to the
6375 ;; token following the opening brace
6387 ;; CASE 9C: we're looking at the first line in a brace-list
6398 ;; CASE 9D: this is just a later brace-list-entry or
6399 ;; brace-entry-open
6408 ))
6409 ))))
6410 ;; CASE 10: A continued statement or top level construct.
6421 ;; This is shared with case 18.
6423 char-after-ip
6424 placeholder
6425 containing-sexp
6426 paren-state))
6427 ;; CASE 14: A case or default label
6433 lim paren-state))
6434 ;; CASE 15: any other label
6442 ;; If the surrounding statement is a switch then
6443 ;; let's analyze all labels as switch labels, so
6444 ;; that they get lined up consistently.
6445 'case-label
6449 lim paren-state))
6450 ;; CASE 16: block close brace, possibly closing the defun or
6451 ;; the class
6453 ;; From here on we have the next containing sexp in lim.
6457 ;; CASE 16E: Closing a statement block? This catches
6458 ;; cases where it's preceded by a statement keyword,
6459 ;; which works even when used in an "invalid" context,
6460 ;; e.g. a macro argument.
6464 lim paren-state))
6465 ;; CASE 16A: closing a lambda defun or an in-expression
6466 ;; block? C.f. cases 4, 7B and 17E.
6469 nil))
6471 'inline-close
6484 ;; CASE 16B: does this close an inline or a function in
6485 ;; a non-class declaration level block?
6494 ;; CASE 16F: Can be a defun-close of a function declared
6495 ;; in a statement block, e.g. in Pike or when using gcc
6496 ;; extensions. Might also trigger it with some macros
6497 ;; followed by blocks, and this gives sane indentation
6498 ;; then too. Let it through to be handled below.
6499 ;; C.f. cases B.3 and 17G.
6501 lim
6510 lim paren-state))
6511 ;; CASE 16C: if there an enclosing brace that hasn't
6512 ;; been narrowed out by a class, then this is a
6513 ;; block-close. C.f. case 17H.
6515 ;; If the block is preceded by a case/switch label on
6516 ;; the same line, we anchor at the first preceding label
6517 ;; at boi. The default handling in c-add-stmt-syntax is
6518 ;; really fixes it better, but we do like this to keep
6519 ;; the indentation compatible with version 5.28 and
6520 ;; earlier.
6527 ;; c-backward-to-block-anchor not necessary here; those
6528 ;; situations are handled in case 16E above.
6530 lim paren-state)))
6531 ;; CASE 16D: find out whether we're closing a top-level
6532 ;; class or a defun
6543 )))
6544 ;; CASE 17: Statement or defun catchall.
6547 ;; Back up statements until we find one that starts at boi.
6550 containing-sexp)))
6554 nil)
6558 ;; CASE 17B: continued statement
6562 containing-sexp paren-state))
6563 ;; CASE 17A: After a case/default label?
6571 'statement-case-open
6573 nil t nil containing-sexp paren-state))
6574 ;; CASE 17D: any old statement
6581 containing-sexp paren-state)
6584 ;; CASE 17I: Inside a substatement block.
6586 ;; The following tests are all based on containing-sexp.
6588 ;; From here on we have the next containing sexp in lim.
6593 lim paren-state)
6596 ;; CASE 17E: first statement in an in-expression block.
6597 ;; C.f. cases 4, 7B and 16A.
6600 nil))
6602 'defun-block-intro
6616 ;; CASE 17F: first statement in an inline, or first
6617 ;; statement in a top-level defun. we can tell this is it
6618 ;; if there are no enclosing braces that haven't been
6619 ;; narrowed out by a class (i.e. don't use bod here).
6628 ;; CASE 17G: First statement in a function declared inside
6629 ;; a normal block. This can occur in Pike and with
6630 ;; e.g. the gcc extensions. Might also trigger it with
6631 ;; some macros followed by blocks, and this gives sane
6632 ;; indentation then too. C.f. cases B.3 and 16F.
6641 lim paren-state))
6642 ;; CASE 17H: First statement in a block. C.f. case 16C.
6644 ;; If the block is preceded by a case/switch label on the
6645 ;; same line, we anchor at the first preceding label at
6646 ;; boi. The default handling in c-add-stmt-syntax is
6647 ;; really fixes it better, but we do like this to keep the
6648 ;; indentation compatible with version 5.28 and earlier.
6655 ;; c-backward-to-block-anchor not necessary here; those
6656 ;; situations are handled in case 17I above.
6658 lim paren-state))
6661 ))
6662 )
6663 ;; now we need to look at any modifiers
6666 ;; are we looking at a comment only line?
6670 ;; we might want to give additional offset to friends (in C++).
6675 ;; Set syntactic-relpos.
6681 nil)
6682 t))
6685 ;; Start of or a continuation of a preprocessor directive?
6700 ;; If inside a cpp expression, i.e. anywhere in a
6701 ;; cpp directive except a #define body, we only let
6702 ;; through the syntactic analysis that is internal
6703 ;; in the expression. That means the arglist
6704 ;; elements, if they are anchored inside the cpp
6705 ;; expression.
6714 ;; Inside a #define body and the syntactic analysis is
6715 ;; anchored on the start of the #define. In this case
6716 ;; we add cpp-define-intro to get the extra
6717 ;; indentation of the #define body.
6719 ;; return the syntax
6720 c-syntactic-context))))
6722 \f
6723 ;; Indentation calculation.
6726 ;; offset can be a number, a function, a variable, a list, or one of
6727 ;; the symbols + or -
6740 langelem symbol))
6750 done))
6752 ))
6755 ;; Get offset from LANGELEM which is a list beginning with the
6756 ;; syntactic symbol and followed by any analysis data it provides.
6757 ;; That data may be zero or more elements, but if at least one is
6758 ;; given then the first is the relpos (or nil). The symbol is
6759 ;; matched against `c-offsets-alist' and the offset calculated from
6760 ;; that is returned.
6770 offset
6774 ))
6777 ;; This is a compatibility wrapper for `c-calc-offset' in case
6778 ;; someone is calling it directly. It takes an old style syntactic
6779 ;; element on the form (SYMBOL . RELPOS) and converts it to the new
6780 ;; list form.
6786 ;; Calculate the syntactic indentation from a syntactic description
6787 ;; as returned by `c-guess-syntax'.
6788 ;;
6789 ;; Note that topmost-intro always has a relpos at bol, for
6790 ;; historical reasons. It's often used together with other symbols
6791 ;; that has more sane positions. Since we always use the first
6792 ;; found relpos, we rely on that these other symbols always precede
6793 ;; topmost-intro in the LANGELEMS list.
6801 ;; Got an absolute column that overrides any indentation
6802 ;; we've collected so far, but not the relative
6803 ;; indentation we might get for the nested structures
6804 ;; further down the langelems list.
6808 ;; Got a relative change of the current calculated
6809 ;; indentation.
6812 ;; Use the anchor position from the first syntactic
6813 ;; element with one.
6825 indent)))
6827 \f
6830 ;;; arch-tag: 149add18-4673-4da5-ac47-6805e4eae089
6831 ;;; cc-engine.el ends here