| blob | e9ed474e792807657c6ef06adaa87fabc9028c8a |
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 this program; see the file COPYING. If not, write to
28 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 ;; Boston, MA 02110-1301, 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.
339 font-lock-comment-delimiter-face))
342 ;; This function does not do any hidden buffer changes.
345 tmp-char-inserted)
347 nil
363 ;; If initial point was within line's indentation and we're not on
364 ;; a line with a line continuation in a macro, position after the
365 ;; indentation. Else stay at same point in text.
372 \f
373 ;; Some debug tools to visualize various special positions. This
374 ;; debug code isn't as portable as the rest of CC Mode.
410 \f
411 ;; `c-beginning-of-statement-1' and accompanying stuff.
413 ;; KLUDGE ALERT: c-maybe-labelp is used to pass information between
414 ;; c-crosses-statement-barrier-p and c-beginning-of-statement-1. A
415 ;; better way should be implemented, but this will at least shut up
416 ;; the byte compiler.
419 ;; New awk-compatible version of c-beginning-of-statement-1, ACM 2002/6/22
421 ;; Macros used internally in c-beginning-of-statement-1 for the
422 ;; automaton actions.
425 stack)))
430 t
431 ,do-if-done
436 ;; Throw nil if stack is empty, else throw non-nil.
460 noerror comma-delim)
461 "Move to the start of the current statement or declaration, or to
462 the previous one if already at the beginning of one. Only
463 statements/declarations on the same level are considered, i.e. don't
464 move into or out of sexps (not even normal expression parentheses).
468 is within the continuation. If starting at such a token, move to the
469 corresponding statement start. If at the beginning of a statement,
470 move to the closest containing statement if there is any. This might
471 also stop at a continuation clause.
473 Labels are treated as separate statements if IGNORE-LABELS is non-nil.
474 The function is not overly intelligent in telling labels from other
475 uses of colons; if used outside a statement context it might trip up
476 on e.g. inherit colons, so IGNORE-LABELS should be used then. There
477 should be no such mistakes in a statement context, however.
479 Macros are ignored unless point is within one, in which case the
480 content of the macro is treated as normal code. Aside from any normal
481 statement starts found in it, stop at the first token of the content
484 leaving them.
486 Return 'label if stopped at a label, 'same if stopped at the beginning
487 of the current statement, 'up if stepped to a containing statement,
488 'previous if stepped to a preceding statement, 'beginning if stepped
489 from a statement continuation clause to its start clause, or 'macro if
490 stepped to a macro start. Note that 'same and not 'label is returned
491 if stopped at the same label without crossing the colon character.
493 LIM may be given to limit the search. If the search hits the limit,
494 point will be left at the closest following token, or at the start
495 position if that is less ('same is returned in this case).
497 NOERROR turns off error logging to `c-parsing-error'.
499 Normally only ';' is considered to delimit statements, but if
500 COMMA-DELIM is non-nil then ',' is treated likewise."
502 ;; The bulk of this function is a pushdown automaton that looks at statement
503 ;; boundaries and the tokens (such as "while") in c-opt-block-stmt-key. Its
504 ;; purpose is to keep track of nested statements, ensuring that such
505 ;; statments are skipped over in their entirety (somewhat akin to what C-M-p
506 ;; does with nested braces/brackets/parentheses).
507 ;;
508 ;; Note: The position of a boundary is the following token.
509 ;;
510 ;; Beginning with the current token (the one following point), move back one
511 ;; sexp at a time (where a sexp is, more or less, either a token or the
512 ;; entire contents of a brace/bracket/paren pair). Each time a statement
513 ;; boundary is crossed or a "while"-like token is found, update the state of
514 ;; the PDA. Stop at the beginning of a statement when the stack (holding
515 ;; nested statement info) is empty and the position has been moved.
516 ;;
517 ;; The following variables constitute the PDA:
518 ;;
519 ;; sym: This is either the "while"-like token (e.g. 'for) we've just
520 ;; scanned back over, 'boundary if we've just gone back over a
521 ;; statement boundary, or nil otherwise.
522 ;; state: takes one of the values (nil else else-boundary while
523 ;; while-boundary catch catch-boundary).
524 ;; nil means "no "while"-like token yet scanned".
525 ;; 'else, for example, means "just gone back over an else".
526 ;; 'else-boundary means "just gone back over a statement boundary
527 ;; immediately after having gone back over an else".
528 ;; saved-pos: A vector of either saved positions (tok ptok pptok, etc.) or
529 ;; of error reporting information.
530 ;; stack: The stack onto which the PDA pushes its state. Each entry
531 ;; consists of a saved value of state and saved-pos. An entry is
532 ;; pushed when we move back over a "continuation" token (e.g. else)
533 ;; and popped when we encounter the corresponding opening token
534 ;; (e.g. if).
535 ;;
536 ;;
537 ;; The following diagram briefly outlines the PDA.
538 ;;
539 ;; Common state:
540 ;; "else": Push state, goto state `else'.
541 ;; "while": Push state, goto state `while'.
542 ;; "catch" or "finally": Push state, goto state `catch'.
543 ;; boundary: Pop state.
544 ;; other: Do nothing special.
545 ;;
546 ;; State `else':
547 ;; boundary: Goto state `else-boundary'.
548 ;; other: Error, pop state, retry token.
549 ;;
550 ;; State `else-boundary':
551 ;; "if": Pop state.
552 ;; boundary: Error, pop state.
553 ;; other: See common state.
554 ;;
555 ;; State `while':
556 ;; boundary: Save position, goto state `while-boundary'.
557 ;; other: Pop state, retry token.
558 ;;
559 ;; State `while-boundary':
560 ;; "do": Pop state.
561 ;; boundary: Restore position if it's not at start, pop state. [*see below]
562 ;; other: See common state.
563 ;;
564 ;; State `catch':
565 ;; boundary: Goto state `catch-boundary'.
566 ;; other: Error, pop state, retry token.
567 ;;
568 ;; State `catch-boundary':
569 ;; "try": Pop state.
570 ;; "catch": Goto state `catch'.
571 ;; boundary: Error, pop state.
572 ;; other: See common state.
573 ;;
574 ;; [*] In the `while-boundary' state, we had pushed a 'while state, and were
575 ;; searching for a "do" which would have opened a do-while. If we didn't
576 ;; find it, we discard the analysis done since the "while", go back to this
577 ;; token in the buffer and restart the scanning there, this time WITHOUT
578 ;; pushing the 'while state onto the stack.
579 ;;
580 ;; In addition to the above there is some special handling of labels
581 ;; and macros.
585 macro-start
588 c-stmt-delim-chars-with-comma
589 c-stmt-delim-chars))
590 pos ; Current position.
591 boundary-pos ; Position of last stmt boundary character (e.g. ;).
592 after-labels-pos ; Value of tok after first found colon.
593 last-label-pos ; Value of tok after last found colon.
594 sym ; Symbol just scanned back over (e.g. 'while or
595 ; 'boundary). See above
596 state ; Current state in the automaton. See above.
597 saved-pos ; Current saved positions. See above
598 stack ; Stack of conses (state . saved-pos).
602 tok ptok pptok ; Pos of last three sexps or bounds.
603 c-in-literal-cache c-maybe-labelp saved)
613 ;; Try to skip back over unary operator characters, to register
614 ;; that we've moved.
621 ; Make a variable in
622 ; cc-langs.el, maybe
624 ;; Skip back over any semicolon here. If it was a bare semicolon, we're
625 ;; done. Later on we ignore the boundaries for statements that doesn't
626 ;; contain any sexp. The only thing that is affected is that the error
627 ;; checking is a little less strict, and we really don't bother.
639 ;; ACM, 2002/7/20: What about giving a limit to the above function?
640 ;; ACM, 2003/6/16: The above two lines (checking for
641 ;; awk-logical-semicolon) are probably redundant after rewriting
642 ;; c-awk-backward-syntactic-ws.
644 pos saved)
646 ;; Begin at start and not pos to detect macros if we stand
647 ;; directly after the #.
650 ;; Record this as the first token if not starting inside it.
653 ;; The following while loop goes back one sexp (balanced parens,
654 ;; etc. with contents, or symbol or suchlike) each iteration. This
655 ;; movement is accomplished with a call to scan-sexps approx 130 lines
656 ;; below.
660 ;; Check for macro start. Take this out for AWK Mode (ACM, 2002/5/31)
661 ;; NO!! just make sure macro-start is nil in AWK Mode (ACM, 2002/6/22)
662 ;; It always is (ACM, 2002/6/23)
677 ;; Stop at the first token in the content of the macro.
681 ret 'macro
682 ignore-labels t))
685 ;; Do a round through the automaton if we've just passed a
686 ;; statement boundary or passed a "while"-like token.
694 ;; The PDA state handling.
695 ;;
696 ;; Refer to the description of the PDA in the opening
697 ;; comments. In the following OR form, the first leaf
698 ;; attempts to handles one of the specific actions detailed
699 ;; (e.g., finding token "if" whilst in state `else-boundary').
700 ;; We drop through to the second leaf (which handles common
701 ;; state) if no specific handler is found in the first cond.
702 ;; If a parsing error is detected (e.g. an "else" with no
703 ;; preceding "if"), we throw to the enclosing catch.
704 ;;
705 ;; Note that the (eq state 'else) means
706 ;; "we've just passed an else", NOT "we're looking for an
707 ;; else".
724 ;; Since this can cause backtracking we do a
725 ;; little more careful analysis to avoid it:
726 ;; If there's a label in front of the while
727 ;; it can't be part of a do-while.
756 ;; This is state common. We get here when the previous
757 ;; cond statement found no particular state handler.
759 ;; If we have a boundary at the start
760 ;; position we push a frame to go to the
761 ;; previous statement.
774 ;; might we be calling this from
775 ;; c-awk-after-if-do-for-while-condition-p?
776 ;; If so, avoid infinite recursion.
779 ;; The following may recursively
780 ;; call this function.
782 ;; Since this can cause backtracking we do a
783 ;; little more careful analysis to avoid it: If
784 ;; the while isn't followed by a semicolon it
785 ;; can't be a do-while.
786 ;; ACM, 2002/5/31; IT CAN IN AWK Mode. ;-(
795 ;; We're either past a statement boundary or at the
796 ;; start of a statement, so throw away any label data
797 ;; for the previous one.
799 last-label-pos nil
800 c-maybe-labelp nil))))
802 ;; Step to the previous sexp, but not if we crossed a
803 ;; boundary, since that doesn't consume an sexp.
807 ;; HERE IS THE SINGLE PLACE INSIDE THE PDA LOOP WHERE WE MOVE
808 ;; BACKWARDS THROUGH THE SOURCE. The following loop goes back
809 ;; one sexp and then only loops in special circumstances (line
810 ;; continuations and skipping past entire macros).
814 ;; Give up if we hit an unbalanced block.
815 ;; Since the stack won't be empty the code
816 ;; below will report a suitable error.
819 ;; Step again if we hit a line continuation.
820 t)
822 ;; If we started inside a macro then this
823 ;; sexp is always interesting.
824 nil)
826 ;; Otherwise check that we didn't step
827 ;; into a macro from the end.
834 t))))))
836 ;; Did the last movement by a sexp cross a statement boundary?
842 ;; Should not include the paren sexp we've
843 ;; passed over in the boundary check.
847 ;; Find its end position this way instead of
848 ;; moving forward if the sexp is large.
854 ;; Check that we didn't step into
855 ;; a macro from the end.
862 t)))))))
868 ptok tok
869 tok boundary-pos
876 ;; c-crosses-statement-barrier-p has found a colon, so
877 ;; we might be in a label now.
881 c-maybe-labelp t))
883 ;; ObjC method def?
890 ;; We've moved back by a sexp, so update the token positions.
892 pptok ptok
893 ptok tok
897 ;; If the stack isn't empty there might be errors to report.
906 ;; Need to investigate closer whether we've crossed
907 ;; between a substatement and its containing statement.
909 ptok
910 pptok))
917 after-labels-pos)
918 ;; We're in a label. Maybe we should step to the statement
919 ;; after it.
926 ;; Skip over the unary operators that can start the statement.
935 ret)))
938 "Return non-nil if buffer positions FROM to TO cross one or more
939 statement or declaration boundaries. The returned value is actually
940 the position of the earliest boundary char. FROM must not be within
941 a string or comment.
943 The variable `c-maybe-labelp' is set to the position of the first `:' that
944 might start a label (i.e. not part of `::' and not preceded by `?'). If a
945 single `?' is found, then `c-maybe-labelp' is cleared."
947 lit-range)
961 ;; Ignore scope operators.
965 ;; A question mark. Can't be a label, so stop
966 ;; looking for more : and ?.
976 nil))))
978 \f
979 ;; A set of functions that covers various idiosyncrasies in
980 ;; implementations of `forward-comment'.
982 ;; Note: Some emacsen considers incorrectly that any line comment
983 ;; ending with a backslash continues to the next line. I can't think
984 ;; of any way to work around that in a reliable way without changing
985 ;; the buffer, though. Suggestions welcome. ;) (No, temporarily
986 ;; changing the syntax for backslash doesn't work since we must treat
987 ;; escapes in string literals correctly.)
990 "Move forward past whitespace and the closest following comment, if any.
991 Return t if a comment was found, nil otherwise. In either case, the
992 point is moved past the following whitespace. Line continuations,
993 i.e. a backslashes followed by line breaks, are treated as whitespace.
994 The line breaks that end line comments are considered to be the
995 comment enders, so the point will be put on the beginning of the next
996 line if it moved past a line comment.
998 This function does not do any hidden buffer changes."
1006 ;; Some emacsen (e.g. XEmacs 21) return t when moving
1007 ;; forwards at eob.
1008 nil
1010 ;; Emacs includes the ending newline in a b-style (c++)
1011 ;; comment, but XEmacs doesn't. We depend on the Emacs
1012 ;; behavior (which also is symmetric).
1016 t))))
1019 "Move forward past all following whitespace and comments.
1020 Line continuations, i.e. a backslashes followed by line breaks, are
1021 treated as whitespace.
1023 This function does not do any hidden buffer changes."
1026 ;; If forward-comment in at least XEmacs 21 is given a large
1027 ;; positive value, it'll loop all the way through if it hits
1028 ;; eob.
1030 ;; Some emacsen (e.g. XEmacs 21) return t when moving
1031 ;; forwards at eob.
1036 t))))
1039 "Move backward past whitespace and the closest preceding comment, if any.
1040 Return t if a comment was found, nil otherwise. In either case, the
1041 point is moved past the preceding whitespace. Line continuations,
1042 i.e. a backslashes followed by line breaks, are treated as whitespace.
1043 The line breaks that end line comments are considered to be the
1044 comment enders, so the point cannot be at the end of the same line to
1045 move over a line comment.
1047 This function does not do any hidden buffer changes."
1050 ;; When we got newline terminated comments, forward-comment in all
1051 ;; supported emacsen so far will stop at eol of each line not
1052 ;; ending with a comment when moving backwards. This corrects for
1053 ;; that, and at the same time handles line continuations.
1062 ;; Some emacsen (e.g. Emacs 19.34) return t when moving
1063 ;; backwards at bob.
1064 nil
1066 ;; Leave point after the closest following newline if we've
1067 ;; backed up over any above, since forward-comment won't move
1068 ;; backward over a line comment if point is at the end of the
1069 ;; same line.
1074 ;; If forward-comment above succeeded and we're at eol
1075 ;; then the newline we moved over above didn't end a
1076 ;; line comment, so we give it another go.
1078 t))
1080 ;; Emacs <= 20 and XEmacs move back over the closer of a
1081 ;; block comment that lacks an opener.
1084 t)))))
1087 "Move backward past all preceding whitespace and comments.
1088 Line continuations, i.e. a backslashes followed by line breaks, are
1089 treated as whitespace. The line breaks that end line comments are
1090 considered to be the comment enders, so the point cannot be at the end
1091 of the same line to move over a line comment.
1093 This function does not do any hidden buffer changes."
1097 ;; `forward-comment' in some emacsen (e.g. Emacs 19.34)
1098 ;; return t when moving backwards at bob.
1103 ;; Emacs <= 20 and XEmacs move back over the
1104 ;; closer of a block comment that lacks an opener.
1106 t)
1108 ;; XEmacs treats line continuations as whitespace but
1109 ;; only in the backward direction, which seems a bit
1110 ;; odd. Anyway, this is necessary for Emacs.
1115 t))))))
1117 \f
1118 ;; Tools for skipping over syntactic whitespace.
1120 ;; The following functions use text properties to cache searches over
1121 ;; large regions of syntactic whitespace. It works as follows:
1122 ;;
1123 ;; o If a syntactic whitespace region contains anything but simple
1124 ;; whitespace (i.e. space, tab and line breaks), the text property
1125 ;; `c-in-sws' is put over it. At places where we have stopped
1126 ;; within that region there's also a `c-is-sws' text property.
1127 ;; That since there typically are nested whitespace inside that
1128 ;; must be handled separately, e.g. whitespace inside a comment or
1129 ;; cpp directive. Thus, from one point with `c-is-sws' it's safe
1130 ;; to jump to another point with that property within the same
1131 ;; `c-in-sws' region. It can be likened to a ladder where
1132 ;; `c-in-sws' marks the bars and `c-is-sws' the rungs.
1133 ;;
1134 ;; o The `c-is-sws' property is put on the simple whitespace chars at
1135 ;; a "rung position" and also maybe on the first following char.
1136 ;; As many characters as can be conveniently found in this range
1137 ;; are marked, but no assumption can be made that the whole range
1138 ;; is marked (it could be clobbered by later changes, for
1139 ;; instance).
1140 ;;
1141 ;; Note that some part of the beginning of a sequence of simple
1142 ;; whitespace might be part of the end of a preceding line comment
1143 ;; or cpp directive and must not be considered part of the "rung".
1144 ;; Such whitespace is some amount of horizontal whitespace followed
1145 ;; by a newline. In the case of cpp directives it could also be
1146 ;; two newlines with horizontal whitespace between them.
1147 ;;
1148 ;; The reason to include the first following char is to cope with
1149 ;; "rung positions" that doesn't have any ordinary whitespace. If
1150 ;; `c-is-sws' is put on a token character it does not have
1151 ;; `c-in-sws' set simultaneously. That's the only case when that
1152 ;; can occur, and the reason for not extending the `c-in-sws'
1153 ;; region to cover it is that the `c-in-sws' region could then be
1154 ;; accidentally merged with a following one if the token is only
1155 ;; one character long.
1156 ;;
1157 ;; o On buffer changes the `c-in-sws' and `c-is-sws' properties are
1158 ;; removed in the changed region. If the change was inside
1159 ;; syntactic whitespace that means that the "ladder" is broken, but
1160 ;; a later call to `c-forward-sws' or `c-backward-sws' will use the
1161 ;; parts on either side and use an ordinary search only to "repair"
1162 ;; the gap.
1163 ;;
1164 ;; Special care needs to be taken if a region is removed: If there
1165 ;; are `c-in-sws' on both sides of it which do not connect inside
1166 ;; the region then they can't be joined. If e.g. a marked macro is
1167 ;; broken, syntactic whitespace inside the new text might be
1168 ;; marked. If those marks would become connected with the old
1169 ;; `c-in-sws' range around the macro then we could get a ladder
1170 ;; with one end outside the macro and the other at some whitespace
1171 ;; within it.
1172 ;;
1173 ;; The main motivation for this system is to increase the speed in
1174 ;; skipping over the large whitespace regions that can occur at the
1175 ;; top level in e.g. header files that contain a lot of comments and
1176 ;; cpp directives. For small comments inside code it's probably
1177 ;; slower than using `forward-comment' straightforwardly, but speed is
1178 ;; not a significant factor there anyway.
1180 ; (defface c-debug-is-sws-face
1181 ; '((t (:background "GreenYellow")))
1182 ; "Debug face to mark the `c-is-sws' property.")
1183 ; (defface c-debug-in-sws-face
1184 ; '((t (:underline t)))
1185 ; "Debug face to mark the `c-in-sws' property.")
1187 ; (defun c-debug-put-sws-faces ()
1188 ; ;; Put the sws debug faces on all the `c-is-sws' and `c-in-sws'
1189 ; ;; properties in the buffer.
1190 ; (interactive)
1191 ; (save-excursion
1192 ; (let (in-face)
1193 ; (goto-char (point-min))
1194 ; (setq in-face (if (get-text-property (point) 'c-is-sws)
1195 ; (point)))
1196 ; (while (progn
1197 ; (goto-char (next-single-property-change
1198 ; (point) 'c-is-sws nil (point-max)))
1199 ; (if in-face
1200 ; (progn
1201 ; (c-debug-add-face in-face (point) 'c-debug-is-sws-face)
1202 ; (setq in-face nil))
1203 ; (setq in-face (point)))
1204 ; (not (eobp))))
1205 ; (goto-char (point-min))
1206 ; (setq in-face (if (get-text-property (point) 'c-in-sws)
1207 ; (point)))
1208 ; (while (progn
1209 ; (goto-char (next-single-property-change
1210 ; (point) 'c-in-sws nil (point-max)))
1211 ; (if in-face
1212 ; (progn
1213 ; (c-debug-add-face in-face (point) 'c-debug-in-sws-face)
1214 ; (setq in-face nil))
1215 ; (setq in-face (point)))
1216 ; (not (eobp)))))))
1219 ;;`(message ,@args)
1220 )
1254 ;; Called from `after-change-functions'. Note that if
1255 ;; `c-forward-sws' or `c-backward-sws' are used outside
1256 ;; `c-save-buffer-state' or similar then this will remove the cache
1257 ;; properties right after they're added.
1260 ;; Adjust the end to remove the properties in any following simple
1261 ;; ws up to and including the next line break, if there is any
1262 ;; after the changed region. This is necessary e.g. when a rung
1263 ;; marked empty line is converted to a line comment by inserting
1264 ;; "//" before the line break. In that case the line break would
1265 ;; keep the rung mark which could make a later `c-backward-sws'
1266 ;; move into the line comment instead of over it.
1276 ;; Ensure that an `c-in-sws' range gets broken. Note that it isn't
1277 ;; safe to keep a range that was continuous before the change. E.g:
1278 ;;
1279 ;; #define foo
1280 ;; \
1281 ;; bar
1282 ;;
1283 ;; There can be a "ladder" between "#" and "b". Now, if the newline
1284 ;; after "foo" is removed then "bar" will become part of the cpp
1285 ;; directive instead of a syntactically relevant token. In that
1286 ;; case there's no longer syntactic ws from "#" to "b".
1293 ;; Used by `c-forward-syntactic-ws' to implement the unbounded search.
1296 ;; unmarked part of the simple ws region.
1298 rung-is-marked next-rung-is-marked simple-ws-end
1299 ;; `safe-start' is set when it's safe to cache the start position.
1300 ;; It's not set if we've initially skipped over comments and line
1301 ;; continuations since we might have gone out through the end of a
1302 ;; macro then. This provision makes `c-forward-sws' not populate the
1303 ;; cache in the majority of cases, but otoh is `c-backward-sws' by far
1304 ;; more common.
1305 safe-start)
1307 ;; Skip simple ws and do a quick check on the following character to see
1308 ;; if it's anything that can't start syntactic ws, so we can bail out
1309 ;; early in the majority of cases when there just are a few ws chars.
1316 ;; Find the last rung position to avoid setting properties in all
1317 ;; the cases when the marked rung is complete.
1318 ;; (`next-single-property-change' is certain to move at least one
1319 ;; step forward.)
1322 ;; Got no marked rung here. Since the simple ws might have started
1323 ;; inside a line comment or cpp directive we must set `rung-pos' as
1324 ;; high as possible.
1333 ;; The following search is the main reason that `c-in-sws'
1334 ;; and `c-is-sws' aren't combined to one property.
1338 ;; If the `c-in-sws' region extended past the last
1339 ;; `c-is-sws' char we have to go back a bit.
1346 "c-forward-sws cached move %s -> %s (max %s)"
1353 ;; We'll loop here if there is simple ws after the last rung.
1354 ;; That means that there's been some change in it and it's
1355 ;; possible that we've stepped into another ladder, so extend
1356 ;; the previous one to join with it if there is one, and try to
1357 ;; use the cache again.
1359 "c-forward-sws extending rung with [%s..%s] (max %s)"
1362 ;; Remove any `c-in-sws' property from the last char of
1363 ;; the rung before we mark it with `c-is-sws', so that we
1364 ;; won't connect with the remains of a broken "ladder".
1370 last-put-in-sws-pos rung-pos)))
1377 ;; Skipped over comments. Don't cache at eob in case the buffer
1378 ;; is narrowed.
1389 ;; Skip a preprocessor directive.
1396 ;; Don't cache at eob in case the buffer is narrowed.
1399 ;; We've searched over a piece of non-white syntactic ws. See if this
1400 ;; can be cached.
1406 ;; Cache if we haven't skipped comments only, and if we started
1407 ;; either from a marked rung or from a completely uncached
1408 ;; position.
1413 ;; See if there's a marked rung in the encountered simple ws. If
1414 ;; so then we can cache, unless `safe-start' is nil. Even then
1415 ;; we need to do this to check if the cache can be used for the
1416 ;; next step.
1420 safe-start))
1424 "c-forward-sws caching [%s..%s] - [%s..%s] (max %s)"
1428 ;; Remove the properties for any nested ws that might be cached.
1429 ;; Only necessary for `c-is-sws' since `c-in-sws' will be set
1430 ;; anyway.
1438 last-put-in-sws-pos rung-pos))
1440 ;; Remove any `c-in-sws' property from the last char of
1441 ;; the rung before we mark it with `c-is-sws', so that we
1442 ;; won't connect with the remains of a broken "ladder".
1445 rung-end-pos))
1448 "c-forward-sws not caching [%s..%s] - [%s..%s] (max %s)"
1452 ;; Set `rung-pos' for the next rung. It's the same thing here as
1453 ;; initially, except that the rung position is set as early as
1454 ;; possible since we can't be in the ending ws of a line comment or
1455 ;; cpp directive now.
1462 ;; Make sure that the newly marked `c-in-sws' region doesn't connect to
1463 ;; another one after the point (which might occur when editing inside a
1464 ;; comment or macro).
1468 "c-forward-sws clearing at %s for cache separation"
1469 last-put-in-sws-pos)
1473 ;; If at eob we have to clear the last character before the end
1474 ;; instead since the buffer might be narrowed and there might
1475 ;; be a `c-in-sws' after (point-max). In this case it's
1476 ;; necessary to clear both properties.
1478 "c-forward-sws clearing thoroughly at %s for cache separation"
1481 last-put-in-sws-pos))))
1482 )))
1485 ;; Used by `c-backward-syntactic-ws' to implement the unbounded search.
1488 ;; part of the simple ws region.
1490 rung-is-marked simple-ws-beg cmt-skip-pos)
1492 ;; Skip simple horizontal ws and do a quick check on the preceding
1493 ;; character to see if it's anying that can't end syntactic ws, so we can
1494 ;; bail out early in the majority of cases when there just are a few ws
1495 ;; chars. Newlines are complicated in the backward direction, so we can't
1496 ;; skip over them.
1503 ;; Try to find a rung position in the simple ws preceding point, so that
1504 ;; we can get a cache hit even if the last bit of the simple ws has
1505 ;; changed recently.
1511 ;; `rung-pos' will be the earliest marked position, which means that
1512 ;; there might be later unmarked parts in the simple ws region.
1513 ;; It's not worth the effort to fix that; the last part of the
1514 ;; simple ws is also typically edited often, so it could be wasted.
1525 ;; The following search is the main reason that `c-in-sws'
1526 ;; and `c-is-sws' aren't combined to one property.
1530 ;; If the `c-in-sws' region extended past the first
1531 ;; `c-is-sws' char we have to go forward a bit.
1536 "c-backward-sws cached move %s <- %s (min %s)"
1548 t
1550 nil))
1552 ;; We'll loop here if there is simple ws before the first rung.
1553 ;; That means that there's been some change in it and it's
1554 ;; possible that we've stepped into another ladder, so extend
1555 ;; the previous one to join with it if there is one, and try to
1556 ;; use the cache again.
1558 "c-backward-sws extending rung with [%s..%s] (min %s)"
1561 ;; Remove any `c-in-sws' property from the last char of
1562 ;; the rung before we mark it with `c-is-sws', so that we
1563 ;; won't connect with the remains of a broken "ladder".
1566 rung-pos)
1570 last-put-in-sws-pos rung-pos))
1579 ;; Inside a cpp directive. See if it should be skipped over.
1582 ;; Move back over all line continuations in the region skipped
1583 ;; over by `c-backward-comments'. If we go past it then we
1584 ;; started inside the cpp directive.
1593 ;; Don't move past the cpp directive if we began inside
1594 ;; it. Note that the position at the end of the last line
1595 ;; of the macro is also considered to be within it.
1597 nil)
1599 ;; It's worthwhile to spend a little bit of effort on finding
1600 ;; the end of the macro, to get a good `simple-ws-beg'
1601 ;; position for the cache. Note that `c-backward-comments'
1602 ;; could have stepped over some comments before going into
1603 ;; the macro, and then `simple-ws-beg' must be kept on the
1604 ;; same side of those comments.
1611 ;; Might happen if comments after the macro were skipped
1612 ;; over.
1616 t)))
1621 simple-ws-beg)
1622 ;; Skipped over comments. Must put point at the end of
1623 ;; the simple ws at point since we might be after a line
1624 ;; comment or cpp directive that's been partially
1625 ;; narrowed out, and we can't risk marking the simple ws
1626 ;; at the end of it.
1628 t)))
1630 ;; We've searched over a piece of non-white syntactic ws. See if this
1631 ;; can be cached.
1636 ;; Cache if we started either from a marked rung or from a
1637 ;; completely uncached position.
1638 rung-is-marked
1641 ;; Cache if there's a marked rung in the encountered simple ws.
1649 "c-backward-sws caching [%s..%s] - [%s..%s] (min %s)"
1654 ;; Remove the properties for any nested ws that might be cached.
1655 ;; Only necessary for `c-is-sws' since `c-in-sws' will be set
1656 ;; anyway.
1661 ;; Remove any `c-in-sws' property from the last char of
1662 ;; the rung before we mark it with `c-is-sws', so that we
1663 ;; won't connect with the remains of a broken "ladder".
1666 rung-end-pos)
1669 last-put-in-sws-pos simple-ws-beg)
1670 rung-pos)
1675 "c-backward-sws not caching [%s..%s] - [%s..%s] (min %s)"
1681 ))
1683 ;; Make sure that the newly marked `c-in-sws' region doesn't connect to
1684 ;; another one before the point (which might occur when editing inside a
1685 ;; comment or macro).
1689 "c-backward-sws clearing at %s for cache separation"
1692 last-put-in-sws-pos))
1694 ;; If at bob and the buffer is narrowed, we have to clear the
1695 ;; character we're standing on instead since there might be a
1696 ;; `c-in-sws' before (point-min). In this case it's necessary
1697 ;; to clear both properties.
1699 "c-backward-sws clearing thoroughly at %s for cache separation"
1700 last-put-in-sws-pos)
1703 )))
1705 \f
1706 ;; A system for handling noteworthy parens before the point.
1710 ;; The state cache used by `c-parse-state' to cut down the amount of
1711 ;; searching. It's the result from some earlier `c-parse-state' call.
1712 ;; The use of the cached info is more effective if the next
1713 ;; `c-parse-state' call is on a line close by the one the cached state
1714 ;; was made at; the cache can actually slow down a little if the
1715 ;; cached state was made very far back in the buffer. The cache is
1716 ;; most effective if `c-parse-state' is used on each line while moving
1717 ;; forward.
1721 ;; This is (point-min) when `c-state-cache' was calculated, since a
1722 ;; change of narrowing is likely to affect the parens that are visible
1723 ;; before the point.
1726 ;; Invalidate all info on `c-state-cache' that applies to the buffer
1727 ;; at POS or higher. This is much like `c-whack-state-after', but
1728 ;; it never changes a paren pair element into an open paren element.
1729 ;; Doing that would mean that the new open paren wouldn't have the
1730 ;; required preceding paren pair element.
1731 ;;
1732 ;; This function does not do any hidden buffer changes.
1742 ;; Finds and records all noteworthy parens between some good point
1743 ;; earlier in the file and point. That good point is at least the
1744 ;; beginning of the top-level construct we are in, or the beginning
1745 ;; of the preceding top-level construct if we aren't in one.
1746 ;;
1747 ;; The returned value is a list of the noteworthy parens with the
1748 ;; last one first. If an element in the list is an integer, it's
1749 ;; the position of an open paren which has not been closed before
1750 ;; the point. If an element is a cons, it gives the position of a
1751 ;; closed brace paren pair; the car is the start paren position and
1752 ;; the cdr is the position following the closing paren. Only the
1753 ;; last closed brace paren pair before each open paren is recorded,
1754 ;; and thus the state never contains two cons elements in
1755 ;; succession.
1756 ;;
1757 ;; Currently no characters which are given paren syntax with the
1758 ;; syntax-table property are recorded, i.e. angle bracket arglist
1759 ;; parens are never present here. Note that this might change.
1760 ;;
1761 ;; This function does not do any hidden buffer changes.
1767 old-state last-pos pairs pos save-pos)
1770 ;; If the minimum position has changed due to narrowing then we
1771 ;; have to fix the tail of `c-state-cache' accordingly.
1774 ;; If point-min has moved forward then we just need to cut
1775 ;; off a bit of the tail.
1785 ;; If point-min has moved backward then we drop the state
1786 ;; completely. It's possible to do a better job here and
1787 ;; recalculate the top only.
1791 ;; Get the latest position we know are directly inside the
1792 ;; closest containing paren of the cached state.
1798 ;; Check if the found last-pos is in a macro. If it is, and
1799 ;; we're not in the same macro, we must discard everything on
1800 ;; c-state-cache that is inside the macro before using it.
1807 ;; Set last-pos again, just like above.
1814 ;; Find the start position for the forward search. (Can't
1815 ;; search in the backward direction since point might be
1816 ;; in some kind of literal.)
1819 ;; There's a cached state with a containing paren. Pop
1820 ;; off the stale containing sexps from it by going
1821 ;; forward out of parens as far as possible.
1835 ;; The last paren pair we moved out from was a brace
1836 ;; pair. Modify the state to record this as a closed
1837 ;; pair now.
1841 c-state-cache))))
1843 ;; Check if the preceding balanced paren is within a
1844 ;; macro; it should be ignored if we're outside the
1845 ;; macro. There's no need to check any further upwards;
1846 ;; if the macro contains an unbalanced opening paren then
1847 ;; we're smoked anyway.
1858 last-pos))
1861 ;; go back 2 bods, but ignore any bogus positions
1862 ;; returned by beginning-of-defun (i.e. open paren in
1863 ;; column zero)
1875 ;; Find the balanced brace pairs.
1877 pairs nil)
1883 ;; Should ignore any pairs that are in a macro, providing
1884 ;; we're not in the same one.
1891 ;; Record the last brace pair.
1895 ;; There's a closed pair on the cached state but we've
1896 ;; found a later one, so remove it.
1901 ;; There could already be a cons first in `c-state-cache'
1902 ;; if we've e.g. jumped over an unbalanced open paren in a
1903 ;; macro below.
1908 ;; Prepare to loop, but record the open paren only if it's
1909 ;; outside a macro or within the same macro as point, and
1910 ;; if it is a legitimate open paren and not some character
1911 ;; that got an open paren syntax-table property.
1918 ;; Check for known types of parens that we want
1919 ;; to record. The syntax table is not to be
1920 ;; trusted here since the caller might be using
1921 ;; e.g. `c++-template-syntax-table'.
1926 ;; Found a close paren without a corresponding opening
1927 ;; one. Maybe we didn't go back far enough, so try to
1928 ;; scan backward for the start paren and then start over.
1931 c-state-cache nil)
1933 ;; Emacs (up to at least 21.2) can get confused by
1934 ;; open parens in column zero inside comments: The
1935 ;; sexp functions can then misbehave and bring us
1936 ;; back to the same point again. Check this so that
1937 ;; we don't get an infinite loop.
1940 c-parsing-error
1946 c-state-cache)))
1948 ;; Debug tool to catch cache inconsistencies.
1959 res1 res2))
1960 res1))
1965 'c-debug-parse-state
1970 ;; Whack off any state information from PAREN-STATE which lies
1971 ;; before BUFPOS. Not destructive on PAREN-STATE.
1972 ;;
1973 ;; This function does not do any hidden buffer changes.
1976 car)
1987 ;; Whack off any state information from PAREN-STATE which lies at or
1988 ;; after BUFPOS. Not destructive on PAREN-STATE.
1989 ;;
1990 ;; This function does not do any hidden buffer changes.
1995 ;; just check the car, because in a balanced brace
1996 ;; expression, it must be impossible for the corresponding
1997 ;; close brace to be before point, but the open brace to
1998 ;; be after.
2000 nil ; whack it off
2002 ;; its possible that the open brace is before
2003 ;; bufpos, but the close brace is after. In that
2004 ;; case, convert this to a non-cons element. The
2005 ;; rest of the state is before bufpos, so we're
2006 ;; done.
2008 ;; we know that both the open and close braces are
2009 ;; before bufpos, so we also know that everything else
2010 ;; on state is before bufpos.
2013 nil ; whack it off
2014 ;; it's before bufpos, so everything else should too.
2017 nil)))
2020 ;; Return the bufpos of the innermost enclosing open paren before
2021 ;; bufpos that hasn't been narrowed out, or nil if none was found.
2022 ;;
2023 ;; This function does not do any hidden buffer changes.
2035 enclosingp))
2038 ;; Return the bufpos of the outermost enclosing open paren before
2039 ;; bufpos that hasn't been narrowed out, or nil if none was found.
2040 ;;
2041 ;; This function does not do any hidden buffer changes.
2051 pos))
2054 ;; Return the closest known safe position higher up than BUFPOS, or
2055 ;; nil if PAREN-STATE doesn't contain one. Return nil if BUFPOS is
2056 ;; nil, which is useful to find the closest limit before a given
2057 ;; limit that might be nil.
2058 ;;
2059 ;; This function does not do any hidden buffer changes.
2069 ;; See below.
2072 ;; elem is the position at and not after the opening paren, so
2073 ;; we can go forward one more step unless it's equal to
2074 ;; bufpos. This is useful in some cases avoid an extra paren
2075 ;; level between the safe position and bufpos.
2080 ;; This is used for `font-lock-beginning-of-syntax-function'. It
2081 ;; goes to the closest previous point that is known to be outside
2082 ;; any string literal or comment. `c-state-cache' is used if it has
2083 ;; a position in the vicinity.
2085 elem
2088 ;; Note: Similar code in `c-safe-position'. The
2089 ;; difference is that we accept a safe position at
2090 ;; the point and don't bother to go forward past open
2091 ;; parens.
2106 ;; The position is far back. Try `c-beginning-of-defun-1'
2107 ;; (although we can't be entirely sure it will go to a position
2108 ;; outside a comment or string in current emacsen). FIXME:
2109 ;; Consult `syntax-ppss' here.
2114 \f
2115 ;; Tools for scanning identifiers and other tokens.
2118 "Return non-nil if the point is on or directly after an identifier.
2119 Keywords are recognized and not considered identifiers. If an
2120 identifier is detected, the returned value is its starting position.
2121 If an identifier both starts and stops at the point \(can only happen
2122 in Pike) then the point for the preceding one is returned.
2124 This function does not do any hidden buffer changes."
2130 ;; Handle the `<operator> syntax in Pike.
2134 t
2145 ;; If the point is at the end of a symbol then skip backward to the
2146 ;; beginning of it. Don't move otherwise. Return non-nil if point
2147 ;; moved.
2150 ;; Handle the `<operator> syntax in Pike.
2156 t
2158 nil)))))
2161 ;; Move to the beginning of the current token. Do not move if not
2162 ;; in the middle of one. BACK-LIMIT may be used to bound the
2163 ;; backward search; if given it's assumed to be at the boundary
2164 ;; between two tokens.
2171 ;; `c-nonsymbol-token-regexp' should always match
2172 ;; since we've skipped backward over punctuator
2173 ;; or paren syntax, but consume one char in case
2174 ;; it doesn't so that we don't leave point before
2175 ;; some earlier incorrect token.
2182 ;; Move to the end of the current token. Do not move if not in the
2183 ;; middle of one. BACK-LIMIT may be used to bound the backward
2184 ;; search; if given it's assumed to be at the boundary between two
2185 ;; tokens. Return non-nil if the point is moved, nil otherwise.
2193 ;; `c-nonsymbol-token-regexp' should always match since
2194 ;; we've skipped backward over punctuator or paren
2195 ;; syntax, but move forward in case it doesn't so that
2196 ;; we don't leave point earlier than we started with.
2212 "Move forward by tokens.
2213 A token is defined as all symbols and identifiers which aren't
2215 treated properly). Point is always either left at the beginning of a
2216 token or not moved at all. COUNT specifies the number of tokens to
2217 move; a negative COUNT moves in the opposite direction. A COUNT of 0
2218 moves to the next token beginning only if not already at one. If
2219 BALANCED is true, move over balanced parens, otherwise move into them.
2220 Also, if BALANCED is true, never move out of an enclosing paren.
2222 LIMIT sets the limit for the movement and defaults to the point limit.
2223 The case when LIMIT is set in the middle of a token, comment or macro
2224 is handled correctly, i.e. the point won't be left there.
2226 Return the number of tokens left to move \(positive or negative). If
2227 BALANCED is true, a move over a balanced paren counts as one. Note
2228 that if COUNT is 0 and no appropriate token beginning is found, 1 will
2229 be returned. Thus, a return value of 0 guarantees that point is at
2230 the requested position and a return value less \(without signs) than
2231 COUNT guarantees that point is at the beginning of some token."
2238 c-jump-syntax-balanced
2239 c-jump-syntax-unbalanced))
2244 ;; If count is zero we should jump if in the middle of a token.
2251 ;; Skip whitespace. Count this as a move if we did in
2252 ;; fact move.
2256 ;; Moved out of bounds. Make sure the returned count isn't zero.
2261 ;; Use `condition-case' to avoid having the limit tests
2262 ;; inside the loop.
2270 t)
2273 t)
2274 ;; `c-nonsymbol-token-regexp' above should always
2275 ;; match if there are correct tokens. Try to
2276 ;; widen to see if the limit was set in the
2277 ;; middle of one, else fall back to treating
2278 ;; the offending thing as a one character token.
2283 nil)
2286 t))))
2296 count)))
2299 "Move backward by tokens.
2300 See `c-forward-token-2' for details."
2308 c-jump-syntax-balanced
2309 c-jump-syntax-unbalanced))
2313 ;; The count is zero so try to skip to the beginning of the
2314 ;; current token.
2318 ;; The limit is inside the same token, so return 1.
2321 ;; We're not in the middle of a token. If there's
2322 ;; whitespace after the point then we must move backward,
2323 ;; so set count to 1 in that case.
2325 ;; If we're looking at a '#' that might start a cpp
2326 ;; directive then we have to do a more elaborate check.
2339 ;; Use `condition-case' to avoid having to check for buffer
2340 ;; limits in `backward-char', `scan-sexps' and `goto-char' below.
2349 ;; This can be very inefficient if there's a long
2350 ;; sequence of operator tokens without any separation.
2351 ;; That doesn't happen in practice, anyway.
2361 count)))
2364 "Like `c-forward-token-2' but doesn't treat multicharacter operator
2366 characters are jumped over character by character. This function is
2367 for compatibility only; it's only a wrapper over `c-forward-token-2'."
2372 "Like `c-backward-token-2' but doesn't treat multicharacter operator
2374 characters are jumped over character by character. This function is
2375 for compatibility only; it's only a wrapper over `c-backward-token-2'."
2379 \f
2380 ;; Tools for doing searches restricted to syntactically relevant text.
2383 paren-level not-inside-token
2384 lookbehind-submatch)
2385 "Like `re-search-forward', but only report matches that are found
2386 in syntactically significant text. I.e. matches in comments, macros
2387 or string literals are ignored. The start point is assumed to be
2388 outside any comment, macro or string literal, or else the content of
2389 that region is taken as syntactically significant text.
2391 If PAREN-LEVEL is non-nil, an additional restriction is added to
2392 ignore matches in nested paren sexps. The search will also not go
2393 outside the current list sexp, which has the effect that if the point
2394 should be moved to BOUND when no match is found \(i.e. NOERROR is
2395 neither nil nor t), then it will be at the closing paren if the end of
2396 the current list sexp is encountered first.
2398 If NOT-INSIDE-TOKEN is non-nil, matches in the middle of tokens are
2399 ignored. Things like multicharacter operators and special symbols
2401 constants.
2403 If LOOKBEHIND-SUBMATCH is non-nil, it's taken as a number of a
2404 subexpression in REGEXP. The end of that submatch is used as the
2405 position to check for syntactic significance. If LOOKBEHIND-SUBMATCH
2406 isn't used or if that subexpression didn't match then the start
2408 subexpression is never tested before the starting position, so it
2412 subexpression can match the end of nonwhite syntactic whitespace,
2413 i.e. the end of comments or cpp directives. This since the function
2414 skips over such things before resuming the search. It's on the other
2416 matches syntactic whitespace.
2418 Bug: Unbalanced parens inside cpp directives are currently not handled
2419 correctly \(i.e. they don't get ignored as they should) when
2420 PAREN-LEVEL is set."
2425 ;;(message "c-syntactic-re-search-forward %s %s %S" (point) bound regexp)
2428 tmp
2429 ;; Start position for the last search.
2430 search-pos
2431 ;; The `parse-partial-sexp' state between the start position
2432 ;; and the point.
2433 state
2434 ;; The current position after the last state update. The next
2435 ;; `parse-partial-sexp' continues from here.
2437 ;; The position at which to check the state and the state
2438 ;; there. This is separate from `state-pos' since we might
2439 ;; need to back up before doing the next search round.
2440 check-pos check-state
2441 ;; Last position known to end a token.
2443 ;; Set when a valid match is found.
2444 found)
2462 state-pos check-pos paren-level nil state))
2464 check-state state))
2466 ;; NOTE: If we got a look behind subexpression and get
2467 ;; an insignificant match in something that isn't
2468 ;; syntactic whitespace (i.e. strings or in nested
2469 ;; parentheses), then we can never skip more than a
2470 ;; single character from the match start position
2471 ;; (i.e. `state-pos' here) before continuing the
2472 ;; search. That since the look behind subexpression
2473 ;; might match the end of the insignificant region in
2474 ;; the next search.
2478 ;; Match inside a line comment. Skip to eol. Use
2479 ;; `re-search-forward' instead of `skip-chars-forward' to get
2480 ;; the right bound behavior.
2484 ;; Match inside a block comment. Skip to the '*/'.
2491 ;; Match in the middle of the opener of a block or line
2492 ;; comment.
2497 ;; The last `parse-partial-sexp' above might have
2498 ;; stopped short of the real check position if the end
2499 ;; of the current sexp was encountered in paren-level
2500 ;; mode. The checks above are always false in that
2501 ;; case, and since they can do better skipping in
2502 ;; lookbehind-submatch mode, we do them before
2503 ;; checking the paren level.
2507 ;; Check the paren level first since we're short of the
2508 ;; syntactic checking position if the end of the
2509 ;; current sexp was encountered by `parse-partial-sexp'.
2512 ;; Inside a nested paren sexp.
2514 ;; See the NOTE above.
2516 ;; Skip out of the paren quickly.
2520 ;; Have exited the current paren sexp.
2523 ;; The last `parse-partial-sexp' call above
2524 ;; has left us just after the closing paren
2525 ;; in this case, so we can modify the bound
2526 ;; to leave the point at the right position
2527 ;; upon return.
2529 nil)
2533 ;; Match inside a string.
2536 ;; See the NOTE above.
2538 ;; Skip to the end of the string before continuing.
2547 continue)))
2552 ;; Match inside a macro. Skip to the end of it.
2560 (< check-pos
2566 ;; Inside a token.
2568 ;; See the NOTE above.
2573 ;; A real match.
2575 nil)))
2577 ;; Should loop to search again, but take care to avoid
2578 ;; looping on the same spot.
2582 nil
2585 t))))
2591 ;;(message "c-syntactic-re-search-forward done %s" (or (match-end 0) (point)))
2598 ;; Search failed. Set point as appropriate.
2602 nil)))
2605 "Like `skip-chars-backward' but only look at syntactically relevant chars,
2606 i.e. don't stop at positions inside syntactic whitespace or string
2607 literals. Preprocessor directives are also ignored, with the exception
2608 of the one that the point starts within, if any. If LIMIT is given,
2609 it's assumed to be at a syntactically relevant position."
2612 ;; A list of syntactically relevant positions in descending
2613 ;; order. It's used to avoid scanning repeatedly over
2614 ;; potentially large regions with `parse-partial-sexp' to verify
2615 ;; each position.
2616 safe-pos-list
2617 ;; The result from `c-beginning-of-macro' at the start position or the
2618 ;; start position itself if it isn't within a macro. Evaluated on
2619 ;; demand.
2620 start-macro-beg)
2626 ;; Use `parse-partial-sexp' from a safe position down to
2627 ;; the point to check if it's outside comments and
2628 ;; strings.
2630 ;; Pick a safe position as close to the point as
2631 ;; possible.
2632 ;;
2633 ;; FIXME: Consult `syntax-ppss' here if our
2634 ;; cache doesn't give a good position.
2650 ;; Cache positions along the way to use if we have to
2651 ;; back up more. Every closing paren on the same
2652 ;; level seems like fairly well spaced positions.
2658 ;; Inside string or comment. Continue search at the
2659 ;; beginning of it.
2661 ;; It's an emacs where `parse-partial-sexp'
2662 ;; supplies the starting position.
2665 t)
2668 ;; Inside a macro.
2676 t
2677 ;; It's inside the same macro we started in so it's
2678 ;; a relevant match.
2680 nil))))))
2684 ;; Skip syntactic ws afterwards so that we don't stop at the
2685 ;; end of a comment if `skip-chars' is something like "^/".
2691 \f
2692 ;; Tools for handling comments and string literals.
2695 "Return the type of literal point is in, if any.
2696 The return value is `c' if in a C-style comment, `c++' if in a C++
2697 style comment, `string' if in a string literal, `pound' if DETECT-CPP
2698 is non-nil and in a preprocessor line, or nil if somewhere else.
2699 Optional LIM is used as the backward limit of the search. If omitted,
2700 or nil, `c-beginning-of-defun' is used.
2702 The last point calculated is cached if the cache is enabled, i.e. if
2703 `c-in-literal-cache' is bound to a two element vector.
2705 This function does not do any hidden buffer changes."
2720 ;; cache this result if the cache is enabled
2723 rtn)))
2725 ;; XEmacs has a built-in function that should make this much quicker.
2726 ;; I don't think we even need the cache, which makes our lives more
2727 ;; complicated anyway. In this case, lim is only used to detect
2728 ;; cpp directives.
2729 ;;
2730 ;; Note that there is a bug in Xemacs's buffer-syntactic-context when used in
2731 ;; conjunction with syntax-table-properties. The bug is present in, e.g.,
2732 ;; Xemacs 21.4.4. It manifested itself thus:
2733 ;;
2734 ;; Starting with an empty AWK Mode buffer, type
2735 ;; /regexp/ {<C-j>
2736 ;; Point gets wrongly left at column 0, rather than being indented to tab-width.
2737 ;;
2738 ;; AWK Mode is designed such that when the first / is typed, it gets the
2739 ;; syntax-table property "string fence". When the second / is typed, BOTH /s
2740 ;; are given the s-t property "string". However, buffer-syntactic-context
2741 ;; fails to take account of the change of the s-t property on the opening / to
2742 ;; "string", and reports that the { is within a string started by the second /.
2743 ;;
2744 ;; The workaround for this is for the AWK Mode initialisation to switch the
2745 ;; defalias for c-in-literal to c-slow-in-literal. This will slow down other
2746 ;; cc-modes in Xemacs whenever an awk-buffer has been initialised.
2747 ;;
2748 ;; (Alan Mackenzie, 2003/4/30).
2763 ;; The defalias above isn't enough to shut up the byte compiler.
2767 "Return a cons of the beginning and end positions of the comment or
2768 string surrounding point (including both delimiters), or nil if point
2770 to start parsing from. If NEAR is non-nil, then the limits of any
2772 spaces and tabs between point and the literal. The search for such a
2773 literal is done first in forward direction. If NOT-IN-DELIMITER is
2774 non-nil, the case when point is inside a starting delimiter won't be
2775 recognized. This only has effect for comments, which have starting
2776 delimiters with more than one character.
2778 This function does not do any hidden buffer changes."
2788 ;; String. Search backward for the start.
2796 ;; Line comment. Search from bol for the comment starter.
2809 ;; Block comment. Search backward for the comment starter.
2819 ;; We're standing in a comment starter.
2826 ;; Search forward for a literal.
2838 ;; Search backward.
2849 ;; Block comment. Due to the nature of line
2850 ;; comments, they will always be covered by the
2851 ;; normal case above.
2854 ;; If LIM is bogus, beg will be bogus.
2858 ))))
2861 ;; Like c-literal-limits, but for emacsen whose `parse-partial-sexp'
2862 ;; returns the pos of the comment start.
2864 "Return a cons of the beginning and end positions of the comment or
2865 string surrounding point (including both delimiters), or nil if point
2867 to start parsing from. If NEAR is non-nil, then the limits of any
2869 spaces and tabs between point and the literal. The search for such a
2870 literal is done first in forward direction. If NOT-IN-DELIMITER is
2871 non-nil, the case when point is inside a starting delimiter won't be
2872 recognized. This only has effect for comments, which have starting
2873 delimiters with more than one character.
2875 This function does not do any hidden buffer changes."
2897 ;; We're standing in a comment starter.
2904 ;; Search forward for a literal.
2916 ;; Search backward.
2927 ;; Block comment. Due to the nature of line
2928 ;; comments, they will always be covered by the
2929 ;; normal case above.
2932 ;; If LIM is bogus, beg will be bogus.
2936 ))))
2942 "If the argument is a cons of two buffer positions (such as returned by
2943 `c-literal-limits'), and that range contains a C++ style line comment,
2944 then an extended range is returned that contains all adjacent line
2945 comments (i.e. all comments that starts in the same column with no
2946 empty lines or non-whitespace characters between them). Otherwise the
2947 argument is returned.
2949 This function does not do any hidden buffer changes."
2959 ;; Got to take care in the backward direction to handle
2960 ;; comments which are preceded by code.
2974 range)
2978 "Convenience function that given the result of `c-literal-limits',
2979 returns nil or the type of literal that the range surrounds. It's
2980 much faster than using `c-in-literal' and is intended to be used when
2981 you need both the type of a literal and its limits.
2983 This function does not do any hidden buffer changes."
2993 range))
2995 \f
2996 ;; `c-find-decl-spots' and accompanying stuff.
2998 ;; Variables used in `c-find-decl-spots' to cache the search done for
2999 ;; the first declaration in the last call. When that function starts,
3000 ;; it needs to back up over syntactic whitespace to look at the last
3001 ;; token before the region being searched. That can sometimes cause
3002 ;; moves back and forth over a quite large region of comments and
3003 ;; macros, which would be repeated for each changed character when
3004 ;; we're called during fontification, since font-lock refontifies the
3005 ;; current line for each change. Thus it's worthwhile to cache the
3006 ;; first match.
3007 ;;
3008 ;; `c-find-decl-syntactic-pos' is a syntactically relevant position in
3009 ;; the syntactic whitespace less or equal to some start position.
3010 ;; There's no cached value if it's nil.
3011 ;;
3012 ;; `c-find-decl-match-pos' is the match position if
3013 ;; `c-find-decl-prefix-search' matched before the syntactic whitespace
3014 ;; at `c-find-decl-syntactic-pos', or nil if there's no such match.
3025 ; (defface c-debug-decl-spot-face
3026 ; '((t (:background "Turquoise")))
3027 ; "Debug face to mark the spots where `c-find-decl-spots' stopped.")
3028 ; (defface c-debug-decl-sws-face
3029 ; '((t (:background "Khaki")))
3030 ; "Debug face to mark the syntactic whitespace between the declaration
3031 ; spots and the preceding token end.")
3047 ;; Macro used inside `c-find-decl-spots'. It ought to be a defun,
3048 ;; but it contains lots of free variables that refer to things
3049 ;; inside `c-find-decl-spots'. The point is left at `cfd-match-pos'
3050 ;; if there is a match, otherwise at `cfd-limit'.
3053 ;; Find the next property match position if we haven't got one already.
3064 ;; Find the next `c-decl-prefix-re' match if we haven't got one already.
3069 c-literal-faces))
3070 ;; Search again if the match is within a comment or a string literal.
3080 ;; Choose whichever match is closer to the start.
3083 cfd-re-match nil)
3085 cfd-prop-match nil))
3090 ;; Skip forward past comments only so we don't skip macros.
3092 ;; Set the position to continue at. We can avoid going over
3093 ;; the comments skipped above a second time, but it's possible
3094 ;; that the comment skipping has taken us past `cfd-prop-match'
3095 ;; since the property might be used inside comments.
3101 ;; Call CFD-FUN for each possible spot for a declaration from the
3102 ;; point to CFD-LIMIT. A spot for a declaration is the first token
3103 ;; in the buffer and each token after the ones matched by
3104 ;; `c-decl-prefix-re' and after the occurrences of the `c-type'
3105 ;; property with the value `c-decl-end' (if `c-type-decl-end-used'
3106 ;; is set). Only a spot that match CFD-DECL-RE and whose face is in
3107 ;; the CFD-FACE-CHECKLIST list causes CFD-FUN to be called. The
3108 ;; face check is disabled if CFD-FACE-CHECKLIST is nil.
3109 ;;
3110 ;; If the match is inside a macro then the buffer is narrowed to the
3111 ;; end of it, so that CFD-FUN can investigate the following tokens
3112 ;; without matching something that begins inside a macro and ends
3113 ;; outside it. It's to avoid this work that the CFD-DECL-RE and
3114 ;; CFD-FACE-CHECKLIST checks exist.
3115 ;;
3116 ;; CFD-FUN is called with point at the start of the spot. It's
3117 ;; passed two arguments: The first is the end position of the token
3118 ;; that `c-decl-prefix-re' matched, or 0 for the implicit match at
3119 ;; bob. The second is a flag that is t when the match is inside a
3120 ;; macro.
3121 ;;
3122 ;; It's assumed that comment and strings are fontified in the
3123 ;; searched range.
3124 ;;
3125 ;; This is mainly used in fontification, and so has an elaborate
3126 ;; cache to handle repeated calls from the same start position; see
3127 ;; the variables above.
3128 ;;
3129 ;; All variables in this function begin with `cfd-' to avoid name
3130 ;; collision with the (dynamically bound) variables used in CFD-FUN.
3133 ;; The last regexp match found by `c-find-decl-prefix-search'.
3134 cfd-re-match
3135 ;; The last `c-decl-end' found by `c-find-decl-prefix-search'.
3136 ;; If searching for the property isn't needed then we disable
3137 ;; it by faking a first match at the limit.
3139 ;; The position of the last match found by
3140 ;; `c-find-decl-prefix-search'. For regexp matches it's the
3141 ;; end of the matched token, for property matches it's the end
3142 ;; of the property. 0 for the implicit match at bob.
3143 ;; `cfd-limit' if there's no match.
3145 ;; The position to continue searching at.
3146 cfd-continue-pos
3147 ;; The position of the last "real" token we've stopped at.
3148 ;; This can be greater than `cfd-continue-pos' when we get
3149 ;; hits inside macros or at `c-decl-end' positions inside
3150 ;; comments.
3152 ;; The end position of the last entered macro.
3155 ;; Initialize by finding a syntactically relevant start position
3156 ;; before the point, and do the first `c-decl-prefix-re' search
3157 ;; unless we're at bob.
3160 ;; Must back up a bit since we look for the end of the previous
3161 ;; statement or declaration, which is earlier than the first
3162 ;; returned match.
3165 ;; But first we need to move to a syntactically relevant
3166 ;; position. Use the faces to back up to the start of the
3167 ;; comment or string literal.
3176 ;; XEmacs doesn't fontify the quotes surrounding string
3177 ;; literals.
3186 ;; The font lock package might not have fontified the start of
3187 ;; the literal at all so check that we have arrived at
3188 ;; something that looks like a start or else resort to
3189 ;; `c-literal-limits'.
3194 ;; Must back out of any macro so that we don't miss any
3195 ;; declaration that could follow after it, unless the limit is
3196 ;; inside the macro. We only check that for the current line to
3197 ;; save some time; it's enough for the by far most common case
3198 ;; when font-lock refontifies the current line only.
3207 ;; Clear the cache if it applied further down.
3213 ;; If we hit `c-find-decl-syntactic-pos' and
3214 ;; `c-find-decl-match-pos' is set then we install the cached
3215 ;; values. If we hit `c-find-decl-syntactic-pos' and
3216 ;; `c-find-decl-match-pos' is nil then we know there's no decl
3217 ;; prefix in the whitespace before `c-find-decl-syntactic-pos'
3218 ;; and so we can continue the search from this point. If we
3219 ;; didn't hit `c-find-decl-syntactic-pos' then we're now in the
3220 ;; right spot to begin searching anyway.
3222 c-find-decl-match-pos)
3225 ;; The match is always outside macros and comments so we
3226 ;; start at the next token. The loop below will later go
3227 ;; back using `cfd-continue-pos' to fix declarations inside
3228 ;; the syntactic ws.
3232 cfd-continue-pos syntactic-pos)
3239 ;; Always consider bob a match to get the first declaration
3240 ;; in the file. Do this separately instead of letting
3241 ;; `c-decl-prefix-re' match bob, so that it always can
3242 ;; consume at least one character to ensure that we won't
3243 ;; get stuck in an infinite loop.
3248 ;; Do an initial search now. In the bob case above it's only done
3249 ;; to search for the `c-type' property.
3252 ;; Advance `cfd-continue-pos' if we got a hit before the start
3253 ;; position. The earliest position that could affect after
3254 ;; the start position is the char before the preceding
3255 ;; comments.
3264 ;; If we got a match it's always outside macros and comments so
3265 ;; advance to the next token and set `cfd-token-pos'. The loop
3266 ;; below will later go back using `cfd-continue-pos' to fix
3267 ;; declarations inside the syntactic ws.
3276 cfd-match-pos))))
3278 ;; Now loop. We already got the first match.
3285 ;; Kludge to filter out matches on the "<" that
3286 ;; aren't open parens, for the sake of languages
3287 ;; that got `c-recognize-<>-arglists' set.
3292 ;; If `cfd-continue-pos' is less or equal to
3293 ;; `cfd-token-pos', we've got a hit inside a macro
3294 ;; that's in the syntactic whitespace before the last
3295 ;; "real" declaration we've checked. If they're equal
3296 ;; we've arrived at the declaration a second time, so
3297 ;; there's nothing to do.
3301 ;; If `cfd-continue-pos' is less than `cfd-token-pos'
3302 ;; we're still searching for declarations embedded in
3303 ;; the syntactic whitespace. In that case we need
3304 ;; only to skip comments and not macros, since they
3305 ;; can't be nested, and that's already been done in
3306 ;; `c-find-decl-prefix-search'.
3311 ;; Continue if the following token fails the
3312 ;; CFD-DECL-RE and CFD-FACE-CHECKLIST checks.
3319 t)))
3327 ;; Narrow to the end of the macro if we got a hit inside
3328 ;; one, to avoid recognizing things that start inside
3329 ;; the macro and end outside it.
3331 ;; Not in the same macro as in the previous round.
3342 t
3345 t)
3346 ;; The matched token was the last thing in the
3347 ;; macro, so the whole match is bogus.
3349 nil)))
3355 ;; Restore limits if we did macro narrowment above.
3363 \f
3364 ;; A cache for found types.
3366 ;; Buffer local variable that contains an obarray with the types we've
3367 ;; found. If a declaration is recognized somewhere we record the
3368 ;; fully qualified identifier in it to recognize it as a type
3369 ;; elsewhere in the file too. This is not accurate since we do not
3370 ;; bother with the scoping rules of the languages, but in practice the
3371 ;; same name is seldom used as both a type and something else in a
3372 ;; file, and we only use this as a last resort in ambiguous cases (see
3373 ;; `c-font-lock-declarations').
3378 ;; Clears `c-found-types'.
3379 ;;
3380 ;; This function does not do any hidden buffer changes.
3384 ;; Add the given region as a type in `c-found-types'. If the region
3385 ;; doesn't match an existing type but there is a type which is equal
3386 ;; to the given one except that the last character is missing, then
3387 ;; the shorter type is removed. That's done to avoid adding all
3388 ;; prefixes of a type as it's being entered and font locked. This
3389 ;; doesn't cover cases like when characters are removed from a type
3390 ;; or added in the middle. We'd need the position of point when the
3391 ;; font locking is invoked to solve this well.
3396 ;; To avoid storing very long strings, do not add a type that
3397 ;; contains '<' in languages with angle bracket arglists, since
3398 ;; the type then probably contains a C++ template spec and those
3399 ;; can be fairly sized programs in themselves.
3406 ;; Return non-nil if the given region contains a type in
3407 ;; `c-found-types'.
3411 ;; Return all the types in `c-found-types' as a sorted list of
3412 ;; strings.
3416 type-list)))
3417 c-found-types)
3420 \f
3421 ;; Handling of small scale constructs like types and names.
3424 ;; Remove all the properties put by `c-forward-<>-arglist' in the
3425 ;; specified region. Point is clobbered.
3435 ;; Dynamically bound variable that instructs `c-forward-type' to also
3436 ;; treat possible types (i.e. those that it normally returns 'maybe or
3437 ;; 'found for) as actual types (and always return 'found for them).
3438 ;; This means that it records them in `c-record-type-identifiers' if
3439 ;; that is set, and that it adds them to `c-found-types'.
3442 ;; Dynamically bound variable that instructs `c-forward-<>-arglist' to
3443 ;; not accept arglists that contain binary operators.
3444 ;;
3445 ;; This is primarily used to handle C++ template arglists. C++
3446 ;; disambiguates them by checking whether the preceding name is a
3447 ;; template or not. We can't do that, so we assume it is a template
3448 ;; if it can be parsed as one. That usually works well since
3449 ;; comparison expressions on the forms "a < b > c" or "a < b, c > d"
3450 ;; in almost all cases would be pointless.
3451 ;;
3452 ;; However, in function arglists, e.g. in "foo (a < b, c > d)", we
3453 ;; should let the comma separate the function arguments instead. And
3454 ;; in a context where the value of the expression is taken, e.g. in
3455 ;; "if (a < b || c > d)", it's probably not a template.
3458 ;; Dynamically bound variables that instructs `c-forward-name',
3459 ;; `c-forward-type' and `c-forward-<>-arglist' to record the ranges of
3460 ;; all the type and reference identifiers they encounter. They will
3461 ;; build lists on these variables where each element is a cons of the
3462 ;; buffer positions surrounding each identifier. This recording is
3463 ;; only activated when `c-record-type-identifiers' is non-nil.
3464 ;;
3465 ;; All known types that can't be identifiers are recorded, and also
3466 ;; other possible types if `c-promote-possible-types' is set.
3467 ;; Recording is however disabled inside angle bracket arglists that
3468 ;; are encountered inside names and other angle bracket arglists.
3469 ;; Such occurences are taken care of by `c-font-lock-<>-arglists'
3470 ;; instead.
3471 ;;
3472 ;; Only the names in C++ template style references (e.g. "tmpl" in
3473 ;; "tmpl<a,b>::foo") are recorded as references, other references
3474 ;; aren't handled here.
3478 ;; If `c-record-type-identifiers' is set, this will receive a cons
3479 ;; cell of the range of the last single identifier symbol stepped over
3480 ;; by `c-forward-name' if it's successful. This is the range that
3481 ;; should be put on one of the record lists by the caller. It's
3482 ;; assigned nil if there's no such symbol in the name.
3487 ;; Always true.
3497 ;; Always true.
3505 ;; Dynamically bound variable that instructs `c-forward-type' to
3506 ;; record the ranges of types that only are found. Behaves otherwise
3507 ;; like `c-record-type-identifiers'.
3511 ;; Used internally in `c-forward-keyword-clause' to move forward
3512 ;; over a type (if TYPE is 'type) or a name (otherwise) which
3513 ;; possibly is prefixed by keywords and their associated clauses.
3514 ;; Try with a type/name first to not trip up on those that begin
3515 ;; with a keyword. Return t if a known or found type is moved
3516 ;; over. The point is clobbered if nil is returned. If range
3517 ;; recording is enabled, the identifier is recorded on as a type
3518 ;; if TYPE is 'type or as a reference if TYPE is 'ref.
3523 nil
3530 t)))
3533 ;; Used internally in `c-forward-keyword-clause' to move forward
3534 ;; over a comma separated list of types or names using
3535 ;; `c-forward-keyword-prefixed-id'.
3545 ;; The first submatch in the current match data is assumed to
3546 ;; surround a token. If it's a keyword, move over it and any
3547 ;; following clauses associated with it, stopping at the next
3548 ;; following token. t is returned in that case, otherwise the point
3549 ;; stays and nil is returned. The kind of clauses that are
3550 ;; recognized are those specified by `c-type-list-kwds',
3551 ;; `c-ref-list-kwds', `c-colon-type-list-kwds',
3552 ;; `c-paren-nontype-kwds', `c-paren-type-kwds', `c-<>-type-kwds',
3553 ;; and `c-<>-arglist-kwds'.
3564 ;; There's a type directly after a keyword in `c-type-list-kwds'.
3569 ;; There's a name directly after a keyword in `c-ref-list-kwds'.
3574 ;; There's an open paren after a keyword in `c-paren-any-kwds'.
3581 ;; Use `c-forward-type' on every identifier we can find
3582 ;; inside the paren, to record the types.
3609 ;; If a keyword matched both one of the types above and
3610 ;; this one, we match `c-colon-type-list-re' after the
3611 ;; clause matched above.
3618 ;; There's a type after the `c-colon-type-list-re'
3619 ;; match after a keyword in `c-colon-type-list-kwds'.
3623 t)))
3626 ;; The point is assumed to be at a '<'. Try to treat it as the open
3627 ;; paren of an angle bracket arglist and move forward to the the
3628 ;; corresponding '>'. If successful, the point is left after the
3629 ;; '>' and t is returned, otherwise the point isn't moved and nil is
3630 ;; returned. If ALL-TYPES is t then all encountered arguments in
3631 ;; the arglist that might be types are treated as found types.
3632 ;;
3633 ;; The surrounding '<' and '>' are given syntax-table properties to
3634 ;; make them behave like parentheses. Each argument separating ','
3635 ;; is also set to `c-<>-arg-sep' in the `c-type' property. These
3636 ;; properties are also cleared in a relevant region forward from the
3637 ;; point if they seems to be set and it turns out to not be an
3638 ;; arglist.
3639 ;;
3640 ;; If the arglist has been successfully parsed before then paren
3641 ;; syntax properties will be exploited to quickly jump to the end,
3642 ;; but that can be disabled by setting REPARSE to t. That is
3643 ;; necessary if the various side effects, e.g. recording of type
3644 ;; ranges, are important. Setting REPARSE to t only applies
3645 ;; recursively to nested angle bracket arglists if
3646 ;; `c-restricted-<>-arglists' is set.
3649 ;; If `c-record-type-identifiers' is set then activate
3650 ;; recording of any found types that constitute an argument in
3651 ;; the arglist.
3659 ;; `nconc' doesn't mind that the tail of
3660 ;; `c-record-found-types' is t.
3662 t)
3665 nil)))
3668 ;; Recursive part of `c-forward-<>-arglist'.
3671 ;; Cover this so that any recorded found type ranges are
3672 ;; automatically lost if it turns out to not be an angle
3673 ;; bracket arglist. It's propagated through the return value
3674 ;; on successful completion.
3676 ;; List that collects the positions after the argument
3677 ;; separating ',' in the arglist.
3678 arg-start-pos)
3680 ;; If the '<' has paren open syntax then we've marked it as an
3681 ;; angle bracket arglist before, so try to skip to the end and see
3682 ;; that the close paren matches.
3699 nil)))
3707 ;; Got an arglist that appears to be valid.
3709 ;; Reparsing is requested, so zap the properties in the
3710 ;; region and go on to redo it. It's done here to
3711 ;; avoid leaving it behind if we exit through
3712 ;; `angle-bracket-arglist-escape' below.
3716 nil)
3717 t)
3719 ;; Got unmatched paren brackets or either paren was
3720 ;; actually some other token. Recover by clearing the
3721 ;; syntax properties on all the '<' and '>' in the
3722 ;; range where we'll search for the arglist below.
3733 nil)))
3734 t
3744 ;; All encountered identifiers are types, so set the
3745 ;; promote flag and parse the type.
3752 ;; Check if this arglist argument is a sole type. If
3753 ;; it's known then it's recorded in
3754 ;; `c-record-type-identifiers'. If it only is found
3755 ;; then it's recorded in `c-record-found-types' which we
3756 ;; might roll back if it turns out that this isn't an
3757 ;; angle bracket arglist afterall.
3763 ;; A found type was recorded but it's not the
3764 ;; only thing in the arglist argument, so reset
3765 ;; `c-record-found-types'.
3767 orig-record-found-types))))))
3771 ;; Must check for '>' at the very start separately,
3772 ;; since the regexp below has to avoid ">>" without
3773 ;; using \\=.
3775 t)
3777 ;; Note: These regexps exploit the match order in \| so
3778 ;; that "<>" is matched by "<" rather than "[^>:-]>".
3781 ;; Stop on ',', '|', '&', '+' and '-' to catch
3782 ;; common binary operators that could be between
3783 ;; two comparison expressions "a<b" and "c>d".
3785 ;; Otherwise we still stop on ',' to find the
3786 ;; argument start positions.
3790 ;; If the arglist starter has lost its open paren
3791 ;; syntax but not the closer, we won't find the
3792 ;; closer above since we only search in the
3793 ;; balanced sexp. In that case we stop just short
3794 ;; of it so check if the following char is the closer.
3796 ;; Remove its syntax so that we don't enter the
3797 ;; recovery code below. That's not necessary
3798 ;; since there's no real reason to suspect that
3799 ;; things inside the arglist are unbalanced.
3802 t)))
3806 ;; Either an operator starting with '>' or the end of
3807 ;; the angle bracket arglist.
3815 ;; We've skipped past a list that ended with '>'. It
3816 ;; must be unbalanced since nested arglists are handled
3817 ;; in the case below. Recover by removing all paren
3818 ;; properties on '<' and '>' in the searched region and
3819 ;; redo the search.
3823 t)
3832 t)
3834 ;; The angle bracket arglist is finished.
3842 nil)))
3845 ;; Either an operator starting with '<' or a nested arglist.
3857 ;; There's always an identifier before a angle
3858 ;; bracket arglist, or a keyword in
3859 ;; `c-<>-type-kwds' or `c-<>-arglist-kwds'.
3878 )))
3880 ;; It was not an angle bracket arglist.
3885 ;; Got an invalid open paren syntax on this
3886 ;; '<'. We'll probably get an unbalanced '>'
3887 ;; further ahead if we just remove the syntax
3888 ;; here, so recover by removing all paren
3889 ;; properties up to and including the
3890 ;; balancing close paren.
3896 ;; It was an angle bracket arglist.
3899 ;; Record the identifier before the template as a type
3900 ;; or reference depending on whether the arglist is last
3901 ;; in a qualified identifier.
3910 t)
3914 ;; Just another argument. Record the position. The
3915 ;; type check stuff that made us stop at it is at
3916 ;; the top of the loop.
3920 ;; Got a character that can't be in an angle bracket
3921 ;; arglist argument. Abort using `throw', since
3922 ;; it's useless to try to find a surrounding arglist
3923 ;; if we're nested.
3930 ;; Move forward over a complete name if at the beginning of one,
3931 ;; stopping at the next following token. If the point is not at
3932 ;; something that are recognized as name then it stays put. A name
3933 ;; could be something as simple as "foo" in C or something as
3934 ;; complex as "X<Y<class A<int>::B, BIT_MAX >> b>, ::operator<> ::
3935 ;; Z<(a>b)> :: operator const X<&foo>::T Q::G<unsigned short
3936 ;; int>::*volatile const" in C++ (this function is actually little
3937 ;; more than a `looking-at' call in all modes except those that,
3938 ;; like C++, have `c-recognize-<>-arglists' set). Return nil if no
3939 ;; name is found, 'template if it's an identifier ending with an
3940 ;; angle bracket arglist, 'operator of it's an operator identifier,
3941 ;; or t if it's some other kind of name.
3944 ;; Turn off `c-promote-possible-types' here since we might
3945 ;; call `c-forward-<>-arglist' and we don't want it to promote
3946 ;; every suspect thing in the arglist to a type. We're
3947 ;; typically called from `c-forward-type' in this case, and
3948 ;; the caller only wants the top level type that it finds to
3949 ;; be promoted.
3950 c-promote-possible-types)
3956 ;; Check for keyword. We go to the last symbol in
3957 ;; `c-identifier-key' first.
3973 ;; "template" is only valid inside an
3974 ;; identifier if preceded by "::".
3979 t))
3981 ;; Handle a C++ operator or template identifier.
3985 ;; Got "... ::template".
3989 res subres))))
3992 ;; Got a cast operator.
3996 ;; Now we should match a sequence of either
3997 ;; '*', '&' or a name followed by ":: *",
3998 ;; where each can be followed by a sequence
3999 ;; of `c-opt-type-modifier-key'.
4002 t)
4012 t))))
4020 ;; Got some other operator.
4029 nil)
4037 res t)))
4047 ;; Got a concatenated identifier. This handles the
4048 ;; cases with tricky syntactic whitespace that aren't
4049 ;; covered in `c-identifier-key'.
4052 t)
4056 ;; Maybe an angle bracket arglist.
4065 ;; Continue if there's an identifier concatenation
4066 ;; operator after the template argument.
4073 t)
4074 ;; `c-add-type' isn't called here since we don't
4075 ;; want to add types containing angle bracket
4076 ;; arglists.
4081 nil)))
4082 )))))
4085 res))
4088 ;; Move forward over a type spec if at the beginning of one,
4089 ;; stopping at the next following token. Return t if it's a known
4090 ;; type that can't be a name or other expression, 'known if it's an
4091 ;; otherwise known type (according to `*-font-lock-extra-types'),
4092 ;; 'prefix if it's a known prefix of a type, 'found if it's a type
4093 ;; that matches one in `c-found-types', 'maybe if it's an identfier
4094 ;; that might be a type, or nil if it can't be a type (the point
4095 ;; isn't moved then). The point is assumed to be at the beginning
4096 ;; of a token.
4097 ;;
4098 ;; Note that this function doesn't skip past the brace definition
4099 ;; that might be considered part of the type, e.g.
4100 ;; "enum {a, b, c} foo".
4103 ;; Skip leading type modifiers. If any are found we know it's a
4104 ;; prefix of a type.
4113 ;; Looking at a keyword that prefixes a type identifier,
4114 ;; e.g. "class".
4121 ;; In many languages the name can be used without the
4122 ;; prefix, so we add it to `c-found-types'.
4127 ;; Invalid syntax.
4139 id-range c-last-identifier-range))))
4151 id-end)
4153 ;; Looking at a primitive or known type identifier. We've
4154 ;; checked for a name first so that we don't go here if the
4155 ;; known type match only is a prefix of another name.
4166 ;; There might be more keywords for the type.
4194 ;; A normal identifier.
4204 ;; It's an identifier that has been used as
4205 ;; a type somewhere else.
4206 'found
4207 ;; It's an identifier that might be a type.
4210 ;; A template is a type.
4214 ;; Otherwise it's an operator identifier, which is not a type.
4219 ;; Skip trailing type modifiers. If any are found we know it's
4220 ;; a type.
4227 ;; Step over any type suffix operator. Do not let the existence
4228 ;; of these alter the classification of the found type, since
4229 ;; these operators typically are allowed in normal expressions
4230 ;; too.
4237 ;; Look for a trailing operator that concatenate the type with
4238 ;; a following one, and if so step past that one through a
4239 ;; recursive call.
4242 c-promote-possible-types))
4243 ;; If we can't promote then set `c-record-found-types' so that
4244 ;; we can merge in the types from the second part afterwards if
4245 ;; it turns out to be a known type there.
4256 ;; If either operand certainly is a type then both are, but we
4257 ;; don't let the existence of the operator itself promote two
4258 ;; uncertain types to a certain one.
4276 ;; Merge in the ranges of any types found by the second
4277 ;; `c-forward-type'.
4279 ;; `nconc' doesn't mind that the tail of
4280 ;; `c-record-found-types' is t.
4282 c-record-type-identifiers))))
4290 ;;(message "c-forward-type %s -> %s: %s" start (point) res)
4292 res))
4294 \f
4295 ;; Handling of large scale constructs like statements and declarations.
4298 ;; Go to the first non-whitespace after the colon that starts a
4299 ;; multiple inheritance introduction. Optional LIM is the farthest
4300 ;; back we should search.
4312 ;; Return nil if we aren't in a method definition, otherwise the
4313 ;; position of the initial [+-].
4319 ))
4321 ;; Contributed by Kevin Ryde <user42@zip.com.au>.
4323 ;; Return non-nil if point is within a gcc \"asm\" block.
4324 ;;
4325 ;; This should be called with point inside an argument list.
4326 ;;
4327 ;; Only one level of enclosing parentheses is considered, so for
4328 ;; instance `nil' is returned when in a function call within an asm
4329 ;; operand.
4339 "Return a determination as to whether point is at the `top-level'.
4340 Being at the top-level means that point is either outside any
4341 enclosing block (such function definition), or only inside a class,
4342 namespace or other block that contains another declaration level.
4344 If point is not at the top-level (e.g. it is inside a method
4345 definition), then nil is returned. Otherwise, if point is at a
4346 top-level not enclosed within a class definition, t is returned.
4347 Otherwise, a 2-vector is returned where the zeroth element is the
4348 buffer position of the start of the class declaration, and the first
4349 element is the buffer position of the enclosing class's opening
4350 brace."
4356 ;; Return non-nil if we are between a function's argument list closing
4357 ;; paren and its opening brace. Note that the list close brace
4358 ;; could be followed by a "const" specifier or a member init hanging
4359 ;; colon. LIM is used as bound for some backward buffer searches;
4360 ;; the search might continue past it.
4361 ;;
4362 ;; Note: This test is easily fooled. It only works reasonably well
4363 ;; in the situations where `c-guess-basic-syntax' uses it.
4369 ;; could be looking at const specifier
4374 ;; otherwise, we could be looking at a hanging member init
4375 ;; colon
4379 ;; this will catch member inits with multiple
4380 ;; line arglists
4393 nil
4395 )
4398 ;; Check that it isn't a cpp expression, e.g. the
4399 ;; expression of an #if directive or the "function header"
4400 ;; of a #define.
4404 ;; Check if we are looking at an ObjC method def or a class
4405 ;; category.
4415 ;; Pike has compound types that include parens,
4416 ;; e.g. "array(string)". Check that we aren't after one.
4422 ))))
4425 ;; Return the position of the first argument declaration if point is
4426 ;; inside a K&R style argument declaration list, nil otherwise.
4427 ;; `c-recognize-knr-p' is not checked. If LIM is non-nil, it's a
4428 ;; position that bounds the backward search for the argument list.
4429 ;;
4430 ;; Note: A declaration level context is assumed; the test can return
4431 ;; false positives for statements.
4436 ;; Go back to the closest preceding normal parenthesis sexp. We
4437 ;; take that as the argument list in the function header. Then
4438 ;; check that it's followed by some symbol before the next ';'
4439 ;; or '{'. If it does, it's the header of the K&R argdecl we're
4440 ;; in.
4443 paren-end)
4459 ;; The function header in a K&R declaration should only
4460 ;; contain identifiers separated by comma. It should
4461 ;; also contain at least one identifier since there
4462 ;; wouldn't be anything to declare in the K&R region
4463 ;; otherwise.
4479 ;; If it's a K&R declaration then we're now at the
4480 ;; beginning of the function arglist. Check that there
4481 ;; isn't a '=' before it in this statement since that
4482 ;; means it some kind of initialization instead.
4489 ;; skip forward over conditional at point, including any predicate
4490 ;; statements in parentheses. No error checking is performed.
4492 ;; else if()
4497 ;; do, else, try, finally
4502 ;; for, if, while, switch, catch, synchronized, foreach
4506 ;; If looking at the token after a conditional then return the
4507 ;; position of its start, otherwise return nil.
4517 ;; Assuming point is at a brace that opens a statement block of some
4518 ;; kind, move to the proper anchor point for that block. It might
4519 ;; need to be adjusted further by c-add-stmt-syntax, but the
4520 ;; position at return is suitable as start position for that
4521 ;; function.
4528 ;; Assuming point is at a brace that opens the block of a top level
4529 ;; declaration of some kind, move to the proper anchor point for
4530 ;; that block.
4535 ;; Search forward for the end of the "header" of the current
4536 ;; declaration. That's the position where the definition body
4537 ;; starts, or the first variable initializer, or the ending
4538 ;; semicolon. I.e. search forward for the closest following
4539 ;; (syntactically relevant) '{', '=' or ';' token. Point is left
4540 ;; _after_ the first found token, or at point-max if none is found.
4545 ;; In C++ we need to take special care to handle operator
4546 ;; tokens and those pesky template brackets.
4551 ;; Handle operator identifiers, i.e. ignore any
4552 ;; operator token preceded by "operator".
4559 t
4561 nil)))))
4570 ;; Go to the beginning of the current declaration, or the beginning
4571 ;; of the previous one if already at the start of it. Point won't
4572 ;; be moved out of any surrounding paren. Return a cons cell on the
4573 ;; form (MOVE . KNR-POS). MOVE is like the return value from
4574 ;; `c-beginning-of-statement-1'. If point skipped over some K&R
4575 ;; style argument declarations (and they are to be recognized) then
4576 ;; KNR-POS is set to the start of the first such argument
4577 ;; declaration, otherwise KNR-POS is nil. If LIM is non-nil, it's a
4578 ;; position that bounds the backward search.
4579 ;;
4580 ;; NB: Cases where the declaration continues after the block, as in
4581 ;; "struct foo { ... } bar;", are currently recognized as two
4582 ;; declarations, e.g. "struct foo { ... }" and "bar;" in this case.
4588 ;; `c-beginning-of-statement-1' stops at a block start, but we
4589 ;; want to continue if the block doesn't begin a top level
4590 ;; construct, i.e. if it isn't preceded by ';', '}', ':', bob,
4591 ;; or an open paren.
4594 ;; Must check with c-opt-method-key in ObjC mode.
4604 ;; Check that we don't move from the first thing in a
4605 ;; macro to its header.
4611 move tentative-move))
4616 ;; Handle K&R argdecls. Back up after the "statement" jumped
4617 ;; over by `c-beginning-of-statement-1', unless it was the
4618 ;; function body, in which case we're sitting on the opening
4619 ;; brace now. Then test if we're in a K&R argdecl region and
4620 ;; that we started at the other side of the first argdecl in
4621 ;; it.
4631 'previous
4633 knr-argdecl-start))
4637 ;; Might have ended up before a protection label. This should
4638 ;; perhaps be checked before `c-recognize-knr-p' to be really
4639 ;; accurate, but we know that no language has both.
4647 ;; `c-beginning-of-statement-1' counts each brace block as a
4648 ;; separate statement, so the result will be 'previous if we've
4649 ;; moved over any. If they were brace list initializers we might
4650 ;; not have moved over a declaration boundary though, so change it
4651 ;; to 'same if we've moved past a '=' before '{', but not ';'.
4652 ;; (This ought to be integrated into `c-beginning-of-statement-1',
4653 ;; so we avoid this extra pass which potentially can search over a
4654 ;; large amount of text.)
4657 c++-template-syntax-table
4670 ;; Assuming point is at the start of a declaration (as detected by
4671 ;; e.g. `c-beginning-of-decl-1'), go to the end of it. Unlike
4672 ;; `c-beginning-of-decl-1', this function handles the case when a
4673 ;; block is followed by identifiers in e.g. struct declarations in C
4674 ;; or C++. If a proper end was found then t is returned, otherwise
4675 ;; point is moved as far as possible within the current sexp and nil
4676 ;; is returned. This function doesn't handle macros; use
4677 ;; `c-end-of-macro' instead in those cases.
4680 c++-template-syntax-table
4688 ;; Stopped at the ';' in a K&R argdecl section which is
4689 ;; detected using the same criteria as in
4690 ;; `c-beginning-of-decl-1'. Move to the following block
4691 ;; start.
4695 ;; Encountered a block in the declaration. Jump over it.
4706 ;; Check for `c-opt-block-decls-with-vars-key'
4707 ;; before the first paren.
4710 c-opt-block-decls-with-vars-key
4712 lim t t t)
4715 ;; Check that the first following paren is
4716 ;; the block.
4718 lim t t t)
4720 ;; The declaration doesn't have any of the
4721 ;; `c-opt-block-decls-with-vars' keywords in the
4722 ;; beginning, so it ends here at the end of the block.
4730 nil)))
4733 ;; Go to the beginning of a member init list (i.e. just after the
4734 ;; ':') if inside one. Returns t in that case, nil otherwise.
4747 ;; this will catch member inits with multiple
4748 ;; line arglists
4756 ;; Skip over any template arg to the class. This way with a
4757 ;; syntax table is bogus but it'll have to do for now.
4766 ;; Skip backwards over a fully::qualified::name.
4774 ;; If we've stepped over a number then this is a bitfield.
4779 ;; now continue checking
4786 ;; search for the containing class, returning a 2 element vector if
4787 ;; found. aref 0 contains the bufpos of the boi of the class key
4788 ;; line, and aref 1 contains the bufpos of the open brace.
4790 ;; no paren-state means we cannot be inside a class
4791 nil
4793 search-start search-end)
4795 ;; a cons cell in the first element means that there is some
4796 ;; balanced sexp before the current bufpos. this we can
4797 ;; ignore. the nth 1 and nth 2 elements define for us the
4798 ;; search boundaries
4801 ;; if the car was not a cons cell then nth 0 and nth 1 define
4802 ;; for us the search boundaries
4805 ;; if search-end is nil, or if the search-end character isn't an
4806 ;; open brace, we are definitely not in a class
4810 nil
4811 ;; now, we need to look more closely at search-start. if
4812 ;; search-start is nil, then our start boundary is really
4813 ;; point-min.
4816 ;; if search-start is a cons cell, then we can start
4817 ;; searching from the end of the balanced sexp just ahead of
4818 ;; us
4821 ;; Otherwise we start searching within the surrounding paren sexp.
4823 ;; now we can do a quick regexp search from search-start to
4824 ;; search-end and see if we can find a class key. watch for
4825 ;; class like strings in literals
4834 ;; Add one to the search limit, to allow
4835 ;; matching of the "{" in the regexp.
4838 t))
4847 ;; check for embedded keywords
4853 ;; make sure we're really looking at the start of a
4854 ;; class definition, and not an ObjC method.
4859 ;; Check if this is an anonymous inner class.
4865 ;; We're done. Just trap this case in the cond.
4866 nil
4867 ;; False alarm; all conditions aren't satisfied.
4869 ;; Its impossible to define a regexp for this, and
4870 ;; nearly so to do it programmatically.
4871 ;;
4872 ;; ; picks up forward decls
4873 ;; = picks up init lists
4874 ;; ) picks up return types
4875 ;; > picks up templates, but remember that we can
4876 ;; inherit from templates!
4878 ;; try to see if we found the `class' keyword
4879 ;; inside a template arg list
4890 )))
4891 foundp))
4892 )))))
4895 ;; return the buffer position of the beginning of the brace list
4896 ;; statement if we're inside a brace list, otherwise return nil.
4897 ;; CONTAINING-SEXP is the buffer pos of the innermost containing
4898 ;; paren. BRACE-STATE is the remainder of the state of enclosing
4899 ;; braces
4900 ;;
4901 ;; N.B.: This algorithm can potentially get confused by cpp macros
4902 ;; places in inconvenient locations. Its a trade-off we make for
4903 ;; speed.
4905 ;; This will pick up brace list declarations.
4918 ;; this will pick up array/aggregate init lists, even if they are nested.
4921 ;; Pike can have class definitions anywhere, so we must
4922 ;; check for the class key here.
4924 c-decl-block-key))
4925 bufpos braceassignp lim next-containing)
4927 containing-sexp)
4938 ;; We're in an in-expression block of some kind. Do not
4939 ;; check nesting. We deliberately set the limit to the
4940 ;; containing sexp, so that c-looking-at-inexpr-block
4941 ;; doesn't check for an identifier before it.
4943 ;; see if the open brace is preceded by = or [...] in
4944 ;; this statement, but watch out for operator=
4947 ;; Checks to do only on the first sexp before the brace.
4950 ;; In Java, an initialization brace list may follow
4951 ;; directly after "new Foo[]", so check for a "new"
4952 ;; earlier.
4958 ;; Carry on looking if this is an
4959 ;; identifier (may contain "." in Java)
4960 ;; or another "[]" sexp.
4963 ;; Checks to do on all sexps before the brace, up to the
4964 ;; beginning of the statement.
4972 ;; We've seen a =, but must check earlier tokens so
4973 ;; that it isn't something that should be ignored.
4979 ;; Check for operator =
4981 ;; Check for `<opchar>= in Pike.
4984 ;; Special case for Pikes
4985 ;; `[]=, since '[' is not in
4986 ;; the punctuation class.
4989 nil)
4991 ;; make sure we're not in a C++ template
4992 ;; argument assignment
5004 ))))
5005 nil)
5012 ;; Brace lists can't contain a semicolon, so we're done.
5014 ;; Go up one level.
5016 lim nil
5017 next-containing nil))
5018 ;; we've hit the beginning of the aggregate list
5022 )
5023 bufpos))
5024 ))
5027 ;; If we're looking at the start of a pike-style list, ie `({Â })',
5028 ;; `([Â ])', `(<Â >)' etc, a cons of a cons of its starting and ending
5029 ;; positions and its entry in c-special-brace-lists is returned, nil
5030 ;; otherwise. The ending position is nil if the list is still open.
5031 ;; LIM is the limit for forward search. The point may either be at
5032 ;; the `(' or at the following paren character. Tries to check the
5033 ;; matching closer, but assumes it's correct if no balanced paren is
5034 ;; found (i.e. the case `({ ... } ... )' is detected as _not_ being
5035 ;; a special brace list).
5040 inner-beg end type)
5055 nil)))))
5065 ;; Check balancing of the inner paren
5066 ;; below.
5069 t)
5070 ;; If the inner char isn't a paren then
5071 ;; we can't check balancing, so just
5072 ;; check the char before the outer
5073 ;; closing paren.
5088 ;; Return non-nil if between two statements or declarations, assuming
5089 ;; point is not inside a literal or comment.
5093 ;; Return t if at the start inside some parenthesis expression
5094 ;; too, to catch macros that have statements as arguments.
5102 ;; Returns non-nil if we're looking at the beginning of a block
5103 ;; inside an expression. The value returned is actually a cons of
5104 ;; either 'inlambda, 'inexpr-statement or 'inexpr-class and the
5105 ;; position of the beginning of the construct. LIM limits the
5106 ;; backward search. CONTAINING-SEXP is the start position of the
5107 ;; closest containing list. If it's nil, the containing paren isn't
5108 ;; used to decide whether we're inside an expression or not. If
5109 ;; both LIM and CONTAINING-SEXP is used, LIM needs to be farther
5110 ;; back.
5114 ;; Look at the character after point only as a last resort
5115 ;; when we can't disambiguate.
5128 c-opt-inexpr-class-key
5132 ;; If the class definition is at the start of
5133 ;; a statement, we don't consider it an
5134 ;; in-expression class.
5142 ;; Also, in Pike we treat it as an
5143 ;; in-expression class if it's used in an
5144 ;; object clone expression.
5159 nil)
5166 containing-sexp
5175 nil
5177 res))))
5180 ;; Returns non-nil if we're looking at the end of an in-expression
5181 ;; block, otherwise the same as `c-looking-at-inexpr-block'.
5182 ;; PAREN-STATE is the paren state relevant at the current position.
5184 ;; We currently only recognize a block.
5187 containing-sexp)
5196 paren-state)
5197 containing-sexp)))))
5200 ;; Narrow the buffer so that the enclosing class is hidden. Uses
5201 ;; and returns the value from c-search-uplist-for-classkey.
5210 ;; if point is now left of the class opening brace, we're
5211 ;; hosed, so try a different tact
5217 ;; end point is the end of the current line
5221 ;; return the class vector
5222 inclass-p))
5224 \f
5225 ;; `c-guess-basic-syntax' and the functions that precedes it below
5226 ;; implements the main decision tree for determining the syntactic
5227 ;; analysis of the current line of code.
5229 ;; Dynamically bound to t when `c-guess-basic-syntax' is called during
5230 ;; auto newline analysis.
5234 ;; A simple function to prepend a new syntax element to
5235 ;; `c-syntactic-context'. Using `setq' on it is unsafe since it
5236 ;; should always be dynamically bound but since we read it first
5237 ;; we'll fail properly anyway if this function is misused.
5239 c-syntactic-context)))
5242 ;; Like `c-add-syntax' but appends to the end of the syntax list.
5243 ;; (Normally not necessary.)
5248 syntax-extra-args
5249 stop-at-boi-only
5250 at-block-start
5251 containing-sexp
5252 paren-state)
5253 ;; Do the generic processing to anchor the given syntax symbol on
5254 ;; the preceding statement: Skip over any labels and containing
5255 ;; statements on the same line, and then search backward until we
5256 ;; find a statement or block start that begins at boi without a
5257 ;; label or comment.
5258 ;;
5259 ;; Point is assumed to be at the prospective anchor point for the
5260 ;; given SYNTAX-SYMBOL. More syntax entries are added if we need to
5261 ;; skip past open parens and containing statements. All the added
5262 ;; syntax elements will get the same anchor point.
5263 ;;
5264 ;; SYNTAX-EXTRA-ARGS are a list of the extra arguments for the
5265 ;; syntax symbol. They are appended after the anchor point.
5266 ;;
5267 ;; If STOP-AT-BOI-ONLY is nil, we might stop in the middle of the
5268 ;; line if another statement precedes the current one on this line.
5269 ;;
5270 ;; If AT-BLOCK-START is non-nil, point is taken to be at the
5271 ;; beginning of a block or brace list, which then might be nested
5272 ;; inside an expression. If AT-BLOCK-START is nil, this is found
5273 ;; out by checking whether the character at point is "{" or not.
5275 ;; This is by far the most common case, so let's give it special
5276 ;; treatment.
5283 step-type step-tmp at-comment special-list)
5286 ;; Begin by skipping any labels and containing statements that
5287 ;; are on the same line.
5292 t
5294 nil)
5297 step-type step-tmp))
5300 ;; Loop if we have to back out of the containing block.
5304 ;; Loop if we have to back up another statement.
5308 ;; Always start by skipping over any comments that
5309 ;; stands between the statement and boi.
5322 ;; Current position might not be good enough;
5323 ;; skip backward another statement.
5325 containing-sexp))
5330 ;; If stop-at-boi-only is nil, we shouldn't
5331 ;; back up over previous or containing
5332 ;; statements to try to reach boi, so go
5333 ;; back to the last position and exit.
5336 nil)
5339 ;; If we've moved into another statement
5340 ;; then we should no longer try to stop
5341 ;; after boi.
5344 ;; Record this a substatement if we skipped up
5345 ;; one level, but not if we're still on the
5346 ;; same line. This so e.g. a sequence of "else
5347 ;; if" clauses won't indent deeper and deeper.
5356 nil)
5357 t)))))
5360 at-comment nil))
5369 ;; Don't stop in the middle of a special brace list opener
5370 ;; like "({".
5378 paren-state)
5395 ;; We're in an in-expression statement.
5396 ;; This syntactic element won't get an anchor pos.
5412 ;; If the open brace was at boi, we're always
5413 ;; done. The c-beginning-of-statement-1 call
5414 ;; above is necessary anyway, to decide the type
5415 ;; of block-intro to add.
5421 'defun-block-intro
5423 nil))
5426 ;; Loop if the brace wasn't at boi, and we didn't
5427 ;; arrive at a defun block.
5429 ;; Avoid backing up another sexp if the point
5430 ;; we're at now is found to be good enough in
5431 ;; the loop above.
5437 )))
5439 ;; Fill in the current point as the anchor for all the symbols
5440 ;; added above.
5447 )))
5450 ;; The inclass and class-close syntactic symbols are added in
5451 ;; several places and some work is needed to fix everything.
5452 ;; Therefore it's collected here.
5465 paren-state)
5466 containing-sexp)))
5469 anchor)))
5472 char-after-ip
5473 beg-of-same-or-containing-stmt
5474 containing-sexp
5475 paren-state)
5476 ;; This function contains the decision tree reached through both
5477 ;; cases 18 and 10. It's a continued statement or top level
5478 ;; construct of some kind.
5485 ;; (CASE A removed.)
5486 ;; CASE B: open braces for class or brace-lists
5493 ;; CASE B.1: class-open
5499 ))
5502 ;; CASE B.2: brace-list-open
5507 indent-point t t t)))
5508 ;; The most semantically accurate symbol here is
5509 ;; brace-list-open, but we normally report it simply as a
5510 ;; statement-cont. The reason is that one normally adjusts
5511 ;; brace-list-open for brace lists as top-level constructs,
5512 ;; and brace lists inside statements is a completely different
5513 ;; context. C.f. case 5A.3.
5516 ;; Turn off the dwim above when we're
5517 ;; analyzing the nature of the brace
5518 ;; for the auto newline feature.
5519 'brace-list-open
5521 nil nil nil
5522 containing-sexp paren-state))
5524 ;; CASE B.3: The body of a function declared inside a normal
5525 ;; block. Can occur e.g. in Pike and when using gcc
5526 ;; extensions, but watch out for macros followed by blocks.
5527 ;; C.f. cases E, 16F and 17G.
5532 ;; Look for a type followed by a symbol, i.e. the start of a
5533 ;; function declaration. Doesn't work for declarations like
5534 ;; "int *foo() ..."; we'd need to refactor the more competent
5535 ;; analysis in `c-font-lock-declarations' for that.
5541 containing-sexp paren-state))
5543 ;; CASE B.4: Continued statement with block open. The most
5544 ;; accurate analysis is perhaps `statement-cont' together with
5545 ;; `block-open' but we play DWIM and use `substatement-open'
5546 ;; instead. The rationaly is that this typically is a macro
5547 ;; followed by a block which makes it very similar to a
5548 ;; statement with a substatement block.
5551 containing-sexp paren-state))
5552 ))
5554 ;; CASE C: iostream insertion or extraction operator
5558 ;; If there is no preceding streamop in the statement
5559 ;; then indent this line as a normal statement-cont.
5563 t))))
5565 ;; CASE E: In the "K&R region" of a function declared inside a
5566 ;; normal block. C.f. case B.3.
5568 ;; Check that the next token is a '{'. This works as
5569 ;; long as no language that allows nested function
5570 ;; definitions allows stuff like member init lists, K&R
5571 ;; declarations or throws clauses there.
5572 ;;
5573 ;; Note that we do a forward search for something ahead
5574 ;; of the indentation line here. That's not good since
5575 ;; the user might not have typed it yet. Unfortunately
5576 ;; it's exceedingly tricky to recognize a function
5577 ;; prototype in a code block without resorting to this.
5584 ;; Look for a type followed by a symbol, i.e. the start of a
5585 ;; function declaration. Doesn't work for declarations like "int
5586 ;; *foo() ..."; we'd need to refactor the more competent analysis
5587 ;; in `c-font-lock-declarations' for that.
5593 containing-sexp paren-state))
5595 ;; CASE D: continued statement.
5599 containing-sexp paren-state))
5600 )))
5603 "Return the syntactic context of the current line.
5604 This function does not do any hidden buffer changes."
5612 literal containing-sexp char-before-ip char-after-ip lim
5613 c-syntactic-context placeholder c-in-literal-cache step-type
5614 tmpsymbol keyword injava-inher special-brace-list
5615 ;; narrow out any enclosing class or extern "C" block
5617 indent-point))
5618 ;; `c-state-cache' is shadowed here so that we don't
5619 ;; throw it away due to the narrowing that might be done
5620 ;; by the function above. That means we must not do any
5621 ;; changes during the execution of this function, since
5622 ;; `c-invalidate-state-cache' then would change this local
5623 ;; variable and leave a bogus value in the global one.
5626 paren-state))
5628 inenclosing-p macro-start in-macro-expr
5629 ;; There's always at most one syntactic element which got
5630 ;; a relpos. It's stored in syntactic-relpos.
5631 syntactic-relpos
5633 ;; Check for meta top-level enclosing constructs such as
5634 ;; extern language definitions.
5644 ;; Compatibility with legacy choice of name for the
5645 ;; extern-lang syntactic symbols.
5648 ;; Init some position variables:
5649 ;;
5650 ;; containing-sexp is the open paren of the closest
5651 ;; surrounding sexp or nil if there is none that hasn't been
5652 ;; narrowed out.
5653 ;;
5654 ;; lim is the position after the closest preceding brace sexp
5655 ;; (nested sexps are ignored), or the position after
5656 ;; containing-sexp if there is none, or (point-min) if
5657 ;; containing-sexp is nil.
5658 ;;
5659 ;; c-state-cache is the state from c-parse-state at
5660 ;; indent-point, without any parens outside the region
5661 ;; narrowed by c-narrow-out-enclosing-class.
5662 ;;
5663 ;; paren-state is the state from c-parse-state outside
5664 ;; containing-sexp, or at indent-point if containing-sexp is
5665 ;; nil. paren-state is not limited to the narrowed region, as
5666 ;; opposed to c-state-cache.
5675 ;; Ignore balanced paren. The next entry
5676 ;; can't be another one.
5679 ;; If there is no surrounding open paren then
5680 ;; put the last balanced pair back on paren-state.
5682 containing-sexp nil)))
5686 ;; If we're in a parenthesis list then ',' delimits the
5687 ;; "statements" rather than being an operator (with the
5688 ;; exception of the "for" clause). This difference is
5689 ;; typically only noticeable when statements are used in macro
5690 ;; arglists.
5695 ;; cache char before and after indent point, and move point to
5696 ;; the most likely position to perform the majority of tests
5704 ;; are we in a literal?
5707 ;; now figure out syntactic qualities of the current line
5709 ;; CASE 1: in a string.
5712 ;; CASE 2: in a C or C++ style comment.
5714 ;; This is a kludge for XEmacs where we use
5715 ;; `buffer-syntactic-context', which doesn't correctly
5716 ;; recognize "\*/" to end a block comment.
5717 ;; `parse-partial-sexp' which is used by
5718 ;; `c-literal-limits' will however do that in most
5719 ;; versions, which results in that we get nil from
5720 ;; `c-literal-limits' even when `c-in-literal' claims
5721 ;; we're inside a comment.
5724 ;; CASE 3: in a cpp preprocessor macro continuation.
5734 ;; If at the beginning of the body of a #define
5735 ;; directive then analyze as cpp-define-intro
5736 ;; only. Go on with the syntactic analysis
5737 ;; otherwise. in-macro-expr is set if we're in a
5738 ;; cpp expression, i.e. before the #define body
5739 ;; or anywhere in a non-#define directive.
5746 nil)))))
5749 ;; CASE 11: an else clause?
5753 containing-sexp paren-state))
5754 ;; CASE 12: while closure of a do/while construct?
5762 containing-sexp paren-state))
5763 ;; CASE 13: A catch or finally clause? This case is simpler
5764 ;; than if-else and do-while, because a block is required
5765 ;; after every try, catch and finally.
5773 t)
5777 t)
5780 t))
5785 containing-sexp paren-state))
5786 ;; CASE 18: A substatement we can recognize by keyword.
5797 ;; Ought to cache the result from the
5798 ;; c-beginning-of-statement-1 calls here.
5808 ;; Step up to the containing statement if we
5809 ;; stayed in the same one.
5817 ;; There was no containing statement afterall.
5819 placeholder))
5821 ;; Require a parenthesis after these keywords.
5822 ;; Necessary to catch e.g. synchronized in Java,
5823 ;; which can be used both as statement and
5824 ;; modifier.
5829 ;; CASE 18A: Simple substatement.
5835 containing-sexp paren-state))
5841 containing-sexp paren-state))
5844 containing-sexp paren-state))))
5845 ;; CASE 18B: Some other substatement. This is shared
5846 ;; with case 10.
5848 char-after-ip
5849 placeholder
5850 lim
5851 paren-state)))
5852 ;; CASE 4: In-expression statement. C.f. cases 7B, 16A and
5853 ;; 17E.
5855 c-opt-inexpr-block-key
5856 c-opt-lambda-key)
5859 containing-sexp)))
5864 ;; It's a statement block or an anonymous class.
5866 ;; It's a Pike lambda. Check whether we are between the
5867 ;; lambda keyword and the argument list or at the defun
5868 ;; opener.
5870 'inline-open
5879 ;; CASE 5: Line is at top level.
5882 ;; CASE 5A: we are looking at a defun, brace list, class,
5883 ;; or inline-inclass method opening brace
5889 ;; CASE 5A.1: Non-class declaration block open.
5898 ;; Special case for extern-lang-open. The
5899 ;; check for a following string is disabled
5900 ;; since it doesn't disambiguate anything.
5902 ;; (c-forward-sexp 1)
5903 ;; (c-forward-syntactic-ws)
5904 ;; (eq (char-after) ?\"))
5907 ))
5910 ;; CASE 5A.2: we are looking at a class opening brace
5917 ))
5919 ;; CASE 5A.3: brace list open
5944 ))))
5948 ;; We're in Java and have found that the open brace
5949 ;; belongs to a "new Foo[]" initialization list,
5950 ;; which means the brace list is part of an
5951 ;; expression and not a top level definition. We
5952 ;; therefore treat it as any topmost continuation
5953 ;; even though the semantically correct symbol still
5954 ;; is brace-list-open, on the same grounds as in
5955 ;; case B.2.
5960 ;; CASE 5A.4: inline defun open
5964 ;; CASE 5A.5: ordinary defun open
5969 ;; Bogus to use bol here, but it's the legacy.
5971 )))
5972 ;; CASE 5B: first K&R arg decl or member init
5975 ;; CASE 5B.1: a member init
5978 ;; this line should be indented relative to the beginning
5979 ;; of indentation for the topmost-intro line that contains
5980 ;; the prototype's open paren
5981 ;; TBD: is the following redundant?
5985 ;; TBD: is the preceding redundant?
5999 ;; we don't need to add any class offset since this
6000 ;; should be relative to the ctor's indentation
6001 )
6002 ;; CASE 5B.2: K&R arg decl intro
6009 ;; CASE 5B.3: Inside a member init list.
6013 ;; CASE 5B.4: Nether region after a C++ or Java func
6014 ;; decl, which could include a `throws' declaration.
6018 )))
6019 ;; CASE 5C: inheritance line. could be first inheritance
6020 ;; line, or continuation of a multiple inheritance
6028 ;; watch out for scope operator
6033 )))
6042 ;; for Java
6047 cont done)
6052 done t))
6056 )
6058 injava-inher)
6061 ))
6063 ;; CASE 5C.1: non-hanging colon on an inher intro
6067 ;; don't add inclass symbol since relative point already
6068 ;; contains any class offset
6069 )
6070 ;; CASE 5C.2: hanging colon on an inher intro
6076 ;; CASE 5C.3: in a Java implements/extends
6090 )))
6091 ;; CASE 5C.4: a continued inheritance line
6095 ;; don't add inclass symbol since relative point already
6096 ;; contains any class offset
6097 )))
6098 ;; CASE 5D: this could be a top-level initialization, a
6099 ;; member init list continuation, or a template argument
6100 ;; list continuation.
6102 c++-template-syntax-table
6105 ;; Note: We use the fact that lim is always after any
6106 ;; preceding brace sexp.
6122 ;; CASE 5D.1: hanging member init colon, but watch out
6123 ;; for bogus matches on access specifiers inside classes.
6143 )))
6147 ;; we do not need to add class offset since relative
6148 ;; point is the member init above us
6149 )
6150 ;; CASE 5D.2: non-hanging member init colon
6156 ;; CASE 5D.3: perhaps a template list continuation?
6165 ;; we can probably indent it just like an arglist-cont
6169 ;; CASE 5D.4: perhaps a multiple inheritance line?
6181 t)
6185 ;; CASE 5D.5: Continuation of the "expression part" of a
6186 ;; top level construct.
6195 ;; A preceding comma at the top level means that a
6196 ;; new variable declaration starts here. Use
6197 ;; topmost-intro-cont for it, for consistency with
6198 ;; the first variable declaration. C.f. case 5N.
6199 'topmost-intro-cont
6201 nil nil nil containing-sexp paren-state))
6202 ))
6203 ;; CASE 5E: we are looking at a access specifier
6205 c-opt-access-key
6208 paren-state))
6209 ;; Append access-label with the same anchor point as inclass gets.
6211 ;; CASE 5F: Close of a non-class declaration level block.
6216 ;; CASE 5G: we are looking at the brace which closes the
6217 ;; enclosing nested class decl
6226 ))))
6228 ;; CASE 5H: we could be looking at subsequent knr-argdecls
6234 ;; Do an extra check to avoid tripping up on
6235 ;; statements that occur in invalid contexts
6236 ;; (e.g. in macro bodies where we don't really
6237 ;; know the context of what we're looking at).
6243 ;; CASE 5I: ObjC method definition.
6248 ;; Handle the case when it's the first (non-comment)
6249 ;; thing in the buffer. Can't look for a 'same return
6250 ;; value from cbos1 since ObjC directives currently
6251 ;; aren't recognized fully, so that we get 'same
6252 ;; instead of 'previous if it moved over a preceding
6253 ;; directive.
6256 ;; CASE 5P: AWK pattern or function or continuation
6257 ;; thereof.
6263 'topmost-intro-cont
6265 nil nil nil
6266 containing-sexp paren-state))
6267 ;; CASE 5N: At a variable declaration that follows a class
6268 ;; definition or some other block declaration that doesn't
6269 ;; end at the closing '}'. C.f. case 5D.5.
6276 ;; Speed up the backward search a bit.
6281 ;; The '}' is unbalanced.
6282 nil
6287 containing-sexp paren-state))
6288 ;; CASE 5J: we are at the topmost level, make
6289 ;; sure we skip back past any access specifiers
6292 c-opt-access-key
6307 ;; real beginning-of-line could be narrowed out due to
6308 ;; enclosure in a class block
6312 ;; Using bol instead of boi above is highly bogus, and
6313 ;; it makes our lives hard to remain compatible. :P
6323 ))
6325 macro-start
6329 ))
6330 ;; CASE 5K: we are at an ObjC method definition
6331 ;; continuation line.
6340 ;; CASE 5L: we are at the first argument of a template
6341 ;; arglist that begins on the previous line.
6345 ;; CASE 5M: we are at a topmost continuation line
6349 ))
6350 ;; (CASE 6 has been removed.)
6351 ;; CASE 7: line is an expression, not a statement. Most
6352 ;; likely we are either in a function prototype or a function
6353 ;; call argument list
6360 ;; CASE 7A: we are looking at the arglist closing paren.
6361 ;; C.f. case 7F.
6374 ;; CASE 7B: Looking at the opening brace of an
6375 ;; in-expression block or brace list. C.f. cases 4, 16A
6376 ;; and 17E.
6380 c-state-cache))
6384 placeholder
6387 paren-state)
6388 containing-sexp)))
6389 ;; placeholder is nil if it's a block directly in
6390 ;; a function arglist. That makes us skip out of
6391 ;; this case.
6392 )))
6400 ;; CASE 7C: we are looking at the first argument in an empty
6401 ;; argument list. Use arglist-close if we're actually
6402 ;; looking at a close paren or bracket.
6412 ;; CASE 7D: we are inside a conditional test clause. treat
6413 ;; these things as statements
6423 ))
6424 ;; CASE 7E: maybe a continued ObjC method call. This is the
6425 ;; case when we are inside a [] bracketed exp, and what
6426 ;; precede the opening bracket is not an identifier.
6434 )))
6435 ;; CASE 7F: we are looking at an arglist continuation line,
6436 ;; but the preceding argument is on the same line as the
6437 ;; opening paren. This case includes multi-line
6438 ;; mathematical paren groupings, but we could be on a
6439 ;; for-list continuation line. C.f. case 7A.
6454 t nil
6457 ;; CASE 7G: we are looking at just a normal arglist
6458 ;; continuation line
6461 ))
6462 ;; CASE 8: func-local multi-inheritance line
6471 ;; CASE 8A: non-hanging colon on an inher intro
6475 ;; CASE 8B: hanging colon on an inher intro
6478 ;; CASE 8C: a continued inheritance line
6482 )))
6483 ;; CASE 9: we are inside a brace-list
6492 ;; CASE 9A: In the middle of a special brace list opener.
6511 ;; CASE 9B: brace-list-close brace
6513 ;; Check special brace list closer.
6520 ;; We were between the special close char and the `)'.
6523 ;; We were before the special close char.
6527 ;; Normal brace list check.
6538 ;; Prepare for the rest of the cases below by going to the
6539 ;; token following the opening brace
6551 ;; CASE 9C: we're looking at the first line in a brace-list
6562 ;; CASE 9D: this is just a later brace-list-entry or
6563 ;; brace-entry-open
6572 ))
6573 ))))
6574 ;; CASE 10: A continued statement or top level construct.
6585 ;; This is shared with case 18.
6587 char-after-ip
6588 placeholder
6589 containing-sexp
6590 paren-state))
6591 ;; CASE 14: A case or default label
6597 lim paren-state))
6598 ;; CASE 15: any other label
6606 ;; If the surrounding statement is a switch then
6607 ;; let's analyze all labels as switch labels, so
6608 ;; that they get lined up consistently.
6609 'case-label
6613 lim paren-state))
6614 ;; CASE 16: block close brace, possibly closing the defun or
6615 ;; the class
6617 ;; From here on we have the next containing sexp in lim.
6621 ;; CASE 16E: Closing a statement block? This catches
6622 ;; cases where it's preceded by a statement keyword,
6623 ;; which works even when used in an "invalid" context,
6624 ;; e.g. a macro argument.
6628 lim paren-state))
6629 ;; CASE 16A: closing a lambda defun or an in-expression
6630 ;; block? C.f. cases 4, 7B and 17E.
6633 nil))
6635 'inline-close
6648 ;; CASE 16B: does this close an inline or a function in
6649 ;; a non-class declaration level block?
6658 ;; CASE 16F: Can be a defun-close of a function declared
6659 ;; in a statement block, e.g. in Pike or when using gcc
6660 ;; extensions, but watch out for macros followed by
6661 ;; blocks. Let it through to be handled below.
6662 ;; C.f. cases B.3 and 17G.
6664 lim
6669 ;; Look for a type or identifier followed by a
6670 ;; symbol, i.e. the start of a function declaration.
6671 ;; Doesn't work for declarations like "int *foo()
6672 ;; ..."; we'd need to refactor the more competent
6673 ;; analysis in `c-font-lock-declarations' for that.
6682 lim paren-state))
6683 ;; CASE 16C: if there an enclosing brace that hasn't
6684 ;; been narrowed out by a class, then this is a
6685 ;; block-close. C.f. case 17H.
6687 ;; If the block is preceded by a case/switch label on
6688 ;; the same line, we anchor at the first preceding label
6689 ;; at boi. The default handling in c-add-stmt-syntax is
6690 ;; really fixes it better, but we do like this to keep
6691 ;; the indentation compatible with version 5.28 and
6692 ;; earlier.
6699 ;; c-backward-to-block-anchor not necessary here; those
6700 ;; situations are handled in case 16E above.
6702 lim paren-state)))
6703 ;; CASE 16D: find out whether we're closing a top-level
6704 ;; class or a defun
6715 )))
6716 ;; CASE 17: Statement or defun catchall.
6719 ;; Back up statements until we find one that starts at boi.
6722 containing-sexp)))
6726 nil)
6730 ;; CASE 17B: continued statement
6734 containing-sexp paren-state))
6735 ;; CASE 17A: After a case/default label?
6743 'statement-case-open
6745 nil t nil containing-sexp paren-state))
6746 ;; CASE 17D: any old statement
6753 containing-sexp paren-state)
6756 ;; CASE 17I: Inside a substatement block.
6758 ;; The following tests are all based on containing-sexp.
6760 ;; From here on we have the next containing sexp in lim.
6765 lim paren-state)
6768 ;; CASE 17E: first statement in an in-expression block.
6769 ;; C.f. cases 4, 7B and 16A.
6772 nil))
6774 'defun-block-intro
6788 ;; CASE 17F: first statement in an inline, or first
6789 ;; statement in a top-level defun. we can tell this is it
6790 ;; if there are no enclosing braces that haven't been
6791 ;; narrowed out by a class (i.e. don't use bod here).
6800 ;; CASE 17G: First statement in a function declared inside
6801 ;; a normal block. This can occur in Pike and with
6802 ;; e.g. the gcc extensions, but watch out for macros
6803 ;; followed by blocks. C.f. cases B.3 and 16F.
6808 ;; Look for a type or identifier followed by a
6809 ;; symbol, i.e. the start of a function declaration.
6810 ;; Doesn't work for declarations like "int *foo()
6811 ;; ..."; we'd need to refactor the more competent
6812 ;; analysis in `c-font-lock-declarations' for that.
6821 lim paren-state))
6822 ;; CASE 17H: First statement in a block. C.f. case 16C.
6824 ;; If the block is preceded by a case/switch label on the
6825 ;; same line, we anchor at the first preceding label at
6826 ;; boi. The default handling in c-add-stmt-syntax is
6827 ;; really fixes it better, but we do like this to keep the
6828 ;; indentation compatible with version 5.28 and earlier.
6835 ;; c-backward-to-block-anchor not necessary here; those
6836 ;; situations are handled in case 17I above.
6838 lim paren-state))
6841 ))
6842 )
6843 ;; now we need to look at any modifiers
6846 ;; are we looking at a comment only line?
6850 ;; we might want to give additional offset to friends (in C++).
6855 ;; Set syntactic-relpos.
6861 nil)
6862 t))
6865 ;; Start of or a continuation of a preprocessor directive?
6880 ;; If inside a cpp expression, i.e. anywhere in a
6881 ;; cpp directive except a #define body, we only let
6882 ;; through the syntactic analysis that is internal
6883 ;; in the expression. That means the arglist
6884 ;; elements, if they are anchored inside the cpp
6885 ;; expression.
6894 ;; Inside a #define body and the syntactic analysis is
6895 ;; anchored on the start of the #define. In this case
6896 ;; we add cpp-define-intro to get the extra
6897 ;; indentation of the #define body.
6899 ;; return the syntax
6900 c-syntactic-context))))
6902 \f
6903 ;; Indentation calculation.
6906 ;; offset can be a number, a function, a variable, a list, or one of
6907 ;; the symbols + or -
6920 langelem symbol))
6934 done))
6936 ))
6939 ;; Get offset from LANGELEM which is a list beginning with the
6940 ;; syntactic symbol and followed by any analysis data it provides.
6941 ;; That data may be zero or more elements, but if at least one is
6942 ;; given then the first is the relpos (or nil). The symbol is
6943 ;; matched against `c-offsets-alist' and the offset calculated from
6944 ;; that is returned.
6954 offset
6958 ))
6961 ;; This is a compatibility wrapper for `c-calc-offset' in case
6962 ;; someone is calling it directly. It takes an old style syntactic
6963 ;; element on the form (SYMBOL . RELPOS) and converts it to the new
6964 ;; list form.
6970 ;; Calculate the syntactic indentation from a syntactic description
6971 ;; as returned by `c-guess-syntax'.
6972 ;;
6973 ;; Note that topmost-intro always has a relpos at bol, for
6974 ;; historical reasons. It's often used together with other symbols
6975 ;; that has more sane positions. Since we always use the first
6976 ;; found relpos, we rely on that these other symbols always precede
6977 ;; topmost-intro in the LANGELEMS list.
6985 ;; Got an absolute column that overrides any indentation
6986 ;; we've collected so far, but not the relative
6987 ;; indentation we might get for the nested structures
6988 ;; further down the langelems list.
6992 ;; Got a relative change of the current calculated
6993 ;; indentation.
6996 ;; Use the anchor position from the first syntactic
6997 ;; element with one.
7009 indent)))
7011 \f
7014 ;;; arch-tag: 149add18-4673-4da5-ac47-6805e4eae089
7015 ;;; cc-engine.el ends here