| blob | ea36064412f26a5890c360df34fee948fc8e2434 |
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 handling of preprocessor directives.
202 ;; This is a dynamically bound cache used together with
203 ;; `c-query-macro-start' and `c-query-and-set-macro-start'. It only
204 ;; works as long as point doesn't cross a macro boundary.
208 ;; This function does not do any hidden buffer changes.
213 c-macro-start))
216 ;; This function does not do any hidden buffer changes.
221 c-macro-start))
224 "Go to the beginning of a preprocessor directive.
225 Leave point at the beginning of the directive and return t if in one,
226 otherwise return nil and leave point unchanged.
228 This function does not do any hidden buffer changes."
239 t
241 nil)))))
244 "Go to the end of a preprocessor directive.
245 More accurately, move point to the end of the closest following line
246 that doesn't end with a line continuation backslash.
248 This function does not do any hidden buffer changes."
254 t))))
257 ;; Assuming point is at the "#" that introduces a preprocessor
258 ;; directive, it's moved forward to the start of the definition body
259 ;; if it's a "#define". Non-nil is returned in this case, in all
260 ;; other cases nil is returned and point isn't moved.
268 \f
269 ;;; Basic utility functions.
272 ;; Return the given region as a string where all syntactic
273 ;; whitespace is removed or, where necessary, replaced with a single
274 ;; space.
300 ;; Return non-nil if the string KEYWORD is a known keyword. More
301 ;; precisely, the value is the symbol for the keyword in
302 ;; `c-keywords-obarray'.
306 ;; Return non-nil if the symbol KEYWORD-SYM, as returned by
307 ;; `c-keyword-sym', is a member of LANG-CONSTANT, which is the name
308 ;; of a language constant that ends with "-kwds". If KEYWORD-SYM is
309 ;; nil then the result is nil.
312 ;; String syntax chars, suitable for skip-syntax-(forward|backward).
317 ;; Regexp matching string start syntax.
322 ;; Holds formatted error strings for the few cases where parse errors
323 ;; are reported.
328 ;; This function does not do any hidden buffer changes.
331 c-parsing-error)
333 ;; Faces given to comments and string literals. This is used in some
334 ;; situations to speed up recognition; it isn't mandatory that font
335 ;; locking is in use. This variable is extended with the face in
336 ;; `c-doc-face-name' when fontification is activated in cc-fonts.el.
341 ;; This function does not do any hidden buffer changes.
344 tmp-char-inserted)
346 nil
362 ;; If initial point was within line's indentation and we're not on
363 ;; a line with a line continuation in a macro, position after the
364 ;; indentation. Else stay at same point in text.
371 \f
372 ;; Some debug tools to visualize various special positions. This
373 ;; debug code isn't as portable as the rest of CC Mode.
409 \f
410 ;; `c-beginning-of-statement-1' and accompanying stuff.
412 ;; KLUDGE ALERT: c-maybe-labelp is used to pass information between
413 ;; c-crosses-statement-barrier-p and c-beginning-of-statement-1. A
414 ;; better way should be implemented, but this will at least shut up
415 ;; the byte compiler.
418 ;; New awk-compatible version of c-beginning-of-statement-1, ACM 2002/6/22
420 ;; Macros used internally in c-beginning-of-statement-1 for the
421 ;; automaton actions.
424 stack)))
429 t
430 ,do-if-done
435 ;; Throw nil if stack is empty, else throw non-nil.
459 noerror comma-delim)
460 "Move to the start of the current statement or declaration, or to
461 the previous one if already at the beginning of one. Only
462 statements/declarations on the same level are considered, i.e. don't
463 move into or out of sexps (not even normal expression parentheses).
467 is within the continuation. If starting at such a token, move to the
468 corresponding statement start. If at the beginning of a statement,
469 move to the closest containing statement if there is any. This might
470 also stop at a continuation clause.
472 Labels are treated as separate statements if IGNORE-LABELS is non-nil.
473 The function is not overly intelligent in telling labels from other
474 uses of colons; if used outside a statement context it might trip up
475 on e.g. inherit colons, so IGNORE-LABELS should be used then. There
476 should be no such mistakes in a statement context, however.
478 Macros are ignored unless point is within one, in which case the
479 content of the macro is treated as normal code. Aside from any normal
480 statement starts found in it, stop at the first token of the content
483 leaving them.
485 Return 'label if stopped at a label, 'same if stopped at the beginning
486 of the current statement, 'up if stepped to a containing statement,
487 'previous if stepped to a preceding statement, 'beginning if stepped
488 from a statement continuation clause to its start clause, or 'macro if
489 stepped to a macro start. Note that 'same and not 'label is returned
490 if stopped at the same label without crossing the colon character.
492 LIM may be given to limit the search. If the search hits the limit,
493 point will be left at the closest following token, or at the start
494 position if that is less ('same is returned in this case).
496 NOERROR turns off error logging to `c-parsing-error'.
498 Normally only ';' is considered to delimit statements, but if
499 COMMA-DELIM is non-nil then ',' is treated likewise."
501 ;; The bulk of this function is a pushdown automaton that looks at statement
502 ;; boundaries and the tokens (such as "while") in c-opt-block-stmt-key. Its
503 ;; purpose is to keep track of nested statements, ensuring that such
504 ;; statments are skipped over in their entirety (somewhat akin to what C-M-p
505 ;; does with nested braces/brackets/parentheses).
506 ;;
507 ;; Note: The position of a boundary is the following token.
508 ;;
509 ;; Beginning with the current token (the one following point), move back one
510 ;; sexp at a time (where a sexp is, more or less, either a token or the
511 ;; entire contents of a brace/bracket/paren pair). Each time a statement
512 ;; boundary is crossed or a "while"-like token is found, update the state of
513 ;; the PDA. Stop at the beginning of a statement when the stack (holding
514 ;; nested statement info) is empty and the position has been moved.
515 ;;
516 ;; The following variables constitute the PDA:
517 ;;
518 ;; sym: This is either the "while"-like token (e.g. 'for) we've just
519 ;; scanned back over, 'boundary if we've just gone back over a
520 ;; statement boundary, or nil otherwise.
521 ;; state: takes one of the values (nil else else-boundary while
522 ;; while-boundary catch catch-boundary).
523 ;; nil means "no "while"-like token yet scanned".
524 ;; 'else, for example, means "just gone back over an else".
525 ;; 'else-boundary means "just gone back over a statement boundary
526 ;; immediately after having gone back over an else".
527 ;; saved-pos: A vector of either saved positions (tok ptok pptok, etc.) or
528 ;; of error reporting information.
529 ;; stack: The stack onto which the PDA pushes its state. Each entry
530 ;; consists of a saved value of state and saved-pos. An entry is
531 ;; pushed when we move back over a "continuation" token (e.g. else)
532 ;; and popped when we encounter the corresponding opening token
533 ;; (e.g. if).
534 ;;
535 ;;
536 ;; The following diagram briefly outlines the PDA.
537 ;;
538 ;; Common state:
539 ;; "else": Push state, goto state `else'.
540 ;; "while": Push state, goto state `while'.
541 ;; "catch" or "finally": Push state, goto state `catch'.
542 ;; boundary: Pop state.
543 ;; other: Do nothing special.
544 ;;
545 ;; State `else':
546 ;; boundary: Goto state `else-boundary'.
547 ;; other: Error, pop state, retry token.
548 ;;
549 ;; State `else-boundary':
550 ;; "if": Pop state.
551 ;; boundary: Error, pop state.
552 ;; other: See common state.
553 ;;
554 ;; State `while':
555 ;; boundary: Save position, goto state `while-boundary'.
556 ;; other: Pop state, retry token.
557 ;;
558 ;; State `while-boundary':
559 ;; "do": Pop state.
560 ;; boundary: Restore position if it's not at start, pop state. [*see below]
561 ;; other: See common state.
562 ;;
563 ;; State `catch':
564 ;; boundary: Goto state `catch-boundary'.
565 ;; other: Error, pop state, retry token.
566 ;;
567 ;; State `catch-boundary':
568 ;; "try": Pop state.
569 ;; "catch": Goto state `catch'.
570 ;; boundary: Error, pop state.
571 ;; other: See common state.
572 ;;
573 ;; [*] In the `while-boundary' state, we had pushed a 'while state, and were
574 ;; searching for a "do" which would have opened a do-while. If we didn't
575 ;; find it, we discard the analysis done since the "while", go back to this
576 ;; token in the buffer and restart the scanning there, this time WITHOUT
577 ;; pushing the 'while state onto the stack.
578 ;;
579 ;; In addition to the above there is some special handling of labels
580 ;; and macros.
584 macro-start
587 c-stmt-delim-chars-with-comma
588 c-stmt-delim-chars))
589 pos ; Current position.
590 boundary-pos ; Position of last stmt boundary character (e.g. ;).
591 after-labels-pos ; Value of tok after first found colon.
592 last-label-pos ; Value of tok after last found colon.
593 sym ; Symbol just scanned back over (e.g. 'while or
594 ; 'boundary). See above
595 state ; Current state in the automaton. See above.
596 saved-pos ; Current saved positions. See above
597 stack ; Stack of conses (state . saved-pos).
601 tok ptok pptok ; Pos of last three sexps or bounds.
602 c-in-literal-cache c-maybe-labelp saved)
612 ;; Try to skip back over unary operator characters, to register
613 ;; that we've moved.
620 ; Make a variable in
621 ; cc-langs.el, maybe
623 ;; Skip back over any semicolon here. If it was a bare semicolon, we're
624 ;; done. Later on we ignore the boundaries for statements that doesn't
625 ;; contain any sexp. The only thing that is affected is that the error
626 ;; checking is a little less strict, and we really don't bother.
638 ;; ACM, 2002/7/20: What about giving a limit to the above function?
639 ;; ACM, 2003/6/16: The above two lines (checking for
640 ;; awk-logical-semicolon) are probably redundant after rewriting
641 ;; c-awk-backward-syntactic-ws.
643 pos saved)
645 ;; Begin at start and not pos to detect macros if we stand
646 ;; directly after the #.
649 ;; Record this as the first token if not starting inside it.
652 ;; The following while loop goes back one sexp (balanced parens,
653 ;; etc. with contents, or symbol or suchlike) each iteration. This
654 ;; movement is accomplished with a call to scan-sexps approx 130 lines
655 ;; below.
659 ;; Check for macro start. Take this out for AWK Mode (ACM, 2002/5/31)
660 ;; NO!! just make sure macro-start is nil in AWK Mode (ACM, 2002/6/22)
661 ;; It always is (ACM, 2002/6/23)
676 ;; Stop at the first token in the content of the macro.
680 ret 'macro
681 ignore-labels t))
684 ;; Do a round through the automaton if we've just passed a
685 ;; statement boundary or passed a "while"-like token.
693 ;; The PDA state handling.
694 ;;
695 ;; Refer to the description of the PDA in the opening
696 ;; comments. In the following OR form, the first leaf
697 ;; attempts to handles one of the specific actions detailed
698 ;; (e.g., finding token "if" whilst in state `else-boundary').
699 ;; We drop through to the second leaf (which handles common
700 ;; state) if no specific handler is found in the first cond.
701 ;; If a parsing error is detected (e.g. an "else" with no
702 ;; preceding "if"), we throw to the enclosing catch.
703 ;;
704 ;; Note that the (eq state 'else) means
705 ;; "we've just passed an else", NOT "we're looking for an
706 ;; else".
723 ;; Since this can cause backtracking we do a
724 ;; little more careful analysis to avoid it:
725 ;; If there's a label in front of the while
726 ;; it can't be part of a do-while.
755 ;; This is state common. We get here when the previous
756 ;; cond statement found no particular state handler.
758 ;; If we have a boundary at the start
759 ;; position we push a frame to go to the
760 ;; previous statement.
773 ;; might we be calling this from
774 ;; c-awk-after-if-do-for-while-condition-p?
775 ;; If so, avoid infinite recursion.
778 ;; The following may recursively
779 ;; call this function.
781 ;; Since this can cause backtracking we do a
782 ;; little more careful analysis to avoid it: If
783 ;; the while isn't followed by a semicolon it
784 ;; can't be a do-while.
785 ;; ACM, 2002/5/31; IT CAN IN AWK Mode. ;-(
794 ;; We're either past a statement boundary or at the
795 ;; start of a statement, so throw away any label data
796 ;; for the previous one.
798 last-label-pos nil
799 c-maybe-labelp nil))))
801 ;; Step to the previous sexp, but not if we crossed a
802 ;; boundary, since that doesn't consume an sexp.
806 ;; HERE IS THE SINGLE PLACE INSIDE THE PDA LOOP WHERE WE MOVE
807 ;; BACKWARDS THROUGH THE SOURCE. The following loop goes back
808 ;; one sexp and then only loops in special circumstances (line
809 ;; continuations and skipping past entire macros).
813 ;; Give up if we hit an unbalanced block.
814 ;; Since the stack won't be empty the code
815 ;; below will report a suitable error.
818 ;; Step again if we hit a line continuation.
819 t)
821 ;; If we started inside a macro then this
822 ;; sexp is always interesting.
823 nil)
825 ;; Otherwise check that we didn't step
826 ;; into a macro from the end.
833 t))))))
835 ;; Did the last movement by a sexp cross a statement boundary?
841 ;; Should not include the paren sexp we've
842 ;; passed over in the boundary check.
846 ;; Find its end position this way instead of
847 ;; moving forward if the sexp is large.
853 ;; Check that we didn't step into
854 ;; a macro from the end.
861 t)))))))
867 ptok tok
868 tok boundary-pos
875 ;; c-crosses-statement-barrier-p has found a colon, so
876 ;; we might be in a label now.
880 c-maybe-labelp t))
882 ;; ObjC method def?
889 ;; We've moved back by a sexp, so update the token positions.
891 pptok ptok
892 ptok tok
896 ;; If the stack isn't empty there might be errors to report.
905 ;; Need to investigate closer whether we've crossed
906 ;; between a substatement and its containing statement.
908 ptok
909 pptok))
916 after-labels-pos)
917 ;; We're in a label. Maybe we should step to the statement
918 ;; after it.
925 ;; Skip over the unary operators that can start the statement.
934 ret)))
937 "Return non-nil if buffer positions FROM to TO cross one or more
938 statement or declaration boundaries. The returned value is actually
939 the position of the earliest boundary char. FROM must not be within
940 a string or comment.
942 The variable `c-maybe-labelp' is set to the position of the first `:' that
943 might start a label (i.e. not part of `::' and not preceded by `?'). If a
944 single `?' is found, then `c-maybe-labelp' is cleared."
946 lit-range)
960 ;; Ignore scope operators.
964 ;; A question mark. Can't be a label, so stop
965 ;; looking for more : and ?.
975 nil))))
977 \f
978 ;; A set of functions that covers various idiosyncrasies in
979 ;; implementations of `forward-comment'.
981 ;; Note: Some emacsen considers incorrectly that any line comment
982 ;; ending with a backslash continues to the next line. I can't think
983 ;; of any way to work around that in a reliable way without changing
984 ;; the buffer, though. Suggestions welcome. ;) (No, temporarily
985 ;; changing the syntax for backslash doesn't work since we must treat
986 ;; escapes in string literals correctly.)
989 "Move forward past whitespace and the closest following comment, if any.
990 Return t if a comment was found, nil otherwise. In either case, the
991 point is moved past the following whitespace. Line continuations,
992 i.e. a backslashes followed by line breaks, are treated as whitespace.
993 The line breaks that end line comments are considered to be the
994 comment enders, so the point will be put on the beginning of the next
995 line if it moved past a line comment.
997 This function does not do any hidden buffer changes."
1005 ;; Some emacsen (e.g. XEmacs 21) return t when moving
1006 ;; forwards at eob.
1007 nil
1009 ;; Emacs includes the ending newline in a b-style (c++)
1010 ;; comment, but XEmacs doesn't. We depend on the Emacs
1011 ;; behavior (which also is symmetric).
1015 t))))
1018 "Move forward past all following whitespace and comments.
1019 Line continuations, i.e. a backslashes followed by line breaks, are
1020 treated as whitespace.
1022 This function does not do any hidden buffer changes."
1025 ;; If forward-comment in at least XEmacs 21 is given a large
1026 ;; positive value, it'll loop all the way through if it hits
1027 ;; eob.
1029 ;; Some emacsen (e.g. XEmacs 21) return t when moving
1030 ;; forwards at eob.
1035 t))))
1038 "Move backward past whitespace and the closest preceding comment, if any.
1039 Return t if a comment was found, nil otherwise. In either case, the
1040 point is moved past the preceding whitespace. Line continuations,
1041 i.e. a backslashes followed by line breaks, are treated as whitespace.
1042 The line breaks that end line comments are considered to be the
1043 comment enders, so the point cannot be at the end of the same line to
1044 move over a line comment.
1046 This function does not do any hidden buffer changes."
1049 ;; When we got newline terminated comments, forward-comment in all
1050 ;; supported emacsen so far will stop at eol of each line not
1051 ;; ending with a comment when moving backwards. This corrects for
1052 ;; that, and at the same time handles line continuations.
1061 ;; Some emacsen (e.g. Emacs 19.34) return t when moving
1062 ;; backwards at bob.
1063 nil
1065 ;; Leave point after the closest following newline if we've
1066 ;; backed up over any above, since forward-comment won't move
1067 ;; backward over a line comment if point is at the end of the
1068 ;; same line.
1073 ;; If forward-comment above succeeded and we're at eol
1074 ;; then the newline we moved over above didn't end a
1075 ;; line comment, so we give it another go.
1077 t))
1079 ;; Emacs <= 20 and XEmacs move back over the closer of a
1080 ;; block comment that lacks an opener.
1083 t)))))
1086 "Move backward past all preceding whitespace and comments.
1087 Line continuations, i.e. a backslashes followed by line breaks, are
1088 treated as whitespace. The line breaks that end line comments are
1089 considered to be the comment enders, so the point cannot be at the end
1090 of the same line to move over a line comment.
1092 This function does not do any hidden buffer changes."
1096 ;; `forward-comment' in some emacsen (e.g. Emacs 19.34)
1097 ;; return t when moving backwards at bob.
1102 ;; Emacs <= 20 and XEmacs move back over the
1103 ;; closer of a block comment that lacks an opener.
1105 t)
1107 ;; XEmacs treats line continuations as whitespace but
1108 ;; only in the backward direction, which seems a bit
1109 ;; odd. Anyway, this is necessary for Emacs.
1114 t))))))
1116 \f
1117 ;; Tools for skipping over syntactic whitespace.
1119 ;; The following functions use text properties to cache searches over
1120 ;; large regions of syntactic whitespace. It works as follows:
1121 ;;
1122 ;; o If a syntactic whitespace region contains anything but simple
1123 ;; whitespace (i.e. space, tab and line breaks), the text property
1124 ;; `c-in-sws' is put over it. At places where we have stopped
1125 ;; within that region there's also a `c-is-sws' text property.
1126 ;; That since there typically are nested whitespace inside that
1127 ;; must be handled separately, e.g. whitespace inside a comment or
1128 ;; cpp directive. Thus, from one point with `c-is-sws' it's safe
1129 ;; to jump to another point with that property within the same
1130 ;; `c-in-sws' region. It can be likened to a ladder where
1131 ;; `c-in-sws' marks the bars and `c-is-sws' the rungs.
1132 ;;
1133 ;; o The `c-is-sws' property is put on the simple whitespace chars at
1134 ;; a "rung position" and also maybe on the first following char.
1135 ;; As many characters as can be conveniently found in this range
1136 ;; are marked, but no assumption can be made that the whole range
1137 ;; is marked (it could be clobbered by later changes, for
1138 ;; instance).
1139 ;;
1140 ;; Note that some part of the beginning of a sequence of simple
1141 ;; whitespace might be part of the end of a preceding line comment
1142 ;; or cpp directive and must not be considered part of the "rung".
1143 ;; Such whitespace is some amount of horizontal whitespace followed
1144 ;; by a newline. In the case of cpp directives it could also be
1145 ;; two newlines with horizontal whitespace between them.
1146 ;;
1147 ;; The reason to include the first following char is to cope with
1148 ;; "rung positions" that doesn't have any ordinary whitespace. If
1149 ;; `c-is-sws' is put on a token character it does not have
1150 ;; `c-in-sws' set simultaneously. That's the only case when that
1151 ;; can occur, and the reason for not extending the `c-in-sws'
1152 ;; region to cover it is that the `c-in-sws' region could then be
1153 ;; accidentally merged with a following one if the token is only
1154 ;; one character long.
1155 ;;
1156 ;; o On buffer changes the `c-in-sws' and `c-is-sws' properties are
1157 ;; removed in the changed region. If the change was inside
1158 ;; syntactic whitespace that means that the "ladder" is broken, but
1159 ;; a later call to `c-forward-sws' or `c-backward-sws' will use the
1160 ;; parts on either side and use an ordinary search only to "repair"
1161 ;; the gap.
1162 ;;
1163 ;; Special care needs to be taken if a region is removed: If there
1164 ;; are `c-in-sws' on both sides of it which do not connect inside
1165 ;; the region then they can't be joined. If e.g. a marked macro is
1166 ;; broken, syntactic whitespace inside the new text might be
1167 ;; marked. If those marks would become connected with the old
1168 ;; `c-in-sws' range around the macro then we could get a ladder
1169 ;; with one end outside the macro and the other at some whitespace
1170 ;; within it.
1171 ;;
1172 ;; The main motivation for this system is to increase the speed in
1173 ;; skipping over the large whitespace regions that can occur at the
1174 ;; top level in e.g. header files that contain a lot of comments and
1175 ;; cpp directives. For small comments inside code it's probably
1176 ;; slower than using `forward-comment' straightforwardly, but speed is
1177 ;; not a significant factor there anyway.
1179 ; (defface c-debug-is-sws-face
1180 ; '((t (:background "GreenYellow")))
1181 ; "Debug face to mark the `c-is-sws' property.")
1182 ; (defface c-debug-in-sws-face
1183 ; '((t (:underline t)))
1184 ; "Debug face to mark the `c-in-sws' property.")
1186 ; (defun c-debug-put-sws-faces ()
1187 ; ;; Put the sws debug faces on all the `c-is-sws' and `c-in-sws'
1188 ; ;; properties in the buffer.
1189 ; (interactive)
1190 ; (save-excursion
1191 ; (let (in-face)
1192 ; (goto-char (point-min))
1193 ; (setq in-face (if (get-text-property (point) 'c-is-sws)
1194 ; (point)))
1195 ; (while (progn
1196 ; (goto-char (next-single-property-change
1197 ; (point) 'c-is-sws nil (point-max)))
1198 ; (if in-face
1199 ; (progn
1200 ; (c-debug-add-face in-face (point) 'c-debug-is-sws-face)
1201 ; (setq in-face nil))
1202 ; (setq in-face (point)))
1203 ; (not (eobp))))
1204 ; (goto-char (point-min))
1205 ; (setq in-face (if (get-text-property (point) 'c-in-sws)
1206 ; (point)))
1207 ; (while (progn
1208 ; (goto-char (next-single-property-change
1209 ; (point) 'c-in-sws nil (point-max)))
1210 ; (if in-face
1211 ; (progn
1212 ; (c-debug-add-face in-face (point) 'c-debug-in-sws-face)
1213 ; (setq in-face nil))
1214 ; (setq in-face (point)))
1215 ; (not (eobp)))))))
1218 ;;`(message ,@args)
1219 )
1253 ;; Called from `after-change-functions'. Note that if
1254 ;; `c-forward-sws' or `c-backward-sws' are used outside
1255 ;; `c-save-buffer-state' or similar then this will remove the cache
1256 ;; properties right after they're added.
1259 ;; Adjust the end to remove the properties in any following simple
1260 ;; ws up to and including the next line break, if there is any
1261 ;; after the changed region. This is necessary e.g. when a rung
1262 ;; marked empty line is converted to a line comment by inserting
1263 ;; "//" before the line break. In that case the line break would
1264 ;; keep the rung mark which could make a later `c-backward-sws'
1265 ;; move into the line comment instead of over it.
1275 ;; Ensure that an `c-in-sws' range gets broken. Note that it isn't
1276 ;; safe to keep a range that was continuous before the change. E.g:
1277 ;;
1278 ;; #define foo
1279 ;; \
1280 ;; bar
1281 ;;
1282 ;; There can be a "ladder" between "#" and "b". Now, if the newline
1283 ;; after "foo" is removed then "bar" will become part of the cpp
1284 ;; directive instead of a syntactically relevant token. In that
1285 ;; case there's no longer syntactic ws from "#" to "b".
1292 ;; Used by `c-forward-syntactic-ws' to implement the unbounded search.
1295 ;; unmarked part of the simple ws region.
1297 rung-is-marked next-rung-is-marked simple-ws-end
1298 ;; `safe-start' is set when it's safe to cache the start position.
1299 ;; It's not set if we've initially skipped over comments and line
1300 ;; continuations since we might have gone out through the end of a
1301 ;; macro then. This provision makes `c-forward-sws' not populate the
1302 ;; cache in the majority of cases, but otoh is `c-backward-sws' by far
1303 ;; more common.
1304 safe-start)
1306 ;; Skip simple ws and do a quick check on the following character to see
1307 ;; if it's anything that can't start syntactic ws, so we can bail out
1308 ;; early in the majority of cases when there just are a few ws chars.
1315 ;; Find the last rung position to avoid setting properties in all
1316 ;; the cases when the marked rung is complete.
1317 ;; (`next-single-property-change' is certain to move at least one
1318 ;; step forward.)
1321 ;; Got no marked rung here. Since the simple ws might have started
1322 ;; inside a line comment or cpp directive we must set `rung-pos' as
1323 ;; high as possible.
1332 ;; The following search is the main reason that `c-in-sws'
1333 ;; and `c-is-sws' aren't combined to one property.
1337 ;; If the `c-in-sws' region extended past the last
1338 ;; `c-is-sws' char we have to go back a bit.
1345 "c-forward-sws cached move %s -> %s (max %s)"
1352 ;; We'll loop here if there is simple ws after the last rung.
1353 ;; That means that there's been some change in it and it's
1354 ;; possible that we've stepped into another ladder, so extend
1355 ;; the previous one to join with it if there is one, and try to
1356 ;; use the cache again.
1358 "c-forward-sws extending rung with [%s..%s] (max %s)"
1361 ;; Remove any `c-in-sws' property from the last char of
1362 ;; the rung before we mark it with `c-is-sws', so that we
1363 ;; won't connect with the remains of a broken "ladder".
1369 last-put-in-sws-pos rung-pos)))
1376 ;; Skipped over comments. Don't cache at eob in case the buffer
1377 ;; is narrowed.
1388 ;; Skip a preprocessor directive.
1395 ;; Don't cache at eob in case the buffer is narrowed.
1398 ;; We've searched over a piece of non-white syntactic ws. See if this
1399 ;; can be cached.
1405 ;; Cache if we haven't skipped comments only, and if we started
1406 ;; either from a marked rung or from a completely uncached
1407 ;; position.
1412 ;; See if there's a marked rung in the encountered simple ws. If
1413 ;; so then we can cache, unless `safe-start' is nil. Even then
1414 ;; we need to do this to check if the cache can be used for the
1415 ;; next step.
1419 safe-start))
1423 "c-forward-sws caching [%s..%s] - [%s..%s] (max %s)"
1427 ;; Remove the properties for any nested ws that might be cached.
1428 ;; Only necessary for `c-is-sws' since `c-in-sws' will be set
1429 ;; anyway.
1437 last-put-in-sws-pos rung-pos))
1439 ;; Remove any `c-in-sws' property from the last char of
1440 ;; the rung before we mark it with `c-is-sws', so that we
1441 ;; won't connect with the remains of a broken "ladder".
1444 rung-end-pos))
1447 "c-forward-sws not caching [%s..%s] - [%s..%s] (max %s)"
1451 ;; Set `rung-pos' for the next rung. It's the same thing here as
1452 ;; initially, except that the rung position is set as early as
1453 ;; possible since we can't be in the ending ws of a line comment or
1454 ;; cpp directive now.
1461 ;; Make sure that the newly marked `c-in-sws' region doesn't connect to
1462 ;; another one after the point (which might occur when editing inside a
1463 ;; comment or macro).
1467 "c-forward-sws clearing at %s for cache separation"
1468 last-put-in-sws-pos)
1472 ;; If at eob we have to clear the last character before the end
1473 ;; instead since the buffer might be narrowed and there might
1474 ;; be a `c-in-sws' after (point-max). In this case it's
1475 ;; necessary to clear both properties.
1477 "c-forward-sws clearing thoroughly at %s for cache separation"
1480 last-put-in-sws-pos))))
1481 )))
1484 ;; Used by `c-backward-syntactic-ws' to implement the unbounded search.
1487 ;; part of the simple ws region.
1489 rung-is-marked simple-ws-beg cmt-skip-pos)
1491 ;; Skip simple horizontal ws and do a quick check on the preceding
1492 ;; character to see if it's anying that can't end syntactic ws, so we can
1493 ;; bail out early in the majority of cases when there just are a few ws
1494 ;; chars. Newlines are complicated in the backward direction, so we can't
1495 ;; skip over them.
1502 ;; Try to find a rung position in the simple ws preceding point, so that
1503 ;; we can get a cache hit even if the last bit of the simple ws has
1504 ;; changed recently.
1510 ;; `rung-pos' will be the earliest marked position, which means that
1511 ;; there might be later unmarked parts in the simple ws region.
1512 ;; It's not worth the effort to fix that; the last part of the
1513 ;; simple ws is also typically edited often, so it could be wasted.
1524 ;; The following search is the main reason that `c-in-sws'
1525 ;; and `c-is-sws' aren't combined to one property.
1529 ;; If the `c-in-sws' region extended past the first
1530 ;; `c-is-sws' char we have to go forward a bit.
1535 "c-backward-sws cached move %s <- %s (min %s)"
1547 t
1549 nil))
1551 ;; We'll loop here if there is simple ws before the first rung.
1552 ;; That means that there's been some change in it and it's
1553 ;; possible that we've stepped into another ladder, so extend
1554 ;; the previous one to join with it if there is one, and try to
1555 ;; use the cache again.
1557 "c-backward-sws extending rung with [%s..%s] (min %s)"
1560 ;; Remove any `c-in-sws' property from the last char of
1561 ;; the rung before we mark it with `c-is-sws', so that we
1562 ;; won't connect with the remains of a broken "ladder".
1565 rung-pos)
1569 last-put-in-sws-pos rung-pos))
1578 ;; Inside a cpp directive. See if it should be skipped over.
1581 ;; Move back over all line continuations in the region skipped
1582 ;; over by `c-backward-comments'. If we go past it then we
1583 ;; started inside the cpp directive.
1592 ;; Don't move past the cpp directive if we began inside
1593 ;; it. Note that the position at the end of the last line
1594 ;; of the macro is also considered to be within it.
1596 nil)
1598 ;; It's worthwhile to spend a little bit of effort on finding
1599 ;; the end of the macro, to get a good `simple-ws-beg'
1600 ;; position for the cache. Note that `c-backward-comments'
1601 ;; could have stepped over some comments before going into
1602 ;; the macro, and then `simple-ws-beg' must be kept on the
1603 ;; same side of those comments.
1610 ;; Might happen if comments after the macro were skipped
1611 ;; over.
1615 t)))
1620 simple-ws-beg)
1621 ;; Skipped over comments. Must put point at the end of
1622 ;; the simple ws at point since we might be after a line
1623 ;; comment or cpp directive that's been partially
1624 ;; narrowed out, and we can't risk marking the simple ws
1625 ;; at the end of it.
1627 t)))
1629 ;; We've searched over a piece of non-white syntactic ws. See if this
1630 ;; can be cached.
1635 ;; Cache if we started either from a marked rung or from a
1636 ;; completely uncached position.
1637 rung-is-marked
1640 ;; Cache if there's a marked rung in the encountered simple ws.
1648 "c-backward-sws caching [%s..%s] - [%s..%s] (min %s)"
1653 ;; Remove the properties for any nested ws that might be cached.
1654 ;; Only necessary for `c-is-sws' since `c-in-sws' will be set
1655 ;; anyway.
1660 ;; Remove any `c-in-sws' property from the last char of
1661 ;; the rung before we mark it with `c-is-sws', so that we
1662 ;; won't connect with the remains of a broken "ladder".
1665 rung-end-pos)
1668 last-put-in-sws-pos simple-ws-beg)
1669 rung-pos)
1674 "c-backward-sws not caching [%s..%s] - [%s..%s] (min %s)"
1680 ))
1682 ;; Make sure that the newly marked `c-in-sws' region doesn't connect to
1683 ;; another one before the point (which might occur when editing inside a
1684 ;; comment or macro).
1688 "c-backward-sws clearing at %s for cache separation"
1691 last-put-in-sws-pos))
1693 ;; If at bob and the buffer is narrowed, we have to clear the
1694 ;; character we're standing on instead since there might be a
1695 ;; `c-in-sws' before (point-min). In this case it's necessary
1696 ;; to clear both properties.
1698 "c-backward-sws clearing thoroughly at %s for cache separation"
1699 last-put-in-sws-pos)
1702 )))
1704 \f
1705 ;; A system for handling noteworthy parens before the point.
1709 ;; The state cache used by `c-parse-state' to cut down the amount of
1710 ;; searching. It's the result from some earlier `c-parse-state' call.
1711 ;; The use of the cached info is more effective if the next
1712 ;; `c-parse-state' call is on a line close by the one the cached state
1713 ;; was made at; the cache can actually slow down a little if the
1714 ;; cached state was made very far back in the buffer. The cache is
1715 ;; most effective if `c-parse-state' is used on each line while moving
1716 ;; forward.
1720 ;; This is (point-min) when `c-state-cache' was calculated, since a
1721 ;; change of narrowing is likely to affect the parens that are visible
1722 ;; before the point.
1725 ;; Invalidate all info on `c-state-cache' that applies to the buffer
1726 ;; at POS or higher. This is much like `c-whack-state-after', but
1727 ;; it never changes a paren pair element into an open paren element.
1728 ;; Doing that would mean that the new open paren wouldn't have the
1729 ;; required preceding paren pair element.
1730 ;;
1731 ;; This function does not do any hidden buffer changes.
1741 ;; Finds and records all noteworthy parens between some good point
1742 ;; earlier in the file and point. That good point is at least the
1743 ;; beginning of the top-level construct we are in, or the beginning
1744 ;; of the preceding top-level construct if we aren't in one.
1745 ;;
1746 ;; The returned value is a list of the noteworthy parens with the
1747 ;; last one first. If an element in the list is an integer, it's
1748 ;; the position of an open paren which has not been closed before
1749 ;; the point. If an element is a cons, it gives the position of a
1750 ;; closed brace paren pair; the car is the start paren position and
1751 ;; the cdr is the position following the closing paren. Only the
1752 ;; last closed brace paren pair before each open paren is recorded,
1753 ;; and thus the state never contains two cons elements in
1754 ;; succession.
1755 ;;
1756 ;; Currently no characters which are given paren syntax with the
1757 ;; syntax-table property are recorded, i.e. angle bracket arglist
1758 ;; parens are never present here. Note that this might change.
1759 ;;
1760 ;; This function does not do any hidden buffer changes.
1766 old-state last-pos pairs pos save-pos)
1769 ;; If the minimum position has changed due to narrowing then we
1770 ;; have to fix the tail of `c-state-cache' accordingly.
1773 ;; If point-min has moved forward then we just need to cut
1774 ;; off a bit of the tail.
1784 ;; If point-min has moved backward then we drop the state
1785 ;; completely. It's possible to do a better job here and
1786 ;; recalculate the top only.
1790 ;; Get the latest position we know are directly inside the
1791 ;; closest containing paren of the cached state.
1797 ;; Check if the found last-pos is in a macro. If it is, and
1798 ;; we're not in the same macro, we must discard everything on
1799 ;; c-state-cache that is inside the macro before using it.
1806 ;; Set last-pos again, just like above.
1813 ;; Find the start position for the forward search. (Can't
1814 ;; search in the backward direction since point might be
1815 ;; in some kind of literal.)
1818 ;; There's a cached state with a containing paren. Pop
1819 ;; off the stale containing sexps from it by going
1820 ;; forward out of parens as far as possible.
1834 ;; The last paren pair we moved out from was a brace
1835 ;; pair. Modify the state to record this as a closed
1836 ;; pair now.
1840 c-state-cache))))
1842 ;; Check if the preceding balanced paren is within a
1843 ;; macro; it should be ignored if we're outside the
1844 ;; macro. There's no need to check any further upwards;
1845 ;; if the macro contains an unbalanced opening paren then
1846 ;; we're smoked anyway.
1857 last-pos))
1860 ;; go back 2 bods, but ignore any bogus positions
1861 ;; returned by beginning-of-defun (i.e. open paren in
1862 ;; column zero)
1874 ;; Find the balanced brace pairs.
1876 pairs nil)
1882 ;; Should ignore any pairs that are in a macro, providing
1883 ;; we're not in the same one.
1890 ;; Record the last brace pair.
1894 ;; There's a closed pair on the cached state but we've
1895 ;; found a later one, so remove it.
1900 ;; There could already be a cons first in `c-state-cache'
1901 ;; if we've e.g. jumped over an unbalanced open paren in a
1902 ;; macro below.
1907 ;; Prepare to loop, but record the open paren only if it's
1908 ;; outside a macro or within the same macro as point, and
1909 ;; if it is a legitimate open paren and not some character
1910 ;; that got an open paren syntax-table property.
1917 ;; Check for known types of parens that we want
1918 ;; to record. The syntax table is not to be
1919 ;; trusted here since the caller might be using
1920 ;; e.g. `c++-template-syntax-table'.
1925 ;; Found a close paren without a corresponding opening
1926 ;; one. Maybe we didn't go back far enough, so try to
1927 ;; scan backward for the start paren and then start over.
1930 c-state-cache nil)
1932 ;; Emacs (up to at least 21.2) can get confused by
1933 ;; open parens in column zero inside comments: The
1934 ;; sexp functions can then misbehave and bring us
1935 ;; back to the same point again. Check this so that
1936 ;; we don't get an infinite loop.
1939 c-parsing-error
1945 c-state-cache)))
1947 ;; Debug tool to catch cache inconsistencies.
1958 res1 res2))
1959 res1))
1964 'c-debug-parse-state
1969 ;; Whack off any state information from PAREN-STATE which lies
1970 ;; before BUFPOS. Not destructive on PAREN-STATE.
1971 ;;
1972 ;; This function does not do any hidden buffer changes.
1975 car)
1986 ;; Whack off any state information from PAREN-STATE which lies at or
1987 ;; after BUFPOS. Not destructive on PAREN-STATE.
1988 ;;
1989 ;; This function does not do any hidden buffer changes.
1994 ;; just check the car, because in a balanced brace
1995 ;; expression, it must be impossible for the corresponding
1996 ;; close brace to be before point, but the open brace to
1997 ;; be after.
1999 nil ; whack it off
2001 ;; its possible that the open brace is before
2002 ;; bufpos, but the close brace is after. In that
2003 ;; case, convert this to a non-cons element. The
2004 ;; rest of the state is before bufpos, so we're
2005 ;; done.
2007 ;; we know that both the open and close braces are
2008 ;; before bufpos, so we also know that everything else
2009 ;; on state is before bufpos.
2012 nil ; whack it off
2013 ;; it's before bufpos, so everything else should too.
2016 nil)))
2019 ;; Return the bufpos of the innermost enclosing open paren before
2020 ;; bufpos that hasn't been narrowed out, or nil if none was found.
2021 ;;
2022 ;; This function does not do any hidden buffer changes.
2034 enclosingp))
2037 ;; Return the bufpos of the outermost enclosing open paren before
2038 ;; bufpos that hasn't been narrowed out, or nil if none was found.
2039 ;;
2040 ;; This function does not do any hidden buffer changes.
2050 pos))
2053 ;; Return the closest known safe position higher up than BUFPOS, or
2054 ;; nil if PAREN-STATE doesn't contain one. Return nil if BUFPOS is
2055 ;; nil, which is useful to find the closest limit before a given
2056 ;; limit that might be nil.
2057 ;;
2058 ;; This function does not do any hidden buffer changes.
2068 ;; See below.
2071 ;; elem is the position at and not after the opening paren, so
2072 ;; we can go forward one more step unless it's equal to
2073 ;; bufpos. This is useful in some cases avoid an extra paren
2074 ;; level between the safe position and bufpos.
2079 ;; This is used for `font-lock-beginning-of-syntax-function'. It
2080 ;; goes to the closest previous point that is known to be outside
2081 ;; any string literal or comment. `c-state-cache' is used if it has
2082 ;; a position in the vicinity.
2084 elem
2087 ;; Note: Similar code in `c-safe-position'. The
2088 ;; difference is that we accept a safe position at
2089 ;; the point and don't bother to go forward past open
2090 ;; parens.
2105 ;; The position is far back. Try `c-beginning-of-defun-1'
2106 ;; (although we can't be entirely sure it will go to a position
2107 ;; outside a comment or string in current emacsen). FIXME:
2108 ;; Consult `syntax-ppss' here.
2113 \f
2114 ;; Tools for scanning identifiers and other tokens.
2117 "Return non-nil if the point is on or directly after an identifier.
2118 Keywords are recognized and not considered identifiers. If an
2119 identifier is detected, the returned value is its starting position.
2120 If an identifier both starts and stops at the point \(can only happen
2121 in Pike) then the point for the preceding one is returned.
2123 This function does not do any hidden buffer changes."
2129 ;; Handle the `<operator> syntax in Pike.
2133 t
2144 ;; If the point is at the end of a symbol then skip backward to the
2145 ;; beginning of it. Don't move otherwise. Return non-nil if point
2146 ;; moved.
2149 ;; Handle the `<operator> syntax in Pike.
2155 t
2157 nil)))))
2160 ;; Move to the beginning of the current token. Do not move if not
2161 ;; in the middle of one. BACK-LIMIT may be used to bound the
2162 ;; backward search; if given it's assumed to be at the boundary
2163 ;; between two tokens.
2170 ;; `c-nonsymbol-token-regexp' should always match
2171 ;; since we've skipped backward over punctuator
2172 ;; or paren syntax, but consume one char in case
2173 ;; it doesn't so that we don't leave point before
2174 ;; some earlier incorrect token.
2181 ;; Move to the end of the current token. Do not move if not in the
2182 ;; middle of one. BACK-LIMIT may be used to bound the backward
2183 ;; search; if given it's assumed to be at the boundary between two
2184 ;; tokens. Return non-nil if the point is moved, nil otherwise.
2192 ;; `c-nonsymbol-token-regexp' should always match since
2193 ;; we've skipped backward over punctuator or paren
2194 ;; syntax, but move forward in case it doesn't so that
2195 ;; we don't leave point earlier than we started with.
2211 "Move forward by tokens.
2212 A token is defined as all symbols and identifiers which aren't
2214 treated properly). Point is always either left at the beginning of a
2215 token or not moved at all. COUNT specifies the number of tokens to
2216 move; a negative COUNT moves in the opposite direction. A COUNT of 0
2217 moves to the next token beginning only if not already at one. If
2218 BALANCED is true, move over balanced parens, otherwise move into them.
2219 Also, if BALANCED is true, never move out of an enclosing paren.
2221 LIMIT sets the limit for the movement and defaults to the point limit.
2222 The case when LIMIT is set in the middle of a token, comment or macro
2223 is handled correctly, i.e. the point won't be left there.
2225 Return the number of tokens left to move \(positive or negative). If
2226 BALANCED is true, a move over a balanced paren counts as one. Note
2227 that if COUNT is 0 and no appropriate token beginning is found, 1 will
2228 be returned. Thus, a return value of 0 guarantees that point is at
2229 the requested position and a return value less \(without signs) than
2230 COUNT guarantees that point is at the beginning of some token."
2237 c-jump-syntax-balanced
2238 c-jump-syntax-unbalanced))
2243 ;; If count is zero we should jump if in the middle of a token.
2250 ;; Skip whitespace. Count this as a move if we did in
2251 ;; fact move.
2255 ;; Moved out of bounds. Make sure the returned count isn't zero.
2260 ;; Use `condition-case' to avoid having the limit tests
2261 ;; inside the loop.
2269 t)
2272 t)
2273 ;; `c-nonsymbol-token-regexp' above should always
2274 ;; match if there are correct tokens. Try to
2275 ;; widen to see if the limit was set in the
2276 ;; middle of one, else fall back to treating
2277 ;; the offending thing as a one character token.
2282 nil)
2285 t))))
2295 count)))
2298 "Move backward by tokens.
2299 See `c-forward-token-2' for details."
2307 c-jump-syntax-balanced
2308 c-jump-syntax-unbalanced))
2312 ;; The count is zero so try to skip to the beginning of the
2313 ;; current token.
2317 ;; The limit is inside the same token, so return 1.
2320 ;; We're not in the middle of a token. If there's
2321 ;; whitespace after the point then we must move backward,
2322 ;; so set count to 1 in that case.
2324 ;; If we're looking at a '#' that might start a cpp
2325 ;; directive then we have to do a more elaborate check.
2338 ;; Use `condition-case' to avoid having to check for buffer
2339 ;; limits in `backward-char', `scan-sexps' and `goto-char' below.
2348 ;; This can be very inefficient if there's a long
2349 ;; sequence of operator tokens without any separation.
2350 ;; That doesn't happen in practice, anyway.
2360 count)))
2363 "Like `c-forward-token-2' but doesn't treat multicharacter operator
2365 characters are jumped over character by character. This function is
2366 for compatibility only; it's only a wrapper over `c-forward-token-2'."
2371 "Like `c-backward-token-2' but doesn't treat multicharacter operator
2373 characters are jumped over character by character. This function is
2374 for compatibility only; it's only a wrapper over `c-backward-token-2'."
2378 \f
2379 ;; Tools for doing searches restricted to syntactically relevant text.
2382 paren-level not-inside-token
2383 lookbehind-submatch)
2384 "Like `re-search-forward', but only report matches that are found
2385 in syntactically significant text. I.e. matches in comments, macros
2386 or string literals are ignored. The start point is assumed to be
2387 outside any comment, macro or string literal, or else the content of
2388 that region is taken as syntactically significant text.
2390 If PAREN-LEVEL is non-nil, an additional restriction is added to
2391 ignore matches in nested paren sexps. The search will also not go
2392 outside the current list sexp, which has the effect that if the point
2393 should be moved to BOUND when no match is found \(i.e. NOERROR is
2394 neither nil nor t), then it will be at the closing paren if the end of
2395 the current list sexp is encountered first.
2397 If NOT-INSIDE-TOKEN is non-nil, matches in the middle of tokens are
2398 ignored. Things like multicharacter operators and special symbols
2400 constants.
2402 If LOOKBEHIND-SUBMATCH is non-nil, it's taken as a number of a
2403 subexpression in REGEXP. The end of that submatch is used as the
2404 position to check for syntactic significance. If LOOKBEHIND-SUBMATCH
2405 isn't used or if that subexpression didn't match then the start
2407 subexpression is never tested before the starting position, so it
2411 subexpression can match the end of nonwhite syntactic whitespace,
2412 i.e. the end of comments or cpp directives. This since the function
2413 skips over such things before resuming the search. It's on the other
2415 matches syntactic whitespace.
2417 Bug: Unbalanced parens inside cpp directives are currently not handled
2418 correctly \(i.e. they don't get ignored as they should) when
2419 PAREN-LEVEL is set."
2424 ;;(message "c-syntactic-re-search-forward %s %s %S" (point) bound regexp)
2427 tmp
2428 ;; Start position for the last search.
2429 search-pos
2430 ;; The `parse-partial-sexp' state between the start position
2431 ;; and the point.
2432 state
2433 ;; The current position after the last state update. The next
2434 ;; `parse-partial-sexp' continues from here.
2436 ;; The position at which to check the state and the state
2437 ;; there. This is separate from `state-pos' since we might
2438 ;; need to back up before doing the next search round.
2439 check-pos check-state
2440 ;; Last position known to end a token.
2442 ;; Set when a valid match is found.
2443 found)
2461 state-pos check-pos paren-level nil state))
2463 check-state state))
2465 ;; NOTE: If we got a look behind subexpression and get
2466 ;; an insignificant match in something that isn't
2467 ;; syntactic whitespace (i.e. strings or in nested
2468 ;; parentheses), then we can never skip more than a
2469 ;; single character from the match start position
2470 ;; (i.e. `state-pos' here) before continuing the
2471 ;; search. That since the look behind subexpression
2472 ;; might match the end of the insignificant region in
2473 ;; the next search.
2477 ;; Match inside a line comment. Skip to eol. Use
2478 ;; `re-search-forward' instead of `skip-chars-forward' to get
2479 ;; the right bound behavior.
2483 ;; Match inside a block comment. Skip to the '*/'.
2490 ;; Match in the middle of the opener of a block or line
2491 ;; comment.
2496 ;; The last `parse-partial-sexp' above might have
2497 ;; stopped short of the real check position if the end
2498 ;; of the current sexp was encountered in paren-level
2499 ;; mode. The checks above are always false in that
2500 ;; case, and since they can do better skipping in
2501 ;; lookbehind-submatch mode, we do them before
2502 ;; checking the paren level.
2506 ;; Check the paren level first since we're short of the
2507 ;; syntactic checking position if the end of the
2508 ;; current sexp was encountered by `parse-partial-sexp'.
2511 ;; Inside a nested paren sexp.
2513 ;; See the NOTE above.
2515 ;; Skip out of the paren quickly.
2519 ;; Have exited the current paren sexp.
2522 ;; The last `parse-partial-sexp' call above
2523 ;; has left us just after the closing paren
2524 ;; in this case, so we can modify the bound
2525 ;; to leave the point at the right position
2526 ;; upon return.
2528 nil)
2532 ;; Match inside a string.
2535 ;; See the NOTE above.
2537 ;; Skip to the end of the string before continuing.
2546 continue)))
2551 ;; Match inside a macro. Skip to the end of it.
2559 (< check-pos
2565 ;; Inside a token.
2567 ;; See the NOTE above.
2572 ;; A real match.
2574 nil)))
2576 ;; Should loop to search again, but take care to avoid
2577 ;; looping on the same spot.
2581 nil
2584 t))))
2590 ;;(message "c-syntactic-re-search-forward done %s" (or (match-end 0) (point)))
2597 ;; Search failed. Set point as appropriate.
2601 nil)))
2604 "Like `skip-chars-backward' but only look at syntactically relevant chars,
2605 i.e. don't stop at positions inside syntactic whitespace or string
2606 literals. Preprocessor directives are also ignored, with the exception
2607 of the one that the point starts within, if any. If LIMIT is given,
2608 it's assumed to be at a syntactically relevant position."
2611 ;; A list of syntactically relevant positions in descending
2612 ;; order. It's used to avoid scanning repeatedly over
2613 ;; potentially large regions with `parse-partial-sexp' to verify
2614 ;; each position.
2615 safe-pos-list
2616 ;; The result from `c-beginning-of-macro' at the start position or the
2617 ;; start position itself if it isn't within a macro. Evaluated on
2618 ;; demand.
2619 start-macro-beg)
2625 ;; Use `parse-partial-sexp' from a safe position down to
2626 ;; the point to check if it's outside comments and
2627 ;; strings.
2629 ;; Pick a safe position as close to the point as
2630 ;; possible.
2631 ;;
2632 ;; FIXME: Consult `syntax-ppss' here if our
2633 ;; cache doesn't give a good position.
2649 ;; Cache positions along the way to use if we have to
2650 ;; back up more. Every closing paren on the same
2651 ;; level seems like fairly well spaced positions.
2657 ;; Inside string or comment. Continue search at the
2658 ;; beginning of it.
2660 ;; It's an emacs where `parse-partial-sexp'
2661 ;; supplies the starting position.
2664 t)
2667 ;; Inside a macro.
2675 t
2676 ;; It's inside the same macro we started in so it's
2677 ;; a relevant match.
2679 nil))))))
2683 ;; Skip syntactic ws afterwards so that we don't stop at the
2684 ;; end of a comment if `skip-chars' is something like "^/".
2690 \f
2691 ;; Tools for handling comments and string literals.
2694 "Return the type of literal point is in, if any.
2695 The return value is `c' if in a C-style comment, `c++' if in a C++
2696 style comment, `string' if in a string literal, `pound' if DETECT-CPP
2697 is non-nil and in a preprocessor line, or nil if somewhere else.
2698 Optional LIM is used as the backward limit of the search. If omitted,
2699 or nil, `c-beginning-of-defun' is used.
2701 The last point calculated is cached if the cache is enabled, i.e. if
2702 `c-in-literal-cache' is bound to a two element vector.
2704 This function does not do any hidden buffer changes."
2719 ;; cache this result if the cache is enabled
2722 rtn)))
2724 ;; XEmacs has a built-in function that should make this much quicker.
2725 ;; I don't think we even need the cache, which makes our lives more
2726 ;; complicated anyway. In this case, lim is only used to detect
2727 ;; cpp directives.
2728 ;;
2729 ;; Note that there is a bug in Xemacs's buffer-syntactic-context when used in
2730 ;; conjunction with syntax-table-properties. The bug is present in, e.g.,
2731 ;; Xemacs 21.4.4. It manifested itself thus:
2732 ;;
2733 ;; Starting with an empty AWK Mode buffer, type
2734 ;; /regexp/ {<C-j>
2735 ;; Point gets wrongly left at column 0, rather than being indented to tab-width.
2736 ;;
2737 ;; AWK Mode is designed such that when the first / is typed, it gets the
2738 ;; syntax-table property "string fence". When the second / is typed, BOTH /s
2739 ;; are given the s-t property "string". However, buffer-syntactic-context
2740 ;; fails to take account of the change of the s-t property on the opening / to
2741 ;; "string", and reports that the { is within a string started by the second /.
2742 ;;
2743 ;; The workaround for this is for the AWK Mode initialisation to switch the
2744 ;; defalias for c-in-literal to c-slow-in-literal. This will slow down other
2745 ;; cc-modes in Xemacs whenever an awk-buffer has been initialised.
2746 ;;
2747 ;; (Alan Mackenzie, 2003/4/30).
2762 ;; The defalias above isn't enough to shut up the byte compiler.
2766 "Return a cons of the beginning and end positions of the comment or
2767 string surrounding point (including both delimiters), or nil if point
2769 to start parsing from. If NEAR is non-nil, then the limits of any
2771 spaces and tabs between point and the literal. The search for such a
2772 literal is done first in forward direction. If NOT-IN-DELIMITER is
2773 non-nil, the case when point is inside a starting delimiter won't be
2774 recognized. This only has effect for comments, which have starting
2775 delimiters with more than one character.
2777 This function does not do any hidden buffer changes."
2787 ;; String. Search backward for the start.
2795 ;; Line comment. Search from bol for the comment starter.
2808 ;; Block comment. Search backward for the comment starter.
2818 ;; We're standing in a comment starter.
2825 ;; Search forward for a literal.
2837 ;; Search backward.
2848 ;; Block comment. Due to the nature of line
2849 ;; comments, they will always be covered by the
2850 ;; normal case above.
2853 ;; If LIM is bogus, beg will be bogus.
2857 ))))
2860 ;; Like c-literal-limits, but for emacsen whose `parse-partial-sexp'
2861 ;; returns the pos of the comment start.
2863 "Return a cons of the beginning and end positions of the comment or
2864 string surrounding point (including both delimiters), or nil if point
2866 to start parsing from. If NEAR is non-nil, then the limits of any
2868 spaces and tabs between point and the literal. The search for such a
2869 literal is done first in forward direction. If NOT-IN-DELIMITER is
2870 non-nil, the case when point is inside a starting delimiter won't be
2871 recognized. This only has effect for comments, which have starting
2872 delimiters with more than one character.
2874 This function does not do any hidden buffer changes."
2896 ;; We're standing in a comment starter.
2903 ;; Search forward for a literal.
2915 ;; Search backward.
2926 ;; Block comment. Due to the nature of line
2927 ;; comments, they will always be covered by the
2928 ;; normal case above.
2931 ;; If LIM is bogus, beg will be bogus.
2935 ))))
2941 "If the argument is a cons of two buffer positions (such as returned by
2942 `c-literal-limits'), and that range contains a C++ style line comment,
2943 then an extended range is returned that contains all adjacent line
2944 comments (i.e. all comments that starts in the same column with no
2945 empty lines or non-whitespace characters between them). Otherwise the
2946 argument is returned.
2948 This function does not do any hidden buffer changes."
2958 ;; Got to take care in the backward direction to handle
2959 ;; comments which are preceded by code.
2973 range)
2977 "Convenience function that given the result of `c-literal-limits',
2978 returns nil or the type of literal that the range surrounds. It's
2979 much faster than using `c-in-literal' and is intended to be used when
2980 you need both the type of a literal and its limits.
2982 This function does not do any hidden buffer changes."
2992 range))
2994 \f
2995 ;; `c-find-decl-spots' and accompanying stuff.
2997 ;; Variables used in `c-find-decl-spots' to cache the search done for
2998 ;; the first declaration in the last call. When that function starts,
2999 ;; it needs to back up over syntactic whitespace to look at the last
3000 ;; token before the region being searched. That can sometimes cause
3001 ;; moves back and forth over a quite large region of comments and
3002 ;; macros, which would be repeated for each changed character when
3003 ;; we're called during fontification, since font-lock refontifies the
3004 ;; current line for each change. Thus it's worthwhile to cache the
3005 ;; first match.
3006 ;;
3007 ;; `c-find-decl-syntactic-pos' is a syntactically relevant position in
3008 ;; the syntactic whitespace less or equal to some start position.
3009 ;; There's no cached value if it's nil.
3010 ;;
3011 ;; `c-find-decl-match-pos' is the match position if
3012 ;; `c-find-decl-prefix-search' matched before the syntactic whitespace
3013 ;; at `c-find-decl-syntactic-pos', or nil if there's no such match.
3024 ; (defface c-debug-decl-spot-face
3025 ; '((t (:background "Turquoise")))
3026 ; "Debug face to mark the spots where `c-find-decl-spots' stopped.")
3027 ; (defface c-debug-decl-sws-face
3028 ; '((t (:background "Khaki")))
3029 ; "Debug face to mark the syntactic whitespace between the declaration
3030 ; spots and the preceding token end.")
3046 ;; Macro used inside `c-find-decl-spots'. It ought to be a defun,
3047 ;; but it contains lots of free variables that refer to things
3048 ;; inside `c-find-decl-spots'. The point is left at `cfd-match-pos'
3049 ;; if there is a match, otherwise at `cfd-limit'.
3052 ;; Find the next property match position if we haven't got one already.
3063 ;; Find the next `c-decl-prefix-re' match if we haven't got one already.
3068 c-literal-faces))
3069 ;; Search again if the match is within a comment or a string literal.
3079 ;; Choose whichever match is closer to the start.
3082 cfd-re-match nil)
3084 cfd-prop-match nil))
3089 ;; Skip forward past comments only so we don't skip macros.
3091 ;; Set the position to continue at. We can avoid going over
3092 ;; the comments skipped above a second time, but it's possible
3093 ;; that the comment skipping has taken us past `cfd-prop-match'
3094 ;; since the property might be used inside comments.
3100 ;; Call CFD-FUN for each possible spot for a declaration from the
3101 ;; point to CFD-LIMIT. A spot for a declaration is the first token
3102 ;; in the buffer and each token after the ones matched by
3103 ;; `c-decl-prefix-re' and after the occurrences of the `c-type'
3104 ;; property with the value `c-decl-end' (if `c-type-decl-end-used'
3105 ;; is set). Only a spot that match CFD-DECL-RE and whose face is in
3106 ;; the CFD-FACE-CHECKLIST list causes CFD-FUN to be called. The
3107 ;; face check is disabled if CFD-FACE-CHECKLIST is nil.
3108 ;;
3109 ;; If the match is inside a macro then the buffer is narrowed to the
3110 ;; end of it, so that CFD-FUN can investigate the following tokens
3111 ;; without matching something that begins inside a macro and ends
3112 ;; outside it. It's to avoid this work that the CFD-DECL-RE and
3113 ;; CFD-FACE-CHECKLIST checks exist.
3114 ;;
3115 ;; CFD-FUN is called with point at the start of the spot. It's
3116 ;; passed two arguments: The first is the end position of the token
3117 ;; that `c-decl-prefix-re' matched, or 0 for the implicit match at
3118 ;; bob. The second is a flag that is t when the match is inside a
3119 ;; macro.
3120 ;;
3121 ;; It's assumed that comment and strings are fontified in the
3122 ;; searched range.
3123 ;;
3124 ;; This is mainly used in fontification, and so has an elaborate
3125 ;; cache to handle repeated calls from the same start position; see
3126 ;; the variables above.
3127 ;;
3128 ;; All variables in this function begin with `cfd-' to avoid name
3129 ;; collision with the (dynamically bound) variables used in CFD-FUN.
3132 ;; The last regexp match found by `c-find-decl-prefix-search'.
3133 cfd-re-match
3134 ;; The last `c-decl-end' found by `c-find-decl-prefix-search'.
3135 ;; If searching for the property isn't needed then we disable
3136 ;; it by faking a first match at the limit.
3138 ;; The position of the last match found by
3139 ;; `c-find-decl-prefix-search'. For regexp matches it's the
3140 ;; end of the matched token, for property matches it's the end
3141 ;; of the property. 0 for the implicit match at bob.
3142 ;; `cfd-limit' if there's no match.
3144 ;; The position to continue searching at.
3145 cfd-continue-pos
3146 ;; The position of the last "real" token we've stopped at.
3147 ;; This can be greater than `cfd-continue-pos' when we get
3148 ;; hits inside macros or at `c-decl-end' positions inside
3149 ;; comments.
3151 ;; The end position of the last entered macro.
3154 ;; Initialize by finding a syntactically relevant start position
3155 ;; before the point, and do the first `c-decl-prefix-re' search
3156 ;; unless we're at bob.
3159 ;; Must back up a bit since we look for the end of the previous
3160 ;; statement or declaration, which is earlier than the first
3161 ;; returned match.
3164 ;; But first we need to move to a syntactically relevant
3165 ;; position. Use the faces to back up to the start of the
3166 ;; comment or string literal.
3175 ;; XEmacs doesn't fontify the quotes surrounding string
3176 ;; literals.
3185 ;; The font lock package might not have fontified the start of
3186 ;; the literal at all so check that we have arrived at
3187 ;; something that looks like a start or else resort to
3188 ;; `c-literal-limits'.
3193 ;; Must back out of any macro so that we don't miss any
3194 ;; declaration that could follow after it, unless the limit is
3195 ;; inside the macro. We only check that for the current line to
3196 ;; save some time; it's enough for the by far most common case
3197 ;; when font-lock refontifies the current line only.
3205 ;; Clear the cache if it applied further down.
3211 ;; If we hit `c-find-decl-syntactic-pos' and
3212 ;; `c-find-decl-match-pos' is set then we install the cached
3213 ;; values. If we hit `c-find-decl-syntactic-pos' and
3214 ;; `c-find-decl-match-pos' is nil then we know there's no decl
3215 ;; prefix in the whitespace before `c-find-decl-syntactic-pos'
3216 ;; and so we can continue the search from this point. If we
3217 ;; didn't hit `c-find-decl-syntactic-pos' then we're now in the
3218 ;; right spot to begin searching anyway.
3220 c-find-decl-match-pos)
3223 ;; The match is always outside macros and comments so we
3224 ;; start at the next token. The loop below will later go
3225 ;; back using `cfd-continue-pos' to fix declarations inside
3226 ;; the syntactic ws.
3230 cfd-continue-pos syntactic-pos)
3237 ;; Always consider bob a match to get the first declaration
3238 ;; in the file. Do this separately instead of letting
3239 ;; `c-decl-prefix-re' match bob, so that it always can
3240 ;; consume at least one character to ensure that we won't
3241 ;; get stuck in an infinite loop.
3246 ;; Do an initial search now. In the bob case above it's only done
3247 ;; to search for the `c-type' property.
3250 ;; Advance `cfd-continue-pos' if we got a hit before the start
3251 ;; position. The earliest position that could affect after
3252 ;; the start position is the char before the preceding
3253 ;; comments.
3262 ;; If we got a match it's always outside macros and comments so
3263 ;; advance to the next token and set `cfd-token-pos'. The loop
3264 ;; below will later go back using `cfd-continue-pos' to fix
3265 ;; declarations inside the syntactic ws.
3274 cfd-match-pos))))
3276 ;; Now loop. We already got the first match.
3283 ;; Kludge to filter out matches on the "<" that
3284 ;; aren't open parens, for the sake of languages
3285 ;; that got `c-recognize-<>-arglists' set.
3290 ;; If `cfd-continue-pos' is less or equal to
3291 ;; `cfd-token-pos', we've got a hit inside a macro
3292 ;; that's in the syntactic whitespace before the last
3293 ;; "real" declaration we've checked. If they're equal
3294 ;; we've arrived at the declaration a second time, so
3295 ;; there's nothing to do.
3299 ;; If `cfd-continue-pos' is less than `cfd-token-pos'
3300 ;; we're still searching for declarations embedded in
3301 ;; the syntactic whitespace. In that case we need
3302 ;; only to skip comments and not macros, since they
3303 ;; can't be nested, and that's already been done in
3304 ;; `c-find-decl-prefix-search'.
3309 ;; Continue if the following token fails the
3310 ;; CFD-DECL-RE and CFD-FACE-CHECKLIST checks.
3317 t)))
3325 ;; Narrow to the end of the macro if we got a hit inside
3326 ;; one, to avoid recognizing things that start inside
3327 ;; the macro and end outside it.
3329 ;; Not in the same macro as in the previous round.
3340 t
3343 t)
3344 ;; The matched token was the last thing in the
3345 ;; macro, so the whole match is bogus.
3347 nil)))
3353 ;; Restore limits if we did macro narrowment above.
3361 \f
3362 ;; A cache for found types.
3364 ;; Buffer local variable that contains an obarray with the types we've
3365 ;; found. If a declaration is recognized somewhere we record the
3366 ;; fully qualified identifier in it to recognize it as a type
3367 ;; elsewhere in the file too. This is not accurate since we do not
3368 ;; bother with the scoping rules of the languages, but in practice the
3369 ;; same name is seldom used as both a type and something else in a
3370 ;; file, and we only use this as a last resort in ambiguous cases (see
3371 ;; `c-font-lock-declarations').
3376 ;; Clears `c-found-types'.
3377 ;;
3378 ;; This function does not do any hidden buffer changes.
3382 ;; Add the given region as a type in `c-found-types'. If the region
3383 ;; doesn't match an existing type but there is a type which is equal
3384 ;; to the given one except that the last character is missing, then
3385 ;; the shorter type is removed. That's done to avoid adding all
3386 ;; prefixes of a type as it's being entered and font locked. This
3387 ;; doesn't cover cases like when characters are removed from a type
3388 ;; or added in the middle. We'd need the position of point when the
3389 ;; font locking is invoked to solve this well.
3394 ;; To avoid storing very long strings, do not add a type that
3395 ;; contains '<' in languages with angle bracket arglists, since
3396 ;; the type then probably contains a C++ template spec and those
3397 ;; can be fairly sized programs in themselves.
3404 ;; Return non-nil if the given region contains a type in
3405 ;; `c-found-types'.
3409 ;; Return all the types in `c-found-types' as a sorted list of
3410 ;; strings.
3414 type-list)))
3415 c-found-types)
3418 \f
3419 ;; Handling of small scale constructs like types and names.
3422 ;; Remove all the properties put by `c-forward-<>-arglist' in the
3423 ;; specified region. Point is clobbered.
3433 ;; Dynamically bound variable that instructs `c-forward-type' to also
3434 ;; treat possible types (i.e. those that it normally returns 'maybe or
3435 ;; 'found for) as actual types (and always return 'found for them).
3436 ;; This means that it records them in `c-record-type-identifiers' if
3437 ;; that is set, and that it adds them to `c-found-types'.
3440 ;; Dynamically bound variable that instructs `c-forward-<>-arglist' to
3441 ;; not accept arglists that contain binary operators.
3442 ;;
3443 ;; This is primarily used to handle C++ template arglists. C++
3444 ;; disambiguates them by checking whether the preceding name is a
3445 ;; template or not. We can't do that, so we assume it is a template
3446 ;; if it can be parsed as one. That usually works well since
3447 ;; comparison expressions on the forms "a < b > c" or "a < b, c > d"
3448 ;; in almost all cases would be pointless.
3449 ;;
3450 ;; However, in function arglists, e.g. in "foo (a < b, c > d)", we
3451 ;; should let the comma separate the function arguments instead. And
3452 ;; in a context where the value of the expression is taken, e.g. in
3453 ;; "if (a < b || c > d)", it's probably not a template.
3456 ;; Dynamically bound variables that instructs `c-forward-name',
3457 ;; `c-forward-type' and `c-forward-<>-arglist' to record the ranges of
3458 ;; all the type and reference identifiers they encounter. They will
3459 ;; build lists on these variables where each element is a cons of the
3460 ;; buffer positions surrounding each identifier. This recording is
3461 ;; only activated when `c-record-type-identifiers' is non-nil.
3462 ;;
3463 ;; All known types that can't be identifiers are recorded, and also
3464 ;; other possible types if `c-promote-possible-types' is set.
3465 ;; Recording is however disabled inside angle bracket arglists that
3466 ;; are encountered inside names and other angle bracket arglists.
3467 ;; Such occurences are taken care of by `c-font-lock-<>-arglists'
3468 ;; instead.
3469 ;;
3470 ;; Only the names in C++ template style references (e.g. "tmpl" in
3471 ;; "tmpl<a,b>::foo") are recorded as references, other references
3472 ;; aren't handled here.
3476 ;; If `c-record-type-identifiers' is set, this will receive a cons
3477 ;; cell of the range of the last single identifier symbol stepped over
3478 ;; by `c-forward-name' if it's successful. This is the range that
3479 ;; should be put on one of the record lists by the caller. It's
3480 ;; assigned nil if there's no such symbol in the name.
3485 ;; Always true.
3495 ;; Always true.
3503 ;; Dynamically bound variable that instructs `c-forward-type' to
3504 ;; record the ranges of types that only are found. Behaves otherwise
3505 ;; like `c-record-type-identifiers'.
3509 ;; Used internally in `c-forward-keyword-clause' to move forward
3510 ;; over a type (if TYPE is 'type) or a name (otherwise) which
3511 ;; possibly is prefixed by keywords and their associated clauses.
3512 ;; Try with a type/name first to not trip up on those that begin
3513 ;; with a keyword. Return t if a known or found type is moved
3514 ;; over. The point is clobbered if nil is returned. If range
3515 ;; recording is enabled, the identifier is recorded on as a type
3516 ;; if TYPE is 'type or as a reference if TYPE is 'ref.
3521 nil
3528 t)))
3531 ;; Used internally in `c-forward-keyword-clause' to move forward
3532 ;; over a comma separated list of types or names using
3533 ;; `c-forward-keyword-prefixed-id'.
3543 ;; The first submatch in the current match data is assumed to
3544 ;; surround a token. If it's a keyword, move over it and any
3545 ;; following clauses associated with it, stopping at the next
3546 ;; following token. t is returned in that case, otherwise the point
3547 ;; stays and nil is returned. The kind of clauses that are
3548 ;; recognized are those specified by `c-type-list-kwds',
3549 ;; `c-ref-list-kwds', `c-colon-type-list-kwds',
3550 ;; `c-paren-nontype-kwds', `c-paren-type-kwds', `c-<>-type-kwds',
3551 ;; and `c-<>-arglist-kwds'.
3562 ;; There's a type directly after a keyword in `c-type-list-kwds'.
3567 ;; There's a name directly after a keyword in `c-ref-list-kwds'.
3572 ;; There's an open paren after a keyword in `c-paren-any-kwds'.
3579 ;; Use `c-forward-type' on every identifier we can find
3580 ;; inside the paren, to record the types.
3607 ;; If a keyword matched both one of the types above and
3608 ;; this one, we match `c-colon-type-list-re' after the
3609 ;; clause matched above.
3616 ;; There's a type after the `c-colon-type-list-re'
3617 ;; match after a keyword in `c-colon-type-list-kwds'.
3621 t)))
3624 ;; The point is assumed to be at a '<'. Try to treat it as the open
3625 ;; paren of an angle bracket arglist and move forward to the the
3626 ;; corresponding '>'. If successful, the point is left after the
3627 ;; '>' and t is returned, otherwise the point isn't moved and nil is
3628 ;; returned. If ALL-TYPES is t then all encountered arguments in
3629 ;; the arglist that might be types are treated as found types.
3630 ;;
3631 ;; The surrounding '<' and '>' are given syntax-table properties to
3632 ;; make them behave like parentheses. Each argument separating ','
3633 ;; is also set to `c-<>-arg-sep' in the `c-type' property. These
3634 ;; properties are also cleared in a relevant region forward from the
3635 ;; point if they seems to be set and it turns out to not be an
3636 ;; arglist.
3637 ;;
3638 ;; If the arglist has been successfully parsed before then paren
3639 ;; syntax properties will be exploited to quickly jump to the end,
3640 ;; but that can be disabled by setting REPARSE to t. That is
3641 ;; necessary if the various side effects, e.g. recording of type
3642 ;; ranges, are important. Setting REPARSE to t only applies
3643 ;; recursively to nested angle bracket arglists if
3644 ;; `c-restricted-<>-arglists' is set.
3647 ;; If `c-record-type-identifiers' is set then activate
3648 ;; recording of any found types that constitute an argument in
3649 ;; the arglist.
3657 ;; `nconc' doesn't mind that the tail of
3658 ;; `c-record-found-types' is t.
3660 t)
3663 nil)))
3666 ;; Recursive part of `c-forward-<>-arglist'.
3669 ;; Cover this so that any recorded found type ranges are
3670 ;; automatically lost if it turns out to not be an angle
3671 ;; bracket arglist. It's propagated through the return value
3672 ;; on successful completion.
3674 ;; List that collects the positions after the argument
3675 ;; separating ',' in the arglist.
3676 arg-start-pos)
3678 ;; If the '<' has paren open syntax then we've marked it as an
3679 ;; angle bracket arglist before, so try to skip to the end and see
3680 ;; that the close paren matches.
3697 nil)))
3705 ;; Got an arglist that appears to be valid.
3707 ;; Reparsing is requested, so zap the properties in the
3708 ;; region and go on to redo it. It's done here to
3709 ;; avoid leaving it behind if we exit through
3710 ;; `angle-bracket-arglist-escape' below.
3714 nil)
3715 t)
3717 ;; Got unmatched paren brackets or either paren was
3718 ;; actually some other token. Recover by clearing the
3719 ;; syntax properties on all the '<' and '>' in the
3720 ;; range where we'll search for the arglist below.
3731 nil)))
3732 t
3742 ;; All encountered identifiers are types, so set the
3743 ;; promote flag and parse the type.
3750 ;; Check if this arglist argument is a sole type. If
3751 ;; it's known then it's recorded in
3752 ;; `c-record-type-identifiers'. If it only is found
3753 ;; then it's recorded in `c-record-found-types' which we
3754 ;; might roll back if it turns out that this isn't an
3755 ;; angle bracket arglist afterall.
3761 ;; A found type was recorded but it's not the
3762 ;; only thing in the arglist argument, so reset
3763 ;; `c-record-found-types'.
3765 orig-record-found-types))))))
3769 ;; Must check for '>' at the very start separately,
3770 ;; since the regexp below has to avoid ">>" without
3771 ;; using \\=.
3773 t)
3775 ;; Note: These regexps exploit the match order in \| so
3776 ;; that "<>" is matched by "<" rather than "[^>:-]>".
3779 ;; Stop on ',', '|', '&', '+' and '-' to catch
3780 ;; common binary operators that could be between
3781 ;; two comparison expressions "a<b" and "c>d".
3783 ;; Otherwise we still stop on ',' to find the
3784 ;; argument start positions.
3788 ;; If the arglist starter has lost its open paren
3789 ;; syntax but not the closer, we won't find the
3790 ;; closer above since we only search in the
3791 ;; balanced sexp. In that case we stop just short
3792 ;; of it so check if the following char is the closer.
3794 ;; Remove its syntax so that we don't enter the
3795 ;; recovery code below. That's not necessary
3796 ;; since there's no real reason to suspect that
3797 ;; things inside the arglist are unbalanced.
3800 t)))
3804 ;; Either an operator starting with '>' or the end of
3805 ;; the angle bracket arglist.
3813 ;; We've skipped past a list that ended with '>'. It
3814 ;; must be unbalanced since nested arglists are handled
3815 ;; in the case below. Recover by removing all paren
3816 ;; properties on '<' and '>' in the searched region and
3817 ;; redo the search.
3821 t)
3830 t)
3832 ;; The angle bracket arglist is finished.
3840 nil)))
3843 ;; Either an operator starting with '<' or a nested arglist.
3855 ;; There's always an identifier before a angle
3856 ;; bracket arglist, or a keyword in
3857 ;; `c-<>-type-kwds' or `c-<>-arglist-kwds'.
3876 )))
3878 ;; It was not an angle bracket arglist.
3883 ;; Got an invalid open paren syntax on this
3884 ;; '<'. We'll probably get an unbalanced '>'
3885 ;; further ahead if we just remove the syntax
3886 ;; here, so recover by removing all paren
3887 ;; properties up to and including the
3888 ;; balancing close paren.
3894 ;; It was an angle bracket arglist.
3897 ;; Record the identifier before the template as a type
3898 ;; or reference depending on whether the arglist is last
3899 ;; in a qualified identifier.
3908 t)
3912 ;; Just another argument. Record the position. The
3913 ;; type check stuff that made us stop at it is at
3914 ;; the top of the loop.
3918 ;; Got a character that can't be in an angle bracket
3919 ;; arglist argument. Abort using `throw', since
3920 ;; it's useless to try to find a surrounding arglist
3921 ;; if we're nested.
3928 ;; Move forward over a complete name if at the beginning of one,
3929 ;; stopping at the next following token. If the point is not at
3930 ;; something that are recognized as name then it stays put. A name
3931 ;; could be something as simple as "foo" in C or something as
3932 ;; complex as "X<Y<class A<int>::B, BIT_MAX >> b>, ::operator<> ::
3933 ;; Z<(a>b)> :: operator const X<&foo>::T Q::G<unsigned short
3934 ;; int>::*volatile const" in C++ (this function is actually little
3935 ;; more than a `looking-at' call in all modes except those that,
3936 ;; like C++, have `c-recognize-<>-arglists' set). Return nil if no
3937 ;; name is found, 'template if it's an identifier ending with an
3938 ;; angle bracket arglist, 'operator of it's an operator identifier,
3939 ;; or t if it's some other kind of name.
3942 ;; Turn off `c-promote-possible-types' here since we might
3943 ;; call `c-forward-<>-arglist' and we don't want it to promote
3944 ;; every suspect thing in the arglist to a type. We're
3945 ;; typically called from `c-forward-type' in this case, and
3946 ;; the caller only wants the top level type that it finds to
3947 ;; be promoted.
3948 c-promote-possible-types)
3954 ;; Check for keyword. We go to the last symbol in
3955 ;; `c-identifier-key' first.
3971 ;; "template" is only valid inside an
3972 ;; identifier if preceded by "::".
3977 t))
3979 ;; Handle a C++ operator or template identifier.
3983 ;; Got "... ::template".
3987 res subres))))
3990 ;; Got a cast operator.
3994 ;; Now we should match a sequence of either
3995 ;; '*', '&' or a name followed by ":: *",
3996 ;; where each can be followed by a sequence
3997 ;; of `c-opt-type-modifier-key'.
4000 t)
4010 t))))
4018 ;; Got some other operator.
4027 nil)
4035 res t)))
4045 ;; Got a concatenated identifier. This handles the
4046 ;; cases with tricky syntactic whitespace that aren't
4047 ;; covered in `c-identifier-key'.
4050 t)
4054 ;; Maybe an angle bracket arglist.
4063 ;; Continue if there's an identifier concatenation
4064 ;; operator after the template argument.
4071 t)
4072 ;; `c-add-type' isn't called here since we don't
4073 ;; want to add types containing angle bracket
4074 ;; arglists.
4079 nil)))
4080 )))))
4083 res))
4086 ;; Move forward over a type spec if at the beginning of one,
4087 ;; stopping at the next following token. Return t if it's a known
4088 ;; type that can't be a name or other expression, 'known if it's an
4089 ;; otherwise known type (according to `*-font-lock-extra-types'),
4090 ;; 'prefix if it's a known prefix of a type, 'found if it's a type
4091 ;; that matches one in `c-found-types', 'maybe if it's an identfier
4092 ;; that might be a type, or nil if it can't be a type (the point
4093 ;; isn't moved then). The point is assumed to be at the beginning
4094 ;; of a token.
4095 ;;
4096 ;; Note that this function doesn't skip past the brace definition
4097 ;; that might be considered part of the type, e.g.
4098 ;; "enum {a, b, c} foo".
4101 ;; Skip leading type modifiers. If any are found we know it's a
4102 ;; prefix of a type.
4111 ;; Looking at a keyword that prefixes a type identifier,
4112 ;; e.g. "class".
4119 ;; In many languages the name can be used without the
4120 ;; prefix, so we add it to `c-found-types'.
4125 ;; Invalid syntax.
4137 id-range c-last-identifier-range))))
4149 id-end)
4151 ;; Looking at a primitive or known type identifier. We've
4152 ;; checked for a name first so that we don't go here if the
4153 ;; known type match only is a prefix of another name.
4164 ;; There might be more keywords for the type.
4192 ;; A normal identifier.
4202 ;; It's an identifier that has been used as
4203 ;; a type somewhere else.
4204 'found
4205 ;; It's an identifier that might be a type.
4208 ;; A template is a type.
4212 ;; Otherwise it's an operator identifier, which is not a type.
4217 ;; Skip trailing type modifiers. If any are found we know it's
4218 ;; a type.
4225 ;; Step over any type suffix operator. Do not let the existence
4226 ;; of these alter the classification of the found type, since
4227 ;; these operators typically are allowed in normal expressions
4228 ;; too.
4235 ;; Look for a trailing operator that concatenate the type with
4236 ;; a following one, and if so step past that one through a
4237 ;; recursive call.
4240 c-promote-possible-types))
4241 ;; If we can't promote then set `c-record-found-types' so that
4242 ;; we can merge in the types from the second part afterwards if
4243 ;; it turns out to be a known type there.
4254 ;; If either operand certainly is a type then both are, but we
4255 ;; don't let the existence of the operator itself promote two
4256 ;; uncertain types to a certain one.
4274 ;; Merge in the ranges of any types found by the second
4275 ;; `c-forward-type'.
4277 ;; `nconc' doesn't mind that the tail of
4278 ;; `c-record-found-types' is t.
4280 c-record-type-identifiers))))
4288 ;;(message "c-forward-type %s -> %s: %s" start (point) res)
4290 res))
4292 \f
4293 ;; Handling of large scale constructs like statements and declarations.
4296 ;; Go to the first non-whitespace after the colon that starts a
4297 ;; multiple inheritance introduction. Optional LIM is the farthest
4298 ;; back we should search.
4310 ;; Return nil if we aren't in a method definition, otherwise the
4311 ;; position of the initial [+-].
4317 ))
4319 ;; Contributed by Kevin Ryde <user42@zip.com.au>.
4321 ;; Return non-nil if point is within a gcc \"asm\" block.
4322 ;;
4323 ;; This should be called with point inside an argument list.
4324 ;;
4325 ;; Only one level of enclosing parentheses is considered, so for
4326 ;; instance `nil' is returned when in a function call within an asm
4327 ;; operand.
4337 "Return a determination as to whether point is at the `top-level'.
4338 Being at the top-level means that point is either outside any
4339 enclosing block (such function definition), or only inside a class,
4340 namespace or other block that contains another declaration level.
4342 If point is not at the top-level (e.g. it is inside a method
4343 definition), then nil is returned. Otherwise, if point is at a
4344 top-level not enclosed within a class definition, t is returned.
4345 Otherwise, a 2-vector is returned where the zeroth element is the
4346 buffer position of the start of the class declaration, and the first
4347 element is the buffer position of the enclosing class's opening
4348 brace."
4354 ;; Return non-nil if we are between a function's argument list closing
4355 ;; paren and its opening brace. Note that the list close brace
4356 ;; could be followed by a "const" specifier or a member init hanging
4357 ;; colon. LIM is used as bound for some backward buffer searches;
4358 ;; the search might continue past it.
4359 ;;
4360 ;; Note: This test is easily fooled. It only works reasonably well
4361 ;; in the situations where `c-guess-basic-syntax' uses it.
4367 ;; could be looking at const specifier
4372 ;; otherwise, we could be looking at a hanging member init
4373 ;; colon
4377 ;; this will catch member inits with multiple
4378 ;; line arglists
4391 nil
4393 )
4396 ;; Check that it isn't a cpp expression, e.g. the
4397 ;; expression of an #if directive or the "function header"
4398 ;; of a #define.
4402 ;; Check if we are looking at an ObjC method def or a class
4403 ;; category.
4413 ;; Pike has compound types that include parens,
4414 ;; e.g. "array(string)". Check that we aren't after one.
4420 ))))
4423 ;; Return the position of the first argument declaration if point is
4424 ;; inside a K&R style argument declaration list, nil otherwise.
4425 ;; `c-recognize-knr-p' is not checked. If LIM is non-nil, it's a
4426 ;; position that bounds the backward search for the argument list.
4427 ;;
4428 ;; Note: A declaration level context is assumed; the test can return
4429 ;; false positives for statements.
4434 ;; Go back to the closest preceding normal parenthesis sexp. We
4435 ;; take that as the argument list in the function header. Then
4436 ;; check that it's followed by some symbol before the next ';'
4437 ;; or '{'. If it does, it's the header of the K&R argdecl we're
4438 ;; in.
4441 paren-end)
4457 ;; The function header in a K&R declaration should only
4458 ;; contain identifiers separated by comma. It should
4459 ;; also contain at least one identifier since there
4460 ;; wouldn't be anything to declare in the K&R region
4461 ;; otherwise.
4477 ;; If it's a K&R declaration then we're now at the
4478 ;; beginning of the function arglist. Check that there
4479 ;; isn't a '=' before it in this statement since that
4480 ;; means it some kind of initialization instead.
4487 ;; skip forward over conditional at point, including any predicate
4488 ;; statements in parentheses. No error checking is performed.
4490 ;; else if()
4495 ;; do, else, try, finally
4500 ;; for, if, while, switch, catch, synchronized, foreach
4504 ;; If looking at the token after a conditional then return the
4505 ;; position of its start, otherwise return nil.
4515 ;; Assuming point is at a brace that opens a statement block of some
4516 ;; kind, move to the proper anchor point for that block. It might
4517 ;; need to be adjusted further by c-add-stmt-syntax, but the
4518 ;; position at return is suitable as start position for that
4519 ;; function.
4526 ;; Assuming point is at a brace that opens the block of a top level
4527 ;; declaration of some kind, move to the proper anchor point for
4528 ;; that block.
4533 ;; Search forward for the end of the "header" of the current
4534 ;; declaration. That's the position where the definition body
4535 ;; starts, or the first variable initializer, or the ending
4536 ;; semicolon. I.e. search forward for the closest following
4537 ;; (syntactically relevant) '{', '=' or ';' token. Point is left
4538 ;; _after_ the first found token, or at point-max if none is found.
4543 ;; In C++ we need to take special care to handle operator
4544 ;; tokens and those pesky template brackets.
4549 ;; Handle operator identifiers, i.e. ignore any
4550 ;; operator token preceded by "operator".
4557 t
4559 nil)))))
4568 ;; Go to the beginning of the current declaration, or the beginning
4569 ;; of the previous one if already at the start of it. Point won't
4570 ;; be moved out of any surrounding paren. Return a cons cell on the
4571 ;; form (MOVE . KNR-POS). MOVE is like the return value from
4572 ;; `c-beginning-of-statement-1'. If point skipped over some K&R
4573 ;; style argument declarations (and they are to be recognized) then
4574 ;; KNR-POS is set to the start of the first such argument
4575 ;; declaration, otherwise KNR-POS is nil. If LIM is non-nil, it's a
4576 ;; position that bounds the backward search.
4577 ;;
4578 ;; NB: Cases where the declaration continues after the block, as in
4579 ;; "struct foo { ... } bar;", are currently recognized as two
4580 ;; declarations, e.g. "struct foo { ... }" and "bar;" in this case.
4586 ;; `c-beginning-of-statement-1' stops at a block start, but we
4587 ;; want to continue if the block doesn't begin a top level
4588 ;; construct, i.e. if it isn't preceded by ';', '}', ':', bob,
4589 ;; or an open paren.
4592 ;; Must check with c-opt-method-key in ObjC mode.
4602 ;; Check that we don't move from the first thing in a
4603 ;; macro to its header.
4609 move tentative-move))
4614 ;; Handle K&R argdecls. Back up after the "statement" jumped
4615 ;; over by `c-beginning-of-statement-1', unless it was the
4616 ;; function body, in which case we're sitting on the opening
4617 ;; brace now. Then test if we're in a K&R argdecl region and
4618 ;; that we started at the other side of the first argdecl in
4619 ;; it.
4629 'previous
4631 knr-argdecl-start))
4635 ;; Might have ended up before a protection label. This should
4636 ;; perhaps be checked before `c-recognize-knr-p' to be really
4637 ;; accurate, but we know that no language has both.
4645 ;; `c-beginning-of-statement-1' counts each brace block as a
4646 ;; separate statement, so the result will be 'previous if we've
4647 ;; moved over any. If they were brace list initializers we might
4648 ;; not have moved over a declaration boundary though, so change it
4649 ;; to 'same if we've moved past a '=' before '{', but not ';'.
4650 ;; (This ought to be integrated into `c-beginning-of-statement-1',
4651 ;; so we avoid this extra pass which potentially can search over a
4652 ;; large amount of text.)
4655 c++-template-syntax-table
4668 ;; Assuming point is at the start of a declaration (as detected by
4669 ;; e.g. `c-beginning-of-decl-1'), go to the end of it. Unlike
4670 ;; `c-beginning-of-decl-1', this function handles the case when a
4671 ;; block is followed by identifiers in e.g. struct declarations in C
4672 ;; or C++. If a proper end was found then t is returned, otherwise
4673 ;; point is moved as far as possible within the current sexp and nil
4674 ;; is returned. This function doesn't handle macros; use
4675 ;; `c-end-of-macro' instead in those cases.
4678 c++-template-syntax-table
4686 ;; Stopped at the ';' in a K&R argdecl section which is
4687 ;; detected using the same criteria as in
4688 ;; `c-beginning-of-decl-1'. Move to the following block
4689 ;; start.
4693 ;; Encountered a block in the declaration. Jump over it.
4704 ;; Check for `c-opt-block-decls-with-vars-key'
4705 ;; before the first paren.
4708 c-opt-block-decls-with-vars-key
4710 lim t t t)
4713 ;; Check that the first following paren is
4714 ;; the block.
4716 lim t t t)
4718 ;; The declaration doesn't have any of the
4719 ;; `c-opt-block-decls-with-vars' keywords in the
4720 ;; beginning, so it ends here at the end of the block.
4728 nil)))
4731 ;; Go to the beginning of a member init list (i.e. just after the
4732 ;; ':') if inside one. Returns t in that case, nil otherwise.
4745 ;; this will catch member inits with multiple
4746 ;; line arglists
4754 ;; Skip over any template arg to the class. This way with a
4755 ;; syntax table is bogus but it'll have to do for now.
4764 ;; Skip backwards over a fully::qualified::name.
4772 ;; If we've stepped over a number then this is a bitfield.
4777 ;; now continue checking
4784 ;; search for the containing class, returning a 2 element vector if
4785 ;; found. aref 0 contains the bufpos of the boi of the class key
4786 ;; line, and aref 1 contains the bufpos of the open brace.
4788 ;; no paren-state means we cannot be inside a class
4789 nil
4791 search-start search-end)
4793 ;; a cons cell in the first element means that there is some
4794 ;; balanced sexp before the current bufpos. this we can
4795 ;; ignore. the nth 1 and nth 2 elements define for us the
4796 ;; search boundaries
4799 ;; if the car was not a cons cell then nth 0 and nth 1 define
4800 ;; for us the search boundaries
4803 ;; if search-end is nil, or if the search-end character isn't an
4804 ;; open brace, we are definitely not in a class
4808 nil
4809 ;; now, we need to look more closely at search-start. if
4810 ;; search-start is nil, then our start boundary is really
4811 ;; point-min.
4814 ;; if search-start is a cons cell, then we can start
4815 ;; searching from the end of the balanced sexp just ahead of
4816 ;; us
4819 ;; Otherwise we start searching within the surrounding paren sexp.
4821 ;; now we can do a quick regexp search from search-start to
4822 ;; search-end and see if we can find a class key. watch for
4823 ;; class like strings in literals
4832 ;; Add one to the search limit, to allow
4833 ;; matching of the "{" in the regexp.
4836 t))
4845 ;; check for embedded keywords
4851 ;; make sure we're really looking at the start of a
4852 ;; class definition, and not an ObjC method.
4857 ;; Check if this is an anonymous inner class.
4863 ;; We're done. Just trap this case in the cond.
4864 nil
4865 ;; False alarm; all conditions aren't satisfied.
4867 ;; Its impossible to define a regexp for this, and
4868 ;; nearly so to do it programmatically.
4869 ;;
4870 ;; ; picks up forward decls
4871 ;; = picks up init lists
4872 ;; ) picks up return types
4873 ;; > picks up templates, but remember that we can
4874 ;; inherit from templates!
4876 ;; try to see if we found the `class' keyword
4877 ;; inside a template arg list
4888 )))
4889 foundp))
4890 )))))
4893 ;; return the buffer position of the beginning of the brace list
4894 ;; statement if we're inside a brace list, otherwise return nil.
4895 ;; CONTAINING-SEXP is the buffer pos of the innermost containing
4896 ;; paren. BRACE-STATE is the remainder of the state of enclosing
4897 ;; braces
4898 ;;
4899 ;; N.B.: This algorithm can potentially get confused by cpp macros
4900 ;; places in inconvenient locations. Its a trade-off we make for
4901 ;; speed.
4903 ;; This will pick up brace list declarations.
4916 ;; this will pick up array/aggregate init lists, even if they are nested.
4919 ;; Pike can have class definitions anywhere, so we must
4920 ;; check for the class key here.
4922 c-decl-block-key))
4923 bufpos braceassignp lim next-containing)
4925 containing-sexp)
4936 ;; We're in an in-expression block of some kind. Do not
4937 ;; check nesting. We deliberately set the limit to the
4938 ;; containing sexp, so that c-looking-at-inexpr-block
4939 ;; doesn't check for an identifier before it.
4941 ;; see if the open brace is preceded by = or [...] in
4942 ;; this statement, but watch out for operator=
4945 ;; Checks to do only on the first sexp before the brace.
4948 ;; In Java, an initialization brace list may follow
4949 ;; directly after "new Foo[]", so check for a "new"
4950 ;; earlier.
4956 ;; Carry on looking if this is an
4957 ;; identifier (may contain "." in Java)
4958 ;; or another "[]" sexp.
4961 ;; Checks to do on all sexps before the brace, up to the
4962 ;; beginning of the statement.
4970 ;; We've seen a =, but must check earlier tokens so
4971 ;; that it isn't something that should be ignored.
4977 ;; Check for operator =
4979 ;; Check for `<opchar>= in Pike.
4982 ;; Special case for Pikes
4983 ;; `[]=, since '[' is not in
4984 ;; the punctuation class.
4987 nil)
4989 ;; make sure we're not in a C++ template
4990 ;; argument assignment
5002 ))))
5003 nil)
5010 ;; Brace lists can't contain a semicolon, so we're done.
5012 ;; Go up one level.
5014 lim nil
5015 next-containing nil))
5016 ;; we've hit the beginning of the aggregate list
5020 )
5021 bufpos))
5022 ))
5025 ;; If we're looking at the start of a pike-style list, ie `({Â })',
5026 ;; `([Â ])', `(<Â >)' etc, a cons of a cons of its starting and ending
5027 ;; positions and its entry in c-special-brace-lists is returned, nil
5028 ;; otherwise. The ending position is nil if the list is still open.
5029 ;; LIM is the limit for forward search. The point may either be at
5030 ;; the `(' or at the following paren character. Tries to check the
5031 ;; matching closer, but assumes it's correct if no balanced paren is
5032 ;; found (i.e. the case `({ ... } ... )' is detected as _not_ being
5033 ;; a special brace list).
5038 inner-beg end type)
5053 nil)))))
5063 ;; Check balancing of the inner paren
5064 ;; below.
5067 t)
5068 ;; If the inner char isn't a paren then
5069 ;; we can't check balancing, so just
5070 ;; check the char before the outer
5071 ;; closing paren.
5086 ;; Return non-nil if between two statements or declarations, assuming
5087 ;; point is not inside a literal or comment.
5091 ;; Return t if at the start inside some parenthesis expression
5092 ;; too, to catch macros that have statements as arguments.
5100 ;; Returns non-nil if we're looking at the beginning of a block
5101 ;; inside an expression. The value returned is actually a cons of
5102 ;; either 'inlambda, 'inexpr-statement or 'inexpr-class and the
5103 ;; position of the beginning of the construct. LIM limits the
5104 ;; backward search. CONTAINING-SEXP is the start position of the
5105 ;; closest containing list. If it's nil, the containing paren isn't
5106 ;; used to decide whether we're inside an expression or not. If
5107 ;; both LIM and CONTAINING-SEXP is used, LIM needs to be farther
5108 ;; back.
5112 ;; Look at the character after point only as a last resort
5113 ;; when we can't disambiguate.
5126 c-opt-inexpr-class-key
5130 ;; If the class definition is at the start of
5131 ;; a statement, we don't consider it an
5132 ;; in-expression class.
5140 ;; Also, in Pike we treat it as an
5141 ;; in-expression class if it's used in an
5142 ;; object clone expression.
5157 nil)
5164 containing-sexp
5173 nil
5175 res))))
5178 ;; Returns non-nil if we're looking at the end of an in-expression
5179 ;; block, otherwise the same as `c-looking-at-inexpr-block'.
5180 ;; PAREN-STATE is the paren state relevant at the current position.
5182 ;; We currently only recognize a block.
5185 containing-sexp)
5194 paren-state)
5195 containing-sexp)))))
5198 ;; Narrow the buffer so that the enclosing class is hidden. Uses
5199 ;; and returns the value from c-search-uplist-for-classkey.
5208 ;; if point is now left of the class opening brace, we're
5209 ;; hosed, so try a different tact
5215 ;; end point is the end of the current line
5219 ;; return the class vector
5220 inclass-p))
5222 \f
5223 ;; `c-guess-basic-syntax' and the functions that precedes it below
5224 ;; implements the main decision tree for determining the syntactic
5225 ;; analysis of the current line of code.
5227 ;; Dynamically bound to t when `c-guess-basic-syntax' is called during
5228 ;; auto newline analysis.
5232 ;; A simple function to prepend a new syntax element to
5233 ;; `c-syntactic-context'. Using `setq' on it is unsafe since it
5234 ;; should always be dynamically bound but since we read it first
5235 ;; we'll fail properly anyway if this function is misused.
5237 c-syntactic-context)))
5240 ;; Like `c-add-syntax' but appends to the end of the syntax list.
5241 ;; (Normally not necessary.)
5246 syntax-extra-args
5247 stop-at-boi-only
5248 at-block-start
5249 containing-sexp
5250 paren-state)
5251 ;; Do the generic processing to anchor the given syntax symbol on
5252 ;; the preceding statement: Skip over any labels and containing
5253 ;; statements on the same line, and then search backward until we
5254 ;; find a statement or block start that begins at boi without a
5255 ;; label or comment.
5256 ;;
5257 ;; Point is assumed to be at the prospective anchor point for the
5258 ;; given SYNTAX-SYMBOL. More syntax entries are added if we need to
5259 ;; skip past open parens and containing statements. All the added
5260 ;; syntax elements will get the same anchor point.
5261 ;;
5262 ;; SYNTAX-EXTRA-ARGS are a list of the extra arguments for the
5263 ;; syntax symbol. They are appended after the anchor point.
5264 ;;
5265 ;; If STOP-AT-BOI-ONLY is nil, we might stop in the middle of the
5266 ;; line if another statement precedes the current one on this line.
5267 ;;
5268 ;; If AT-BLOCK-START is non-nil, point is taken to be at the
5269 ;; beginning of a block or brace list, which then might be nested
5270 ;; inside an expression. If AT-BLOCK-START is nil, this is found
5271 ;; out by checking whether the character at point is "{" or not.
5273 ;; This is by far the most common case, so let's give it special
5274 ;; treatment.
5281 step-type step-tmp at-comment special-list)
5284 ;; Begin by skipping any labels and containing statements that
5285 ;; are on the same line.
5290 t
5292 nil)
5295 step-type step-tmp))
5298 ;; Loop if we have to back out of the containing block.
5302 ;; Loop if we have to back up another statement.
5306 ;; Always start by skipping over any comments that
5307 ;; stands between the statement and boi.
5320 ;; Current position might not be good enough;
5321 ;; skip backward another statement.
5323 containing-sexp))
5328 ;; If stop-at-boi-only is nil, we shouldn't
5329 ;; back up over previous or containing
5330 ;; statements to try to reach boi, so go
5331 ;; back to the last position and exit.
5334 nil)
5337 ;; If we've moved into another statement
5338 ;; then we should no longer try to stop
5339 ;; after boi.
5342 ;; Record this a substatement if we skipped up
5343 ;; one level, but not if we're still on the
5344 ;; same line. This so e.g. a sequence of "else
5345 ;; if" clauses won't indent deeper and deeper.
5354 nil)
5355 t)))))
5358 at-comment nil))
5367 ;; Don't stop in the middle of a special brace list opener
5368 ;; like "({".
5376 paren-state)
5393 ;; We're in an in-expression statement.
5394 ;; This syntactic element won't get an anchor pos.
5410 ;; If the open brace was at boi, we're always
5411 ;; done. The c-beginning-of-statement-1 call
5412 ;; above is necessary anyway, to decide the type
5413 ;; of block-intro to add.
5419 'defun-block-intro
5421 nil))
5424 ;; Loop if the brace wasn't at boi, and we didn't
5425 ;; arrive at a defun block.
5427 ;; Avoid backing up another sexp if the point
5428 ;; we're at now is found to be good enough in
5429 ;; the loop above.
5435 )))
5437 ;; Fill in the current point as the anchor for all the symbols
5438 ;; added above.
5445 )))
5448 ;; The inclass and class-close syntactic symbols are added in
5449 ;; several places and some work is needed to fix everything.
5450 ;; Therefore it's collected here.
5463 paren-state)
5464 containing-sexp)))
5467 anchor)))
5470 char-after-ip
5471 beg-of-same-or-containing-stmt
5472 containing-sexp
5473 paren-state)
5474 ;; This function contains the decision tree reached through both
5475 ;; cases 18 and 10. It's a continued statement or top level
5476 ;; construct of some kind.
5483 ;; (CASE A removed.)
5484 ;; CASE B: open braces for class or brace-lists
5491 ;; CASE B.1: class-open
5497 ))
5500 ;; CASE B.2: brace-list-open
5505 indent-point t t t)))
5506 ;; The most semantically accurate symbol here is
5507 ;; brace-list-open, but we normally report it simply as a
5508 ;; statement-cont. The reason is that one normally adjusts
5509 ;; brace-list-open for brace lists as top-level constructs,
5510 ;; and brace lists inside statements is a completely different
5511 ;; context. C.f. case 5A.3.
5514 ;; Turn off the dwim above when we're
5515 ;; analyzing the nature of the brace
5516 ;; for the auto newline feature.
5517 'brace-list-open
5519 nil nil nil
5520 containing-sexp paren-state))
5522 ;; CASE B.3: The body of a function declared inside a normal
5523 ;; block. Can occur e.g. in Pike and when using gcc
5524 ;; extensions, but watch out for macros followed by blocks.
5525 ;; C.f. cases E, 16F and 17G.
5530 ;; Look for a type followed by a symbol, i.e. the start of a
5531 ;; function declaration. Doesn't work for declarations like
5532 ;; "int *foo() ..."; we'd need to refactor the more competent
5533 ;; analysis in `c-font-lock-declarations' for that.
5539 containing-sexp paren-state))
5541 ;; CASE B.4: Continued statement with block open. The most
5542 ;; accurate analysis is perhaps `statement-cont' together with
5543 ;; `block-open' but we play DWIM and use `substatement-open'
5544 ;; instead. The rationaly is that this typically is a macro
5545 ;; followed by a block which makes it very similar to a
5546 ;; statement with a substatement block.
5549 containing-sexp paren-state))
5550 ))
5552 ;; CASE C: iostream insertion or extraction operator
5556 ;; If there is no preceding streamop in the statement
5557 ;; then indent this line as a normal statement-cont.
5561 t))))
5563 ;; CASE E: In the "K&R region" of a function declared inside a
5564 ;; normal block. C.f. case B.3.
5566 ;; Check that the next token is a '{'. This works as
5567 ;; long as no language that allows nested function
5568 ;; definitions allows stuff like member init lists, K&R
5569 ;; declarations or throws clauses there.
5570 ;;
5571 ;; Note that we do a forward search for something ahead
5572 ;; of the indentation line here. That's not good since
5573 ;; the user might not have typed it yet. Unfortunately
5574 ;; it's exceedingly tricky to recognize a function
5575 ;; prototype in a code block without resorting to this.
5582 ;; Look for a type followed by a symbol, i.e. the start of a
5583 ;; function declaration. Doesn't work for declarations like "int
5584 ;; *foo() ..."; we'd need to refactor the more competent analysis
5585 ;; in `c-font-lock-declarations' for that.
5591 containing-sexp paren-state))
5593 ;; CASE D: continued statement.
5597 containing-sexp paren-state))
5598 )))
5601 "Return the syntactic context of the current line.
5602 This function does not do any hidden buffer changes."
5610 literal containing-sexp char-before-ip char-after-ip lim
5611 c-syntactic-context placeholder c-in-literal-cache step-type
5612 tmpsymbol keyword injava-inher special-brace-list
5613 ;; narrow out any enclosing class or extern "C" block
5615 indent-point))
5616 ;; `c-state-cache' is shadowed here so that we don't
5617 ;; throw it away due to the narrowing that might be done
5618 ;; by the function above. That means we must not do any
5619 ;; changes during the execution of this function, since
5620 ;; `c-invalidate-state-cache' then would change this local
5621 ;; variable and leave a bogus value in the global one.
5624 paren-state))
5626 inenclosing-p macro-start in-macro-expr
5627 ;; There's always at most one syntactic element which got
5628 ;; a relpos. It's stored in syntactic-relpos.
5629 syntactic-relpos
5631 ;; Check for meta top-level enclosing constructs such as
5632 ;; extern language definitions.
5642 ;; Compatibility with legacy choice of name for the
5643 ;; extern-lang syntactic symbols.
5646 ;; Init some position variables:
5647 ;;
5648 ;; containing-sexp is the open paren of the closest
5649 ;; surrounding sexp or nil if there is none that hasn't been
5650 ;; narrowed out.
5651 ;;
5652 ;; lim is the position after the closest preceding brace sexp
5653 ;; (nested sexps are ignored), or the position after
5654 ;; containing-sexp if there is none, or (point-min) if
5655 ;; containing-sexp is nil.
5656 ;;
5657 ;; c-state-cache is the state from c-parse-state at
5658 ;; indent-point, without any parens outside the region
5659 ;; narrowed by c-narrow-out-enclosing-class.
5660 ;;
5661 ;; paren-state is the state from c-parse-state outside
5662 ;; containing-sexp, or at indent-point if containing-sexp is
5663 ;; nil. paren-state is not limited to the narrowed region, as
5664 ;; opposed to c-state-cache.
5673 ;; Ignore balanced paren. The next entry
5674 ;; can't be another one.
5677 ;; If there is no surrounding open paren then
5678 ;; put the last balanced pair back on paren-state.
5680 containing-sexp nil)))
5684 ;; If we're in a parenthesis list then ',' delimits the
5685 ;; "statements" rather than being an operator (with the
5686 ;; exception of the "for" clause). This difference is
5687 ;; typically only noticeable when statements are used in macro
5688 ;; arglists.
5693 ;; cache char before and after indent point, and move point to
5694 ;; the most likely position to perform the majority of tests
5702 ;; are we in a literal?
5705 ;; now figure out syntactic qualities of the current line
5707 ;; CASE 1: in a string.
5710 ;; CASE 2: in a C or C++ style comment.
5712 ;; This is a kludge for XEmacs where we use
5713 ;; `buffer-syntactic-context', which doesn't correctly
5714 ;; recognize "\*/" to end a block comment.
5715 ;; `parse-partial-sexp' which is used by
5716 ;; `c-literal-limits' will however do that in most
5717 ;; versions, which results in that we get nil from
5718 ;; `c-literal-limits' even when `c-in-literal' claims
5719 ;; we're inside a comment.
5722 ;; CASE 3: in a cpp preprocessor macro continuation.
5732 ;; If at the beginning of the body of a #define
5733 ;; directive then analyze as cpp-define-intro
5734 ;; only. Go on with the syntactic analysis
5735 ;; otherwise. in-macro-expr is set if we're in a
5736 ;; cpp expression, i.e. before the #define body
5737 ;; or anywhere in a non-#define directive.
5744 nil)))))
5747 ;; CASE 11: an else clause?
5751 containing-sexp paren-state))
5752 ;; CASE 12: while closure of a do/while construct?
5760 containing-sexp paren-state))
5761 ;; CASE 13: A catch or finally clause? This case is simpler
5762 ;; than if-else and do-while, because a block is required
5763 ;; after every try, catch and finally.
5771 t)
5775 t)
5778 t))
5783 containing-sexp paren-state))
5784 ;; CASE 18: A substatement we can recognize by keyword.
5795 ;; Ought to cache the result from the
5796 ;; c-beginning-of-statement-1 calls here.
5806 ;; Step up to the containing statement if we
5807 ;; stayed in the same one.
5815 ;; There was no containing statement afterall.
5817 placeholder))
5819 ;; Require a parenthesis after these keywords.
5820 ;; Necessary to catch e.g. synchronized in Java,
5821 ;; which can be used both as statement and
5822 ;; modifier.
5827 ;; CASE 18A: Simple substatement.
5833 containing-sexp paren-state))
5839 containing-sexp paren-state))
5842 containing-sexp paren-state))))
5843 ;; CASE 18B: Some other substatement. This is shared
5844 ;; with case 10.
5846 char-after-ip
5847 placeholder
5848 lim
5849 paren-state)))
5850 ;; CASE 4: In-expression statement. C.f. cases 7B, 16A and
5851 ;; 17E.
5853 c-opt-inexpr-block-key
5854 c-opt-lambda-key)
5857 containing-sexp)))
5862 ;; It's a statement block or an anonymous class.
5864 ;; It's a Pike lambda. Check whether we are between the
5865 ;; lambda keyword and the argument list or at the defun
5866 ;; opener.
5868 'inline-open
5877 ;; CASE 5: Line is at top level.
5880 ;; CASE 5A: we are looking at a defun, brace list, class,
5881 ;; or inline-inclass method opening brace
5887 ;; CASE 5A.1: Non-class declaration block open.
5896 ;; Special case for extern-lang-open. The
5897 ;; check for a following string is disabled
5898 ;; since it doesn't disambiguate anything.
5900 ;; (c-forward-sexp 1)
5901 ;; (c-forward-syntactic-ws)
5902 ;; (eq (char-after) ?\"))
5905 ))
5908 ;; CASE 5A.2: we are looking at a class opening brace
5915 ))
5917 ;; CASE 5A.3: brace list open
5942 ))))
5946 ;; We're in Java and have found that the open brace
5947 ;; belongs to a "new Foo[]" initialization list,
5948 ;; which means the brace list is part of an
5949 ;; expression and not a top level definition. We
5950 ;; therefore treat it as any topmost continuation
5951 ;; even though the semantically correct symbol still
5952 ;; is brace-list-open, on the same grounds as in
5953 ;; case B.2.
5958 ;; CASE 5A.4: inline defun open
5962 ;; CASE 5A.5: ordinary defun open
5967 ;; Bogus to use bol here, but it's the legacy.
5969 )))
5970 ;; CASE 5B: first K&R arg decl or member init
5973 ;; CASE 5B.1: a member init
5976 ;; this line should be indented relative to the beginning
5977 ;; of indentation for the topmost-intro line that contains
5978 ;; the prototype's open paren
5979 ;; TBD: is the following redundant?
5983 ;; TBD: is the preceding redundant?
5997 ;; we don't need to add any class offset since this
5998 ;; should be relative to the ctor's indentation
5999 )
6000 ;; CASE 5B.2: K&R arg decl intro
6007 ;; CASE 5B.3: Inside a member init list.
6011 ;; CASE 5B.4: Nether region after a C++ or Java func
6012 ;; decl, which could include a `throws' declaration.
6016 )))
6017 ;; CASE 5C: inheritance line. could be first inheritance
6018 ;; line, or continuation of a multiple inheritance
6026 ;; watch out for scope operator
6031 )))
6040 ;; for Java
6045 cont done)
6050 done t))
6054 )
6056 injava-inher)
6059 ))
6061 ;; CASE 5C.1: non-hanging colon on an inher intro
6065 ;; don't add inclass symbol since relative point already
6066 ;; contains any class offset
6067 )
6068 ;; CASE 5C.2: hanging colon on an inher intro
6074 ;; CASE 5C.3: in a Java implements/extends
6088 )))
6089 ;; CASE 5C.4: a continued inheritance line
6093 ;; don't add inclass symbol since relative point already
6094 ;; contains any class offset
6095 )))
6096 ;; CASE 5D: this could be a top-level initialization, a
6097 ;; member init list continuation, or a template argument
6098 ;; list continuation.
6100 c++-template-syntax-table
6103 ;; Note: We use the fact that lim is always after any
6104 ;; preceding brace sexp.
6115 ;; CASE 5D.1: hanging member init colon, but watch out
6116 ;; for bogus matches on access specifiers inside classes.
6136 )))
6140 ;; we do not need to add class offset since relative
6141 ;; point is the member init above us
6142 )
6143 ;; CASE 5D.2: non-hanging member init colon
6149 ;; CASE 5D.3: perhaps a template list continuation?
6158 ;; we can probably indent it just like an arglist-cont
6162 ;; CASE 5D.4: perhaps a multiple inheritance line?
6174 t)
6178 ;; CASE 5D.5: Continuation of the "expression part" of a
6179 ;; top level construct.
6188 ;; A preceding comma at the top level means that a
6189 ;; new variable declaration starts here. Use
6190 ;; topmost-intro-cont for it, for consistency with
6191 ;; the first variable declaration. C.f. case 5N.
6192 'topmost-intro-cont
6194 nil nil nil containing-sexp paren-state))
6195 ))
6196 ;; CASE 5E: we are looking at a access specifier
6198 c-opt-access-key
6201 paren-state))
6202 ;; Append access-label with the same anchor point as inclass gets.
6204 ;; CASE 5F: Close of a non-class declaration level block.
6209 ;; CASE 5G: we are looking at the brace which closes the
6210 ;; enclosing nested class decl
6219 ))))
6221 ;; CASE 5H: we could be looking at subsequent knr-argdecls
6227 ;; Do an extra check to avoid tripping up on
6228 ;; statements that occur in invalid contexts
6229 ;; (e.g. in macro bodies where we don't really
6230 ;; know the context of what we're looking at).
6236 ;; CASE 5I: ObjC method definition.
6241 ;; CASE 5P: AWK pattern or function or continuation
6242 ;; thereof.
6248 'topmost-intro-cont
6250 nil nil nil
6251 containing-sexp paren-state))
6252 ;; CASE 5N: At a variable declaration that follows a class
6253 ;; definition or some other block declaration that doesn't
6254 ;; end at the closing '}'. C.f. case 5D.5.
6261 ;; Speed up the backward search a bit.
6266 ;; The '}' is unbalanced.
6267 nil
6272 containing-sexp paren-state))
6273 ;; CASE 5J: we are at the topmost level, make
6274 ;; sure we skip back past any access specifiers
6277 c-opt-access-key
6292 ;; real beginning-of-line could be narrowed out due to
6293 ;; enclosure in a class block
6297 ;; Using bol instead of boi above is highly bogus, and
6298 ;; it makes our lives hard to remain compatible. :P
6308 ))
6310 macro-start
6314 ))
6315 ;; CASE 5K: we are at an ObjC method definition
6316 ;; continuation line.
6323 ;; CASE 5L: we are at the first argument of a template
6324 ;; arglist that begins on the previous line.
6328 ;; CASE 5M: we are at a topmost continuation line
6332 ))
6333 ;; (CASE 6 has been removed.)
6334 ;; CASE 7: line is an expression, not a statement. Most
6335 ;; likely we are either in a function prototype or a function
6336 ;; call argument list
6343 ;; CASE 7A: we are looking at the arglist closing paren.
6344 ;; C.f. case 7F.
6357 ;; CASE 7B: Looking at the opening brace of an
6358 ;; in-expression block or brace list. C.f. cases 4, 16A
6359 ;; and 17E.
6363 c-state-cache))
6367 placeholder
6370 paren-state)
6371 containing-sexp)))
6372 ;; placeholder is nil if it's a block directly in
6373 ;; a function arglist. That makes us skip out of
6374 ;; this case.
6375 )))
6383 ;; CASE 7C: we are looking at the first argument in an empty
6384 ;; argument list. Use arglist-close if we're actually
6385 ;; looking at a close paren or bracket.
6395 ;; CASE 7D: we are inside a conditional test clause. treat
6396 ;; these things as statements
6406 ))
6407 ;; CASE 7E: maybe a continued ObjC method call. This is the
6408 ;; case when we are inside a [] bracketed exp, and what
6409 ;; precede the opening bracket is not an identifier.
6417 )))
6418 ;; CASE 7F: we are looking at an arglist continuation line,
6419 ;; but the preceding argument is on the same line as the
6420 ;; opening paren. This case includes multi-line
6421 ;; mathematical paren groupings, but we could be on a
6422 ;; for-list continuation line. C.f. case 7A.
6437 t nil
6440 ;; CASE 7G: we are looking at just a normal arglist
6441 ;; continuation line
6444 ))
6445 ;; CASE 8: func-local multi-inheritance line
6454 ;; CASE 8A: non-hanging colon on an inher intro
6458 ;; CASE 8B: hanging colon on an inher intro
6461 ;; CASE 8C: a continued inheritance line
6465 )))
6466 ;; CASE 9: we are inside a brace-list
6475 ;; CASE 9A: In the middle of a special brace list opener.
6494 ;; CASE 9B: brace-list-close brace
6496 ;; Check special brace list closer.
6503 ;; We were between the special close char and the `)'.
6506 ;; We were before the special close char.
6510 ;; Normal brace list check.
6521 ;; Prepare for the rest of the cases below by going to the
6522 ;; token following the opening brace
6534 ;; CASE 9C: we're looking at the first line in a brace-list
6545 ;; CASE 9D: this is just a later brace-list-entry or
6546 ;; brace-entry-open
6555 ))
6556 ))))
6557 ;; CASE 10: A continued statement or top level construct.
6568 ;; This is shared with case 18.
6570 char-after-ip
6571 placeholder
6572 containing-sexp
6573 paren-state))
6574 ;; CASE 14: A case or default label
6580 lim paren-state))
6581 ;; CASE 15: any other label
6589 ;; If the surrounding statement is a switch then
6590 ;; let's analyze all labels as switch labels, so
6591 ;; that they get lined up consistently.
6592 'case-label
6596 lim paren-state))
6597 ;; CASE 16: block close brace, possibly closing the defun or
6598 ;; the class
6600 ;; From here on we have the next containing sexp in lim.
6604 ;; CASE 16E: Closing a statement block? This catches
6605 ;; cases where it's preceded by a statement keyword,
6606 ;; which works even when used in an "invalid" context,
6607 ;; e.g. a macro argument.
6611 lim paren-state))
6612 ;; CASE 16A: closing a lambda defun or an in-expression
6613 ;; block? C.f. cases 4, 7B and 17E.
6616 nil))
6618 'inline-close
6631 ;; CASE 16B: does this close an inline or a function in
6632 ;; a non-class declaration level block?
6641 ;; CASE 16F: Can be a defun-close of a function declared
6642 ;; in a statement block, e.g. in Pike or when using gcc
6643 ;; extensions, but watch out for macros followed by
6644 ;; blocks. Let it through to be handled below.
6645 ;; C.f. cases B.3 and 17G.
6647 lim
6652 ;; Look for a type or identifier followed by a
6653 ;; symbol, i.e. the start of a function declaration.
6654 ;; Doesn't work for declarations like "int *foo()
6655 ;; ..."; we'd need to refactor the more competent
6656 ;; analysis in `c-font-lock-declarations' for that.
6665 lim paren-state))
6666 ;; CASE 16C: if there an enclosing brace that hasn't
6667 ;; been narrowed out by a class, then this is a
6668 ;; block-close. C.f. case 17H.
6670 ;; If the block is preceded by a case/switch label on
6671 ;; the same line, we anchor at the first preceding label
6672 ;; at boi. The default handling in c-add-stmt-syntax is
6673 ;; really fixes it better, but we do like this to keep
6674 ;; the indentation compatible with version 5.28 and
6675 ;; earlier.
6682 ;; c-backward-to-block-anchor not necessary here; those
6683 ;; situations are handled in case 16E above.
6685 lim paren-state)))
6686 ;; CASE 16D: find out whether we're closing a top-level
6687 ;; class or a defun
6698 )))
6699 ;; CASE 17: Statement or defun catchall.
6702 ;; Back up statements until we find one that starts at boi.
6705 containing-sexp)))
6709 nil)
6713 ;; CASE 17B: continued statement
6717 containing-sexp paren-state))
6718 ;; CASE 17A: After a case/default label?
6726 'statement-case-open
6728 nil t nil containing-sexp paren-state))
6729 ;; CASE 17D: any old statement
6736 containing-sexp paren-state)
6739 ;; CASE 17I: Inside a substatement block.
6741 ;; The following tests are all based on containing-sexp.
6743 ;; From here on we have the next containing sexp in lim.
6748 lim paren-state)
6751 ;; CASE 17E: first statement in an in-expression block.
6752 ;; C.f. cases 4, 7B and 16A.
6755 nil))
6757 'defun-block-intro
6771 ;; CASE 17F: first statement in an inline, or first
6772 ;; statement in a top-level defun. we can tell this is it
6773 ;; if there are no enclosing braces that haven't been
6774 ;; narrowed out by a class (i.e. don't use bod here).
6783 ;; CASE 17G: First statement in a function declared inside
6784 ;; a normal block. This can occur in Pike and with
6785 ;; e.g. the gcc extensions, but watch out for macros
6786 ;; followed by blocks. C.f. cases B.3 and 16F.
6791 ;; Look for a type or identifier followed by a
6792 ;; symbol, i.e. the start of a function declaration.
6793 ;; Doesn't work for declarations like "int *foo()
6794 ;; ..."; we'd need to refactor the more competent
6795 ;; analysis in `c-font-lock-declarations' for that.
6804 lim paren-state))
6805 ;; CASE 17H: First statement in a block. C.f. case 16C.
6807 ;; If the block is preceded by a case/switch label on the
6808 ;; same line, we anchor at the first preceding label at
6809 ;; boi. The default handling in c-add-stmt-syntax is
6810 ;; really fixes it better, but we do like this to keep the
6811 ;; indentation compatible with version 5.28 and earlier.
6818 ;; c-backward-to-block-anchor not necessary here; those
6819 ;; situations are handled in case 17I above.
6821 lim paren-state))
6824 ))
6825 )
6826 ;; now we need to look at any modifiers
6829 ;; are we looking at a comment only line?
6833 ;; we might want to give additional offset to friends (in C++).
6838 ;; Set syntactic-relpos.
6844 nil)
6845 t))
6848 ;; Start of or a continuation of a preprocessor directive?
6863 ;; If inside a cpp expression, i.e. anywhere in a
6864 ;; cpp directive except a #define body, we only let
6865 ;; through the syntactic analysis that is internal
6866 ;; in the expression. That means the arglist
6867 ;; elements, if they are anchored inside the cpp
6868 ;; expression.
6877 ;; Inside a #define body and the syntactic analysis is
6878 ;; anchored on the start of the #define. In this case
6879 ;; we add cpp-define-intro to get the extra
6880 ;; indentation of the #define body.
6882 ;; return the syntax
6883 c-syntactic-context))))
6885 \f
6886 ;; Indentation calculation.
6889 ;; offset can be a number, a function, a variable, a list, or one of
6890 ;; the symbols + or -
6903 langelem symbol))
6917 done))
6919 ))
6922 ;; Get offset from LANGELEM which is a list beginning with the
6923 ;; syntactic symbol and followed by any analysis data it provides.
6924 ;; That data may be zero or more elements, but if at least one is
6925 ;; given then the first is the relpos (or nil). The symbol is
6926 ;; matched against `c-offsets-alist' and the offset calculated from
6927 ;; that is returned.
6937 offset
6941 ))
6944 ;; This is a compatibility wrapper for `c-calc-offset' in case
6945 ;; someone is calling it directly. It takes an old style syntactic
6946 ;; element on the form (SYMBOL . RELPOS) and converts it to the new
6947 ;; list form.
6953 ;; Calculate the syntactic indentation from a syntactic description
6954 ;; as returned by `c-guess-syntax'.
6955 ;;
6956 ;; Note that topmost-intro always has a relpos at bol, for
6957 ;; historical reasons. It's often used together with other symbols
6958 ;; that has more sane positions. Since we always use the first
6959 ;; found relpos, we rely on that these other symbols always precede
6960 ;; topmost-intro in the LANGELEMS list.
6968 ;; Got an absolute column that overrides any indentation
6969 ;; we've collected so far, but not the relative
6970 ;; indentation we might get for the nested structures
6971 ;; further down the langelems list.
6975 ;; Got a relative change of the current calculated
6976 ;; indentation.
6979 ;; Use the anchor position from the first syntactic
6980 ;; element with one.
6992 indent)))
6994 \f
6997 ;;; arch-tag: 149add18-4673-4da5-ac47-6805e4eae089
6998 ;;; cc-engine.el ends here