| blob | 3ac0ed52b741fd37443f735e583c2751f224f7cf |
1 ;;; cc-engine.el --- core syntax guessing engine for CC mode
3 ;; Copyright (C) 1985,87,92,93,94,95,96,97 Free Software Foundation, Inc.
5 ;; Authors: 1992-1997 Barry A. Warsaw
6 ;; 1987 Dave Detlefs and Stewart Clamen
7 ;; 1985 Richard M. Stallman
8 ;; Maintainer: cc-mode-help@python.org
9 ;; Created: 22-Apr-1997 (split from cc-mode.el)
10 ;; Version: 5.12
11 ;; Keywords: c languages oop
13 ;; This file is part of GNU Emacs.
15 ;; GNU Emacs is free software; you can redistribute it and/or modify
16 ;; it under the terms of the GNU General Public License as published by
17 ;; the Free Software Foundation; either version 2, or (at your option)
18 ;; any later version.
20 ;; GNU Emacs is distributed in the hope that it will be useful,
21 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
22 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 ;; GNU General Public License for more details.
25 ;; You should have received a copy of the GNU General Public License
26 ;; along with GNU Emacs; see the file COPYING. If not, write to the
27 ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
28 ;; Boston, MA 02111-1307, USA.
30 \f
31 ;; WARNING: Be *exceptionally* careful about modifications to this
32 ;; function! Much of CC Mode depends on this Doing The Right Thing.
33 ;; If you break it you will be sorry.
36 ;; move to the start of the current statement, or the previous
37 ;; statement if already at the beginning of one.
40 donep c-in-literal-cache
41 ;; KLUDGE ALERT: maybe-labelp is used to pass information
42 ;; between c-crosses-statement-barrier-p and
43 ;; c-beginning-of-statement-1. A better way should be
44 ;; implemented.
45 maybe-labelp saved
47 ;; first check for bare semicolon
52 t))
55 )
59 ;; stop at beginning of buffer
61 ;; go backwards one balanced expression, but be careful of
62 ;; unbalanced paren being reached
68 ;; skip over any unary operators, or other special
69 ;; characters appearing at front of identifier
77 donep t)))
80 ;; see if we're in a literal. if not, then this bufpos may be
81 ;; a candidate for stopping
83 ;; CASE 0: did we hit the error condition above?
85 ;; CASE 1: are we in a literal?
88 ;; CASE 2: some other kind of literal?
90 ;; CASE 3: are we looking at a conditional keyword?
105 ))))
106 ;; did we find a conditional?
109 foundp)))
110 ;; are we in the middle of an else-if clause?
119 ;; are we sitting at an else clause, that we are not a
120 ;; substatement of?
124 ;; are we sitting at the while of a do-while?
129 donep substmt-p))
130 ;; CASE 4: are we looking at a label?
132 ;; CASE 5: is this the first time we're checking?
137 ;; CASE 6: have we crossed a statement barrier?
140 ;; CASE 7: ignore labels
143 ;; with switch labels, we have to go back further
144 ;; to try to pick up the case or default
145 ;; keyword. Potential bogosity alert: we assume
146 ;; `case' or `default' is first thing on line
151 t
153 nil))
155 ;; CASE 8: ObjC or Java method def
159 ;; CASE 9: nothing special
161 ))))
163 ;; we always do want to skip over non-whitespace modifier
164 ;; characters that didn't get skipped above
187 \f
189 ;; Does buffer positions FROM to TO cross a C statement boundary?
192 crossedp)
210 crossedp))
212 \f
213 ;; Skipping of "syntactic whitespace", defined as lexical whitespace,
214 ;; C and C++ style comments, and preprocessor directives. Search no
215 ;; farther back or forward than optional LIM. If LIM is omitted,
216 ;; `beginning-of-defun' is used for backward skipping, point-max is
217 ;; used for forward skipping.
220 ;; Forward skip of syntactic whitespace for Emacs 19.
229 ;; skip preprocessor directives
233 )))))
236 ;; Backward skip over syntactic whitespace for Emacs 19.
249 )))
250 )))
252 \f
253 ;; Return `c' if in a C-style comment, `c++' if in a C++ style
254 ;; comment, `string' if in a string literal, `pound' if on a
255 ;; preprocessor line, or nil if not in a comment at all. Optional LIM
256 ;; is used as the backward limit of the search. If omitted, or nil,
257 ;; `beginning-of-defun' is used."
260 ;; Determine if point is in a C++ literal. we cache the last point
261 ;; calculated if the cache is enabled
263 c-in-literal-cache
279 ;; cache this result if the cache is enabled
282 rtn)))
284 \f
285 ;; utilities for moving and querying around syntactic elements
289 ;; Finds and records all open parens between some important point
290 ;; earlier in the file and point.
291 ;;
292 ;; if there's a state cache, return it
297 ;; go back 2 bods, but ignore any bogus positions
298 ;; returned by beginning-of-defun (i.e. open paren
299 ;; in column zero)
309 ;;(skip-chars-forward " \t}")
312 placeholder state sexp-end)
313 ;; cache last bod position
324 ;; we want to record both the start and end
325 ;; of this sexp, but we only want to record
326 ;; the last-most of any of them before here
332 state))))
334 ;; we're contained in this sexp so put pos on
335 ;; front of list
337 ;; something bad happened. check to see if we
338 ;; crossed an unbalanced close brace. if so, we
339 ;; didn't really find the right `important bufpos'
340 ;; so lets back up and try again
344 ;;(char-after (1- placeholder))
351 ;; bogus, but what can we do here?
355 pos last-bod)
360 nil))
361 state)))
364 ;; whack off any state information that appears on STATE which lies
365 ;; after the bounds of BUFPOS.
371 ;; just check the car, because in a balanced brace
372 ;; expression, it must be impossible for the corresponding
373 ;; close brace to be before point, but the open brace to be
374 ;; after.
376 nil ; whack it off
377 ;; its possible that the open brace is before bufpos, but
378 ;; the close brace is after. In that case, convert this
379 ;; to a non-cons element.
382 ;; we know that both the open and close braces are
383 ;; before bufpos, so we also know that everything else
384 ;; on state is before bufpos, so we can glom up the
385 ;; whole thing and exit.
387 state nil)))
389 nil ; whack it off
390 ;; it's before bufpos, so everything else should too
392 state nil))))
393 newstate))
396 ;; Using BUFPOS buffer position, and WHICH (must be 'open or
397 ;; 'close), hack the c-parse-state STATE and return the results.
404 state))
407 ;; 'close brace
413 ;; TBD: is this test relevant???
415 state ;on error, don't change
416 ;; watch out for balanced expr already on cdr of list
420 ))))
423 ;; Adjust all points in state that lie in the region FROM..TO by
424 ;; SHIFT amount (as would be returned by c-indent-line).
437 e))
438 state))
440 \f
442 ;; Go to the first non-whitespace after the colon that starts a
443 ;; multiple inheritance introduction. Optional LIM is the farthest
444 ;; back we should search.
457 ))
463 ;; Go to the beginning of the macro. Right now we don't support
464 ;; multi-line macros too well
468 ;; Return nil if we aren't in a method definition, otherwise the
469 ;; position of the initial [+-].
475 ))
478 ;; Return t if we are between a function's argument list closing
479 ;; paren and its opening brace. Note that the list close brace
480 ;; could be followed by a "const" specifier or a member init hanging
481 ;; colon. Optional CONTAINING is position of containing s-exp open
482 ;; brace. If not supplied, point is used as search start.
487 ;; could be looking at const specifier
492 ;; otherwise, we could be looking at a hanging member init
493 ;; colon
500 nil
502 )
504 ;; check if we are looking at a method def
511 ;; or a class category
515 )))))
516 )))
518 ;; defuns to look backwards for things
520 ;; Move to the start of the last "unbalanced" do expression.
521 ;; Optional LIM is the farthest back to search. If none is found,
522 ;; nil is returned and point is left unchanged, otherwise t is returned.
527 foundp)
529 ;; we protect this call because trying to execute this when the
530 ;; while is not associated with a do will throw an error
549 foundp))
552 ;; Move to the start of the last "unbalanced" if and return t. If
553 ;; none is found, and we are looking at an if clause, nil is
554 ;; returned. If none is found and we are looking at an else clause,
555 ;; an error is thrown.
576 ;; check for else if... skip over
580 nil
586 ))
587 t)))
590 ;; skip forward over conditional at point, including any predicate
591 ;; statements in parentheses. No error checking is performed.
593 ;; else if()
595 ;; do, else, try, finally
597 ;; for, if, while, switch, catch, synchronized
601 ;; skip forward over case/default bodies, with optional maximal
602 ;; limit. if no next case body is found, nil is returned and point
603 ;; is not moved
606 donep foundp bufpos
609 ;; search until we've passed the limit, or we've found our match
613 ;; see if we can find a case statement, not in a literal
618 ;; if we crossed into a balanced sexp, we know the case is
619 ;; not part of our switch statement, so just bound over the
620 ;; sexp and keep looking.
627 foundp t))))
630 foundp))
633 ;; search for the containing class, returning a 2 element vector if
634 ;; found. aref 0 contains the bufpos of the class key, and aref 1
635 ;; contains the bufpos of the open brace.
637 ;; no brace-state means we cannot be inside a class
638 nil
640 search-start search-end)
642 ;; a cons cell in the first element means that there is some
643 ;; balanced sexp before the current bufpos. this we can
644 ;; ignore. the nth 1 and nth 2 elements define for us the
645 ;; search boundaries
648 ;; if the car was not a cons cell then nth 0 and nth 1 define
649 ;; for us the search boundaries
652 ;; search-end cannot be a cons cell
655 ;; if search-end is nil, or if the search-end character isn't an
656 ;; open brace, we are definitely not in a class
660 nil
661 ;; now, we need to look more closely at search-start. if
662 ;; search-start is nil, then our start boundary is really
663 ;; point-min.
666 ;; if search-start is a cons cell, then we can start
667 ;; searching from the end of the balanced sexp just ahead of
668 ;; us
671 ;; now we can do a quick regexp search from search-start to
672 ;; search-end and see if we can find a class key. watch for
673 ;; class like strings in literals
678 foundp class match-end)
687 nil ; its in a comment or string, ignore
692 ;; check for embedded keywords
698 ;; make sure we're really looking at the start of a
699 ;; class definition, and not a forward decl, return
700 ;; arg, template arg list, or an ObjC or Java method.
704 ;; Its impossible to define a regexp for this, and
705 ;; nearly so to do it programmatically.
706 ;;
707 ;; ; picks up forward decls
708 ;; = picks up init lists
709 ;; ) picks up return types
710 ;; > picks up templates, but remember that we can
711 ;; inherit from templates!
713 ;; try to see if we found the `class' keyword
714 ;; inside a template arg list
722 )))
723 foundp))
724 )))))
727 ;; return the buffer position of the beginning of the brace list
728 ;; statement if we're inside a brace list, otherwise return nil.
729 ;; CONTAINING-SEXP is the buffer pos of the innermost containing
730 ;; paren. BRACE-STATE is the remainder of the state of enclosing braces
731 ;;
732 ;; N.B.: This algorithm can potentially get confused by cpp macros
733 ;; places in inconvenient locations. Its a trade-off we make for
734 ;; speed.
736 ;; this will pick up enum lists
746 ;; this will pick up array/aggregate init lists, even if they are nested.
750 containing-sexp)
754 ;; see if significant character just before brace is an equal
764 ;; lets see if we're nested. find the most nested
765 ;; containing brace
768 ;; we've hit the beginning of the aggregate list
771 ))
772 bufpos))
773 ))
775 \f
777 ;; return the bufpos of the most enclosing brace that hasn't been
778 ;; narrowed out by any enclosing class, or nil if none was found
788 enclosingp))
791 ;; return the bufpos of the least (highest) enclosing brace that
792 ;; hasn't been narrowed out by any enclosing class, or nil if none
793 ;; was found.
797 ;; return the closest known safe position higher up than point
807 safepos))
810 ;; narrow the buffer so that the enclosing class is hidden
818 ;; if point is now left of the class opening brace, we're
819 ;; hosed, so try a different tact
825 ;; end point is the end of the current line
829 ;; return the class vector
830 inclass-p))
832 \f
833 ;; This function implements the main decision tree for determining the
834 ;; syntactic analysis of the current line of code. Yes, it's huge and
835 ;; bloated!
846 c-method-key
848 literal containing-sexp char-before-ip char-after-ip lim
849 syntax placeholder c-in-literal-cache inswitch-p
850 injava-inher
851 ;; narrow out any enclosing class or extern "C" block
859 )
861 ;; get the buffer position of the most nested opening brace,
862 ;; if there is one, and it hasn't been narrowed out
873 ;; if cdr == point, then containing sexp is the brace
874 ;; that opens the sexp we close
877 ;; otherwise, ignore this element
879 ;; ignore the bufpos if its been narrowed out by the
880 ;; containing class
884 ;; set the limit on the farthest back we need to search
888 nil)
891 ;; cache char before and after indent point, and move point to
892 ;; the most likely position to perform the majority of tests
901 ;; are we in a literal?
904 ;; now figure out syntactic qualities of the current line
906 ;; CASE 1: in a string.
909 ;; CASE 2: in a C or C++ style comment.
911 ;; we need to catch multi-paragraph C comments
915 ;; CASE 3: in a cpp preprocessor
919 ;; CASE 4: in an objective-c method intro
922 ;; CASE 5: Line is at top level.
925 ;; CASE 5A: we are looking at a defun, class, or
926 ;; inline-inclass method opening brace
929 ;; CASE 5A.1: extern declaration
942 ;; CASE 5A.2: we are looking at a class opening brace
946 ;; TBD: watch out! there could be a bogus
947 ;; c-state-cache in place when we get here. we have
948 ;; to go through much chicanery to ignore the cache.
949 ;; But of course, there may not be! BLECH! BOGUS!
958 )))
961 ))
963 ;; CASE 5A.3: brace list open
966 ;; c-b-o-s could have left us at point-min
978 )))
980 ;; CASE 5A.4: inline defun open
984 ;; CASE 5A.5: ordinary defun open
988 )))
989 ;; CASE 5B: first K&R arg decl or member init
992 ;; CASE 5B.1: a member init
995 ;; this line should be indented relative to the beginning
996 ;; of indentation for the topmost-intro line that contains
997 ;; the prototype's open paren
998 ;; TBD: is the following redundant?
1002 ;; TBD: is the preceding redundant?
1016 ;; we don't need to add any class offset since this
1017 ;; should be relative to the ctor's indentation
1018 )
1019 ;; CASE 5B.2: K&R arg decl intro
1023 ;; CASE 5B.3: Nether region after a C++ or Java func
1024 ;; decl, which could include a `throws' declaration.
1028 )))
1029 ;; CASE 5C: inheritance line. could be first inheritance
1030 ;; line, or continuation of a multiple inheritance
1033 ;; watch out for scope operator
1038 )))
1047 ;; for Java
1052 cont done)
1057 done t))
1061 )
1063 injava-inher)
1066 ))
1068 ;; CASE 5C.1: non-hanging colon on an inher intro
1072 ;; don't add inclass symbol since relative point already
1073 ;; contains any class offset
1074 )
1075 ;; CASE 5C.2: hanging colon on an inher intro
1079 ;; CASE 5C.3: in a Java implements/extends
1093 )))
1094 ;; CASE 5C.4: a continued inheritance line
1098 ;; don't add inclass symbol since relative point already
1099 ;; contains any class offset
1100 )))
1101 ;; CASE 5D: this could be a top-level compound statement or a
1102 ;; member init list continuation
1108 ;; this will catch member inits with multiple
1109 ;; line arglists
1114 ;; now continue checking
1118 ;; CASE 5D.1: hanging member init colon, but watch out
1119 ;; for bogus matches on access specifiers inside classes.
1128 ;; we do not need to add class offset since relative
1129 ;; point is the member init above us
1130 )
1131 ;; CASE 5D.2: non-hanging member init colon
1137 ;; CASE 5D.3: perhaps a multiple inheritance line?
1140 ;; CASE 5D.4: perhaps a template list continuation?
1143 ;; not sure if this is the right test, but it should
1144 ;; be fast and mostly accurate.
1147 ;; we can probably indent it just like and arglist-cont
1149 ;; CASE 5D.5: perhaps a top-level statement-cont
1152 ;; skip over any access-specifiers
1156 ;; skip over comments, whitespace
1159 ))
1160 ;; CASE 5E: we are looking at a access specifier
1162 c-access-key
1166 ;; CASE 5F: extern-lang-close?
1170 ;; CASE 5G: we are looking at the brace which closes the
1171 ;; enclosing nested class decl
1183 ))))
1188 ;; CASE 5H: we could be looking at subsequent knr-argdecls
1190 ;; here we essentially use the hack that is used in
1191 ;; Emacs' c-mode.el to limit how far back we should
1192 ;; look. The assumption is made that argdecls are
1193 ;; indented at least one space and that function
1194 ;; headers are not indented.
1213 ;; or a class category
1217 )))))
1218 ))
1224 ;; CASE 5I: we are at the topmost level, make sure we skip
1225 ;; back past any access specifiers
1229 c-access-key
1238 ;; real beginning-of-line could be narrowed out due to
1239 ;; enclosure in a class block
1249 ))
1250 ;; CASE 5J: we are at an ObjC or Java method definition
1251 ;; continuation line.
1258 ;; CASE 5K: we are at a topmost continuation line
1264 ;; CASE 6: line is an expression, not a statement. Most
1265 ;; likely we are either in a function prototype or a function
1266 ;; call argument list
1270 ;; CASE 6A: we are looking at the arglist closing paren
1275 ;; CASE 6B: we are looking at the first argument in an empty
1276 ;; argument list. Use arglist-close if we're actually
1277 ;; looking at a close paren or bracket.
1281 ;; CASE 6C: we are inside a conditional test clause. treat
1282 ;; these things as statements
1293 ))
1294 ;; CASE 6D: maybe a continued method call. This is the case
1295 ;; when we are inside a [] bracketed exp, and what precede
1296 ;; the opening bracket is not an identifier.
1304 )))
1305 ;; CASE 6E: we are looking at an arglist continuation line,
1306 ;; but the preceding argument is on the same line as the
1307 ;; opening paren. This case includes multi-line
1308 ;; mathematical paren groupings, but we could be on a
1309 ;; for-list continuation line
1320 ;; CASE 6F: we are looking at just a normal arglist
1321 ;; continuation line
1326 ))
1327 ;; CASE 7: func-local multi-inheritance line
1336 ;; CASE 7A: non-hanging colon on an inher intro
1340 ;; CASE 7B: hanging colon on an inher intro
1343 ;; CASE 7C: a continued inheritance line
1347 )))
1348 ;; CASE 8: we are inside a brace-list
1351 ;; CASE 8A: brace-list-close brace
1355 t))
1358 ;; CASE 8B: we're looking at the first line in a brace-list
1365 )
1366 ;;)) ; end CASE 8B
1367 ;; CASE 8C: this is just a later brace-list-entry
1375 ;; CASE 9: A continued statement
1396 nil))))
1398 ;; CASE 9A: substatement
1405 ;; CASE 9B: open braces for class or brace-lists
1408 ;; CASE 9B.1: class-open
1415 ))
1417 ;; CASE 9B.2: brace-list-open
1423 ;; CASE 9B.3: catch-all for unknown construct.
1425 ;; Can and should I add an extensibility hook here?
1426 ;; Something like c-recognize-hook so support for
1427 ;; unknown constructs could be added. It's probably a
1428 ;; losing proposition, so I dunno.
1432 ))
1433 ;; CASE 9C: iostream insertion or extraction operator
1440 ;; if we ended up at indent-point, then the first
1441 ;; streamop is on a separate line. Indent the line like
1442 ;; a statement-cont instead
1447 ;; CASE 9D: continued statement. find the accurate
1448 ;; beginning of statement or substatement
1451 ;; KLUDGE ALERT! c-beginning-of-statement-1 can leave
1452 ;; us before the lim we're passing in. It should be
1453 ;; fixed, but I'm worried about side-effects at this
1454 ;; late date. Fix for v5.
1459 )))
1460 ;; CASE 10: an else clause?
1464 ;; CASE 11: Statement. But what kind? Lets see if its a
1465 ;; while closure of a do/while construct
1474 ))
1476 ;; CASE 12: A case or default label
1479 ;; check for hanging braces
1483 ;; CASE 13: any other label
1487 ;; CASE 14: block close brace, possibly closing the defun or
1488 ;; the class
1497 ;; CASE 14A: does this close an inline?
1501 ;; inextern-p in higher level let*
1508 ;; CASE 14B: if there an enclosing brace that hasn't
1509 ;; been narrowed out by a class, then this is a
1510 ;; block-close
1514 ;; CASE 14C: find out whether we're closing a top-level
1515 ;; class or a defun
1523 )))
1524 ;; CASE 15: statement catchall
1526 ;; we know its a statement, but we need to find out if it is
1527 ;; the first statement in a block
1531 ;; now skip forward past any case/default clauses we might find.
1536 ;; we want to ignore non-case labels when skipping forward
1541 ;; CASE 15A: we are inside a case/default clause inside a
1542 ;; switch statement. find out if we are at the statement
1543 ;; just after the case/default label.
1556 ;; CASE 15B: continued statement
1559 ;; CASE 15C: a question/colon construct? But make sure
1560 ;; what came before was not a label, and what comes after
1561 ;; is not a globally scoped function call!
1572 ;; watch out for scope operator
1575 ;; CASE 15D: any old statement
1578 relpos done)
1581 ;; It is possible we're on the brace that opens a nested
1582 ;; function.
1605 ;; CASE 15E: first statement in an inline, or first
1606 ;; statement in a top-level defun. we can tell this is it
1607 ;; if there are no enclosing braces that haven't been
1608 ;; narrowed out by a class (i.e. don't use bod here!)
1616 ;; if not at boi, then defun-opening braces are hung on
1617 ;; right side, so we need a different relpos
1623 ;; looking at a Java throws clause following a
1624 ;; method's parameter list
1626 ))
1628 ;; CASE 15F: first statement in a block
1637 ))
1638 )
1640 ;; now we need to look at any modifiers
1643 ;; are we looking at a comment only line?
1646 ;; we might want to give additional offset to friends (in C++).
1650 ;; return the syntax
1651 syntax))))
1653 \f
1656 nil
1658 c-parsing-error)
1660 c-parsing-error)
1662 ;; indent via syntactic language elements
1664 ;; indent the current line as C/C++/ObjC code. Optional SYNTAX is the
1665 ;; syntactic information for the current line. Returns the amount of
1666 ;; indentation change
1675 nil
1681 ;; If initial point was within line's indentation, position after
1682 ;; the indentation. Else stay at same point in text.
1685 )
1687 shift-amt))
1690 "Show syntactic information for current line.
1691 With universal argument, inserts the analysis as a comment on that line."
1699 ))
1702 \f
1704 ;;; cc-engine.el ends here