;;; cc-engine.el --- core syntax guessing engine for CC mode
-;; Copyright (C) 1985, 1987, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-;; 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
-;; Free Software Foundation, Inc.
+;; Copyright (C) 1985, 1987, 1992-2011 Free Software Foundation, Inc.
;; Authors: 2001- Alan Mackenzie
;; 1998- Martin Stjernholm
;; The last position where a label is possible provided the
;; statement started there. It's nil as long as no invalid
;; label content has been found (according to
- ;; `c-nonlabel-token-key'. It's `start' if no valid label
+ ;; `c-nonlabel-token-key'). It's `start' if no valid label
;; content was found in the label. Note that we might still
;; regard it a label if it starts with `c-label-kwds'.
label-good-pos
+ ;; Putative positions of the components of a bitfield declaration,
+ ;; e.g. "int foo : NUM_FOO_BITS ;"
+ bitfield-type-pos bitfield-id-pos bitfield-size-pos
;; Symbol just scanned back over (e.g. 'while or 'boundary).
;; See above.
sym
;; Record this as the first token if not starting inside it.
(setq tok start))
- ;; The following while loop goes back one sexp (balanced parens,
- ;; etc. with contents, or symbol or suchlike) each iteration. This
- ;; movement is accomplished with a call to scan-sexps approx 130 lines
- ;; below.
+
+ ;; The following while loop goes back one sexp (balanced parens,
+ ;; etc. with contents, or symbol or suchlike) each iteration. This
+ ;; movement is accomplished with a call to c-backward-sexp approx 170
+ ;; lines below.
+ ;;
+ ;; The loop is exited only by throwing nil to the (catch 'loop ...):
+ ;; 1. On reaching the start of a macro;
+ ;; 2. On having passed a stmt boundary with the PDA stack empty;
+ ;; 3. On reaching the start of an Objective C method def;
+ ;; 4. From macro `c-bos-pop-state'; when the stack is empty;
+ ;; 5. From macro `c-bos-pop-state-and-retry' when the stack is empty.
(while
(catch 'loop ;; Throw nil to break, non-nil to continue.
(cond
+ ;; Are we in a macro, just after the opening #?
((save-excursion
(and macro-start ; Always NIL for AWK.
(progn (skip-chars-backward " \t")
(setq pos saved
ret 'macro
ignore-labels t))
- (throw 'loop nil))
+ (throw 'loop nil)) ; 1. Start of macro.
;; Do a round through the automaton if we've just passed a
;; statement boundary or passed a "while"-like token.
(setq sym (intern (match-string 1)))))
(when (and (< pos start) (null stack))
- (throw 'loop nil))
+ (throw 'loop nil)) ; 2. Statement boundary.
;; The PDA state handling.
;;
;; HERE IS THE SINGLE PLACE INSIDE THE PDA LOOP WHERE WE MOVE
;; BACKWARDS THROUGH THE SOURCE.
- ;; This is typically fast with the caching done by
- ;; c-(backward|forward)-sws.
(c-backward-syntactic-ws)
-
(let ((before-sws-pos (point))
- ;; Set as long as we have to continue jumping by sexps.
- ;; It's the position to use as end in the next round.
- sexp-loop-continue-pos
;; The end position of the area to search for statement
;; barriers in this round.
- (sexp-loop-end-pos pos))
+ (maybe-after-boundary-pos pos))
- ;; The following while goes back one sexp per iteration.
+ ;; Go back over exactly one logical sexp, taking proper
+ ;; account of macros and escaped EOLs.
(while
(progn
(unless (c-safe (c-backward-sexp) t)
;; stack won't be empty the code below will report a
;; suitable error.
(throw 'loop nil))
-
- ;; Check if the sexp movement crossed a statement or
- ;; declaration boundary. But first modify the point
- ;; so that `c-crosses-statement-barrier-p' only looks
- ;; at the non-sexp chars following the sexp.
- (save-excursion
- (when (setq
- boundary-pos
- (cond
- ((if macro-start
- nil
- (save-excursion
- (when (c-beginning-of-macro)
- ;; Set continuation position in case
- ;; `c-crosses-statement-barrier-p'
- ;; doesn't detect anything below.
- (setq sexp-loop-continue-pos (point)))))
- ;; If the sexp movement took us into a
- ;; macro then there were only some non-sexp
- ;; chars after it. Skip out of the macro
- ;; to analyze them but not the non-sexp
- ;; chars that might be inside the macro.
- (c-end-of-macro)
- (c-crosses-statement-barrier-p
- (point) sexp-loop-end-pos))
-
- ((and
- (eq (char-after) ?{)
- (not (c-looking-at-inexpr-block lim nil t)))
- ;; Passed a block sexp. That's a boundary
- ;; alright.
- (point))
-
- ((looking-at "\\s\(")
- ;; Passed some other paren. Only analyze
- ;; the non-sexp chars after it.
- (goto-char (1+ (c-down-list-backward
- before-sws-pos)))
- ;; We're at a valid token start position
- ;; (outside the `save-excursion') if
- ;; `c-crosses-statement-barrier-p' failed.
- (c-crosses-statement-barrier-p
- (point) sexp-loop-end-pos))
-
- (t
- ;; Passed a symbol sexp or line
- ;; continuation. It doesn't matter that
- ;; it's included in the analyzed region.
- (if (c-crosses-statement-barrier-p
- (point) sexp-loop-end-pos)
- t
- ;; If it was a line continuation then we
- ;; have to continue looping.
- (if (looking-at "\\\\$")
- (setq sexp-loop-continue-pos (point)))
- nil))))
-
- (setq pptok ptok
- ptok tok
- tok boundary-pos
- sym 'boundary)
- ;; Like a C "continue". Analyze the next sexp.
- (throw 'loop t)))
-
- sexp-loop-continue-pos) ; End of "go back a sexp" loop condition.
- (goto-char sexp-loop-continue-pos)
- (setq sexp-loop-end-pos sexp-loop-continue-pos
- sexp-loop-continue-pos nil))))
+ (cond
+ ;; Have we moved into a macro?
+ ((and (not macro-start)
+ (c-beginning-of-macro))
+ ;; Have we crossed a statement boundary? If not,
+ ;; keep going back until we find one or a "real" sexp.
+ (and
+ (save-excursion
+ (c-end-of-macro)
+ (not (c-crosses-statement-barrier-p
+ (point) maybe-after-boundary-pos)))
+ (setq maybe-after-boundary-pos (point))))
+ ;; Have we just gone back over an escaped NL? This
+ ;; doesn't count as a sexp.
+ ((looking-at "\\\\$")))))
+
+ ;; Have we crossed a statement boundary?
+ (setq boundary-pos
+ (cond
+ ;; Are we at a macro beginning?
+ ((and (not macro-start)
+ c-opt-cpp-prefix
+ (looking-at c-opt-cpp-prefix))
+ (save-excursion
+ (c-end-of-macro)
+ (c-crosses-statement-barrier-p
+ (point) maybe-after-boundary-pos)))
+ ;; Just gone back over a brace block?
+ ((and
+ (eq (char-after) ?{)
+ (not (c-looking-at-inexpr-block lim nil t)))
+ (save-excursion
+ (c-forward-sexp) (point)))
+ ;; Just gone back over some paren block?
+ ((looking-at "\\s\(")
+ (save-excursion
+ (goto-char (1+ (c-down-list-backward
+ before-sws-pos)))
+ (c-crosses-statement-barrier-p
+ (point) maybe-after-boundary-pos)))
+ ;; Just gone back over an ordinary symbol of some sort?
+ (t (c-crosses-statement-barrier-p
+ (point) maybe-after-boundary-pos))))
+
+ (when boundary-pos
+ (setq pptok ptok
+ ptok tok
+ tok boundary-pos
+ sym 'boundary)
+ ;; Like a C "continue". Analyze the next sexp.
+ (throw 'loop t))))
;; ObjC method def?
(when (and c-opt-method-key
(setq saved (c-in-method-def-p)))
(setq pos saved
ignore-labels t) ; Avoid the label check on exit.
- (throw 'loop nil))
+ (throw 'loop nil)) ; 3. ObjC method def.
+
+ ;; Might we have a bitfield declaration, "<type> <id> : <size>"?
+ (if c-has-bitfields
+ (cond
+ ;; The : <size> and <id> fields?
+ ((and (numberp c-maybe-labelp)
+ (not bitfield-size-pos)
+ (save-excursion
+ (goto-char (or tok start))
+ (not (looking-at c-keywords-regexp)))
+ (not (looking-at c-keywords-regexp))
+ (not (c-punctuation-in (point) c-maybe-labelp)))
+ (setq bitfield-size-pos (or tok start)
+ bitfield-id-pos (point)))
+ ;; The <type> field?
+ ((and bitfield-id-pos
+ (not bitfield-type-pos))
+ (if (and (looking-at c-symbol-key) ; Can only be an integer type. :-)
+ (not (looking-at c-not-primitive-type-keywords-regexp))
+ (not (c-punctuation-in (point) tok)))
+ (setq bitfield-type-pos (point))
+ (setq bitfield-size-pos nil
+ bitfield-id-pos nil)))))
;; Handle labels.
(unless (eq ignore-labels t)
;; (including a case label) or something like C++'s "public:"?
;; A case label might use an expression rather than a token.
(setq after-case:-pos (or tok start))
- (if (looking-at c-nonlabel-token-key) ; e.g. "while" or "'a'"
+ (if (or (looking-at c-nonlabel-token-key) ; e.g. "while" or "'a'"
+ ;; Catch C++'s inheritance construct "class foo : bar".
+ (save-excursion
+ (and
+ (c-safe (c-backward-sexp) t)
+ (looking-at c-nonlabel-token-2-key))))
(setq c-maybe-labelp nil)
(if after-labels-pos ; Have we already encountered a label?
(if (not last-label-pos)
pptok ptok
ptok tok
tok (point)
- pos tok))) ; Not nil (for the while loop).
+ pos tok) ; always non-nil
+ ) ; end of (catch loop ....)
+ ) ; end of sexp-at-a-time (while ....)
;; If the stack isn't empty there might be errors to report.
(while stack
(eq c-maybe-labelp t)
(not (eq ret 'beginning))
after-labels-pos
+ (not bitfield-type-pos) ; Bitfields take precedence over labels.
(or (not label-good-pos)
(<= label-good-pos pos)
(progn
(goto-char pos)
ret)))
+(defun c-punctuation-in (from to)
+ "Return non-nil if there is a non-comment non-macro punctuation character
+between FROM and TO. FROM must not be in a string or comment. The returned
+value is the position of the first such character."
+ (save-excursion
+ (goto-char from)
+ (let ((pos (point)))
+ (while (progn (skip-chars-forward c-symbol-chars to)
+ (c-forward-syntactic-ws to)
+ (> (point) pos))
+ (setq pos (point))))
+ (and (< (point) to) (point))))
+
(defun c-crosses-statement-barrier-p (from to)
"Return non-nil if buffer positions FROM to TO cross one or more
statement or declaration boundaries. The returned value is actually
Note that this function might do hidden buffer changes. See the
comment at the start of cc-engine.el for more info."
- (let ((skip-chars c-stmt-delim-chars)
- lit-range)
- (save-excursion
- (catch 'done
- (goto-char from)
- (while (progn (skip-chars-forward skip-chars to)
- (< (point) to))
- (cond
- ((setq lit-range (c-literal-limits from)) ; Have we landed in a string/comment?
- (goto-char (cdr lit-range)))
- ((eq (char-after) ?:)
- (forward-char)
- (if (and (eq (char-after) ?:)
- (< (point) to))
- ;; Ignore scope operators.
- (forward-char)
- (setq c-maybe-labelp (1- (point)))))
- ((eq (char-after) ??)
- ;; A question mark. Can't be a label, so stop
- ;; looking for more : and ?.
- (setq c-maybe-labelp nil
- skip-chars (substring c-stmt-delim-chars 0 -2)))
- ((memq (char-after) '(?# ?\n ?\r)) ; A virtual semicolon?
- (if (and (eq (char-before) ?\\) (memq (char-after) '(?\n ?\r)))
- (backward-char))
- (skip-chars-backward " \t" from)
- (if (c-at-vsemi-p)
- (throw 'done (point))
- (forward-line)))
- (t (throw 'done (point)))))
- ;; In trailing space after an as yet undetected virtual semicolon?
- (c-backward-syntactic-ws from)
- (if (and (< (point) to)
- (c-at-vsemi-p))
- (point)
- nil)))))
+ (let* ((skip-chars
+ ;; If the current language has CPP macros, insert # into skip-chars.
+ (if c-opt-cpp-symbol
+ (concat (substring c-stmt-delim-chars 0 1) ; "^"
+ c-opt-cpp-symbol ; usually "#"
+ (substring c-stmt-delim-chars 1)) ; e.g. ";{}?:"
+ c-stmt-delim-chars))
+ (non-skip-list
+ (append (substring skip-chars 1) nil)) ; e.g. (?# ?\; ?{ ?} ?? ?:)
+ lit-range vsemi-pos)
+ (save-restriction
+ (widen)
+ (save-excursion
+ (catch 'done
+ (goto-char from)
+ (while (progn (skip-chars-forward
+ skip-chars
+ (min to (c-point 'bonl)))
+ (< (point) to))
+ (cond
+ ;; Virtual semicolon?
+ ((and (bolp)
+ (save-excursion
+ (progn
+ (if (setq lit-range (c-literal-limits from)) ; Have we landed in a string/comment?
+ (goto-char (car lit-range)))
+ (c-backward-syntactic-ws) ; ? put a limit here, maybe?
+ (setq vsemi-pos (point))
+ (c-at-vsemi-p))))
+ (throw 'done vsemi-pos))
+ ;; In a string/comment?
+ ((setq lit-range (c-literal-limits))
+ (goto-char (cdr lit-range)))
+ ((eq (char-after) ?:)
+ (forward-char)
+ (if (and (eq (char-after) ?:)
+ (< (point) to))
+ ;; Ignore scope operators.
+ (forward-char)
+ (setq c-maybe-labelp (1- (point)))))
+ ((eq (char-after) ??)
+ ;; A question mark. Can't be a label, so stop
+ ;; looking for more : and ?.
+ (setq c-maybe-labelp nil
+ skip-chars (substring c-stmt-delim-chars 0 -2)))
+ ;; At a CPP construct?
+ ((and c-opt-cpp-symbol (looking-at c-opt-cpp-symbol)
+ (save-excursion
+ (forward-line 0)
+ (looking-at c-opt-cpp-prefix)))
+ (c-end-of-macro))
+ ((memq (char-after) non-skip-list)
+ (throw 'done (point)))))
+ ;; In trailing space after an as yet undetected virtual semicolon?
+ (c-backward-syntactic-ws from)
+ (if (and (< (point) to)
+ (c-at-vsemi-p))
+ (point)
+ nil))))))
(defun c-at-statement-start-p ()
"Return non-nil if the point is at the first token in a statement
;; same line.
(re-search-forward "\\=\\s *[\n\r]" start t)
- (if (if (forward-comment -1)
+ (if (if (let (open-paren-in-column-0-is-defun-start) (forward-comment -1))
(if (eolp)
;; If forward-comment above succeeded and we're at eol
;; then the newline we moved over above didn't end a
;; line comment, so we give it another go.
- (forward-comment -1)
+ (let (open-paren-in-column-0-is-defun-start)
+ (forward-comment -1))
t))
;; Emacs <= 20 and XEmacs move back over the closer of a
;; return t when moving backwards at bob.
(not (bobp))
- (if (forward-comment -1)
+ (if (let (open-paren-in-column-0-is-defun-start)
+ (forward-comment -1))
(if (looking-at "\\*/")
;; Emacs <= 20 and XEmacs move back over the
;; closer of a block comment that lacks an opener.
rung-is-marked simple-ws-beg cmt-skip-pos)
;; Skip simple horizontal ws and do a quick check on the preceding
- ;; character to see if it's anying that can't end syntactic ws, so we can
+ ;; character to see if it's anything that can't end syntactic ws, so we can
;; bail out early in the majority of cases when there just are a few ws
;; chars. Newlines are complicated in the backward direction, so we can't
;; skip over them.
(defconst c-state-cache-too-far 5000)
;; A maximum comfortable scanning distance, e.g. between
;; `c-state-cache-good-pos' and "HERE" (where we call c-parse-state). When
-;; this distance is exceeded, we take "emergency meausures", e.g. by clearing
+;; this distance is exceeded, we take "emergency measures", e.g. by clearing
;; the cache and starting again from point-min or a beginning of defun. This
;; value can be tuned for efficiency or set to a lower value for testing.
(defvar c-state-nonlit-pos-cache nil)
(make-variable-buffer-local 'c-state-nonlit-pos-cache)
-;; A list of buffer positions which are known not to be in a literal. This is
-;; ordered with higher positions at the front of the list. Only those which
-;; are less than `c-state-nonlit-pos-cache-limit' are valid.
+;; A list of buffer positions which are known not to be in a literal or a cpp
+;; construct. This is ordered with higher positions at the front of the list.
+;; Only those which are less than `c-state-nonlit-pos-cache-limit' are valid.
(defvar c-state-nonlit-pos-cache-limit 1)
(make-variable-buffer-local 'c-state-nonlit-pos-cache-limit)
;; This function is almost the same as `c-literal-limits'. It differs in
;; that it is a lower level function, and that it rigourously follows the
;; syntax from BOB, whereas `c-literal-limits' uses a "local" safe position.
+ ;;
+ ;; NOTE: This function manipulates `c-state-nonlit-pos-cache'. This cache
+ ;; MAY NOT contain any positions within macros, since macros are frequently
+ ;; turned into comments by use of the `c-cpp-delimiter' category properties.
+ ;; We cannot rely on this mechanism whilst determining a cache pos since
+ ;; this function is also called from outwith `c-parse-state'.
(save-restriction
(widen)
(save-excursion
here)
(setq lit (c-state-pp-to-literal pos npos))
(setq pos (or (cdr lit) npos)) ; end of literal containing npos.
+ (goto-char pos)
+ (when (and (c-beginning-of-macro) (/= (point) pos))
+ (c-syntactic-end-of-macro)
+ (or (eobp) (forward-char))
+ (setq pos (point)))
(setq c-state-nonlit-pos-cache (cons pos c-state-nonlit-pos-cache)))
(if (> pos c-state-nonlit-pos-cache-limit)
pos))
(defsubst c-state-cache-non-literal-place (pos state)
- ;; Return a position outside of a string/comment at or before POS.
+ ;; Return a position outside of a string/comment/macro at or before POS.
;; STATE is the parse-partial-sexp state at POS.
- (if (or (nth 3 state) ; in a string?
- (nth 4 state)) ; in a comment?
- (nth 8 state)
- pos))
-
+ (let ((res (if (or (nth 3 state) ; in a string?
+ (nth 4 state)) ; in a comment?
+ (nth 8 state)
+ pos)))
+ (save-excursion
+ (goto-char res)
+ (if (c-beginning-of-macro)
+ (point)
+ res))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Stuff to do with point-min, and coping with any literal there.
;; of fruitless backward scans.
(defvar c-state-brace-pair-desert nil)
(make-variable-buffer-local 'c-state-brace-pair-desert)
-;; Used only in `c-append-lower-brace-pair-to-state-cache'. It is set when an
+;; Used only in `c-append-lower-brace-pair-to-state-cache'. It is set when
;; that defun has searched backwards for a brace pair and not found one. Its
;; value is either nil or a cons (PA . FROM), where PA is the position of the
;; enclosing opening paren/brace/bracket which bounds the backwards search (or
;; `c-parse-state', or nil.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Defuns which analyse the buffer, yet don't change `c-state-cache'.
+;; Defuns which analyze the buffer, yet don't change `c-state-cache'.
(defun c-get-fallback-scan-pos (here)
;; Return a start position for building `c-state-cache' from
;; scratch. This will be at the top level, 2 defuns back.
;;
;; If there aren't enough opening paren/brace/brackets, return the position
;; of the outermost one found, or HERE- if there are none. If there are no
- ;; closeing p/b/bs between HERE+ and TOP, return HERE-. HERE-/+ and TOP
+ ;; closing p/b/bs between HERE+ and TOP, return HERE-. HERE-/+ and TOP
;; must not be inside literals. Only the accessible portion of the buffer
;; will be scanned.
(defun c-parse-state-get-strategy (here good-pos)
;; Determine the scanning strategy for adjusting `c-parse-state', attempting
- ;; to minimise the amount of scanning. HERE is the pertinent position in
+ ;; to minimize the amount of scanning. HERE is the pertinent position in
;; the buffer, GOOD-POS is a position where `c-state-cache' (possibly with
;; its head trimmed) is known to be good, or nil if there is no such
;; position.
(<= from (cdr c-state-brace-pair-desert)))
;; Only search what we absolutely need to:
(if (and c-state-brace-pair-desert
- (> from (cdr c-state-brace-pair-desert)))
+ (eq cache-pos (car c-state-brace-pair-desert)))
(narrow-to-region (cdr c-state-brace-pair-desert) (point-max)))
;; In the next pair of nested loops, the inner one moves back past a
c-state-cache)))
;; N.B. This defsubst codes one method for the simple, normal case,
;; and a more sophisticated, slower way for the general case. Don't
- ;; eliminate this defsubst - it's a speed optimisation.
+ ;; eliminate this defsubst - it's a speed optimization.
(c-append-lower-brace-pair-to-state-cache (1- bra+1)))))
(defun c-append-to-state-cache (from)
;;
;; This function must only be called only when (> `c-state-cache-good-pos'
;; HERE). Usually the gap between CACHE-POS and HERE is large. It is thus
- ;; optimised to eliminate (or minimise) scanning between these two
+ ;; optimized to eliminate (or minimize) scanning between these two
;; positions.
;;
;; Return a three element list (GOOD-POS SCAN-BACK-POS FWD-FLAG), where:
; or `here' itself.
here- here+ ; start/end of macro around HERE, or HERE
(here-bol (c-point 'bol here))
- (too-far-back (max (- here c-state-cache-too-far) 1)))
+ (too-far-back (max (- here c-state-cache-too-far) (point-min))))
;; Remove completely irrelevant entries from `c-state-cache'.
(while (and c-state-cache
c-state-old-cpp-end nil)
(c-state-mark-point-min-literal))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Debugging routines to dump `c-state-cache' in a "replayable" form.
+;; (defmacro c-sc-de (elt) ; "c-state-cache-dump-element"
+;; `(format ,(concat "(setq " (symbol-name elt) " %s) ") ,elt))
+;; (defmacro c-sc-qde (elt) ; "c-state-cache-quote-dump-element"
+;; `(format ,(concat "(setq " (symbol-name elt) " '%s) ") ,elt))
+;; (defun c-state-dump ()
+;; ;; For debugging.
+;; ;(message
+;; (concat
+;; (c-sc-qde c-state-cache)
+;; (c-sc-de c-state-cache-good-pos)
+;; (c-sc-qde c-state-nonlit-pos-cache)
+;; (c-sc-de c-state-nonlit-pos-cache-limit)
+;; (c-sc-qde c-state-brace-pair-desert)
+;; (c-sc-de c-state-point-min)
+;; (c-sc-de c-state-point-min-lit-type)
+;; (c-sc-de c-state-point-min-lit-start)
+;; (c-sc-de c-state-min-scan-pos)
+;; (c-sc-de c-state-old-cpp-beg)
+;; (c-sc-de c-state-old-cpp-end)))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
(defun c-invalidate-state-cache-1 (here)
;; Invalidate all info on `c-state-cache' that applies to the buffer at HERE
;; or higher and set `c-state-cache-good-pos' accordingly. The cache is
c-state-cache-good-pos nil
c-state-min-scan-pos nil)
-;;; Truncate `c-state-cache' and set `c-state-cache-good-pos' to a value below
-;;; `here'. To maintain its consistency, we may need to insert a new brace
-;;; pair.
+ ;; Truncate `c-state-cache' and set `c-state-cache-good-pos' to a value
+ ;; below `here'. To maintain its consistency, we may need to insert a new
+ ;; brace pair.
(let ((here-bol (c-point 'bol here))
too-high-pa ; recorded {/(/[ next above here, or nil.
dropped-cons ; was the last removed element a brace pair?
(unless (fboundp 'c-real-parse-state)
(fset 'c-real-parse-state (symbol-function 'c-parse-state)))
(cc-bytecomp-defun c-real-parse-state)
+
+(defvar c-parse-state-state nil)
+(defun c-record-parse-state-state ()
+ (setq c-parse-state-state
+ (mapcar
+ (lambda (arg)
+ (cons arg (symbol-value arg)))
+ '(c-state-cache
+ c-state-cache-good-pos
+ c-state-nonlit-pos-cache
+ c-state-nonlit-pos-cache-limit
+ c-state-brace-pair-desert
+ c-state-point-min
+ c-state-point-min-lit-type
+ c-state-point-min-lit-start
+ c-state-min-scan-pos
+ c-state-old-cpp-beg
+ c-state-old-cpp-end))))
+(defun c-replay-parse-state-state ()
+ (message
+ (concat "(setq "
+ (mapconcat
+ (lambda (arg)
+ (format "%s %s%s" (car arg) (if (atom (cdr arg)) "" "'") (cdr arg)))
+ c-parse-state-state " ")
+ ")")))
+
(defun c-debug-parse-state ()
(let ((here (point)) (res1 (c-real-parse-state)) res2)
(let ((c-state-cache nil)
;; The cache can actually go further back due to the ad-hoc way
;; the first paren is found, so try to whack off a bit of its
;; start before complaining.
- (save-excursion
- (goto-char (or (c-least-enclosing-brace res2) (point)))
- (c-beginning-of-defun-1)
- (while (not (or (bobp) (eq (char-after) ?{)))
- (c-beginning-of-defun-1))
- (unless (equal (c-whack-state-before (point) res1) res2)
- (message (concat "c-parse-state inconsistency at %s: "
- "using cache: %s, from scratch: %s")
- here res1 res2))))
+ ;; (save-excursion
+ ;; (goto-char (or (c-least-enclosing-brace res2) (point)))
+ ;; (c-beginning-of-defun-1)
+ ;; (while (not (or (bobp) (eq (char-after) ?{)))
+ ;; (c-beginning-of-defun-1))
+ ;; (unless (equal (c-whack-state-before (point) res1) res2)
+ ;; (message (concat "c-parse-state inconsistency at %s: "
+ ;; "using cache: %s, from scratch: %s")
+ ;; here res1 res2)))
+ (message (concat "c-parse-state inconsistency at %s: "
+ "using cache: %s, from scratch: %s")
+ here res1 res2)
+ (message "Old state:")
+ (c-replay-parse-state-state))
+ (c-record-parse-state-state)
res1))
(defun c-toggle-parse-state-debug (&optional arg)
;; a relevant match.
(goto-char pos)
nil))))))
-
+
(> (point)
(progn
;; Skip syntactic ws afterwards so that we don't stop at the
;; complicated anyway. In this case, lim is only used to detect
;; cpp directives.
;;
-;; Note that there is a bug in Xemacs's buffer-syntactic-context when used in
+;; Note that there is a bug in XEmacs's buffer-syntactic-context when used in
;; conjunction with syntax-table-properties. The bug is present in, e.g.,
-;; Xemacs 21.4.4. It manifested itself thus:
+;; XEmacs 21.4.4. It manifested itself thus:
;;
;; Starting with an empty AWK Mode buffer, type
;; /regexp/ {<C-j>
;; fails to take account of the change of the s-t property on the opening / to
;; "string", and reports that the { is within a string started by the second /.
;;
-;; The workaround for this is for the AWK Mode initialisation to switch the
+;; The workaround for this is for the AWK Mode initialization to switch the
;; defalias for c-in-literal to c-slow-in-literal. This will slow down other
-;; cc-modes in Xemacs whenever an awk-buffer has been initialised.
+;; cc-modes in XEmacs whenever an awk-buffer has been initialized.
;;
;; (Alan Mackenzie, 2003/4/30).
(setq cfd-prop-match nil))
(when (/= cfd-macro-end 0)
- ;; Restore limits if we did macro narrowment above.
+ ;; Restore limits if we did macro narrowing above.
(narrow-to-region (point-min) cfd-buffer-end)))
(goto-char cfd-continue-pos)
;; The strategy now (2010-01) adopted is to mark and unmark < and
;; > IN MATCHING PAIRS ONLY. [Previously, they were marked
;; individually when their context so indicated. This gave rise to
-;; intractible problems when one of a matching pair was deleted, or
+;; intractable problems when one of a matching pair was deleted, or
;; pulled into a literal.]
;;
;; At each buffer change, the syntax-table properties are removed in a
(goto-char start)
nil))
- (forward-char)
+ (forward-char) ; Forward over the opening '<'.
(unless (looking-at c-<-op-cont-regexp)
+ ;; go forward one non-alphanumeric character (group) per iteration of
+ ;; this loop.
(while (and
(progn
(c-forward-syntactic-ws)
(c-forward-type)
(c-forward-syntactic-ws))))))
- (setq pos (point))
+ (setq pos (point)) ; e.g. first token inside the '<'
;; Note: These regexps exploit the match order in \| so
;; that "<>" is matched by "<" rather than "[^>:-]>".
;; Either an operator starting with '<' or a nested arglist.
(setq pos (point))
(let (id-start id-end subres keyword-match)
- (if (if (looking-at c-<-op-cont-regexp)
- (setq tmp (match-end 0))
- (setq tmp pos)
- (backward-char)
- (not
- (and
-
- (save-excursion
- ;; There's always an identifier before an angle
- ;; bracket arglist, or a keyword in
- ;; `c-<>-type-kwds' or `c-<>-arglist-kwds'.
- (c-backward-syntactic-ws)
- (setq id-end (point))
- (c-simple-skip-symbol-backward)
- (when (or (setq keyword-match
- (looking-at c-opt-<>-sexp-key))
- (not (looking-at c-keywords-regexp)))
- (setq id-start (point))))
-
- (setq subres
- (let ((c-promote-possible-types t)
- (c-record-found-types t))
- (c-forward-<>-arglist-recur
- (and keyword-match
- (c-keyword-member
- (c-keyword-sym (match-string 1))
- 'c-<>-type-kwds)))))
- )))
-
- ;; It was not an angle bracket arglist.
- (goto-char tmp)
+ (cond
+ ;; The '<' begins a multi-char operator.
+ ((looking-at c-<-op-cont-regexp)
+ (setq tmp (match-end 0))
+ (goto-char (match-end 0)))
+ ;; We're at a nested <.....>
+ ((progn
+ (setq tmp pos)
+ (backward-char) ; to the '<'
+ (and
+ (save-excursion
+ ;; There's always an identifier before an angle
+ ;; bracket arglist, or a keyword in `c-<>-type-kwds'
+ ;; or `c-<>-arglist-kwds'.
+ (c-backward-syntactic-ws)
+ (setq id-end (point))
+ (c-simple-skip-symbol-backward)
+ (when (or (setq keyword-match
+ (looking-at c-opt-<>-sexp-key))
+ (not (looking-at c-keywords-regexp)))
+ (setq id-start (point))))
+ (setq subres
+ (let ((c-promote-possible-types t)
+ (c-record-found-types t))
+ (c-forward-<>-arglist-recur
+ (and keyword-match
+ (c-keyword-member
+ (c-keyword-sym (match-string 1))
+ 'c-<>-type-kwds)))))))
;; It was an angle bracket arglist.
(setq c-record-found-types subres)
(c-forward-syntactic-ws)
(looking-at c-opt-identifier-concat-key)))
(c-record-ref-id (cons id-start id-end))
- (c-record-type-id (cons id-start id-end))))))
- t)
+ (c-record-type-id (cons id-start id-end)))))
+
+ ;; At a "less than" operator.
+ (t
+ (forward-char)
+ )))
+ t) ; carry on looping.
((and (not c-restricted-<>-arglists)
(or (and (eq (char-before) ?&)
;; `*-font-lock-extra-types');
;; o - 'prefix if it's a known prefix of a type;
;; o - 'found if it's a type that matches one in `c-found-types';
- ;; o - 'maybe if it's an identfier that might be a type; or
+ ;; o - 'maybe if it's an identifier that might be a type; or
;; o - nil if it can't be a type (the point isn't moved then).
;;
;; The point is assumed to be at the beginning of a token.
;; car ^ ^ point
;; Foo::Foo (int b) : Base (b) {}
;; car ^ ^ point
- ;;
+ ;;
;; The cdr of the return value is non-nil when a
;; `c-typedef-decl-kwds' specifier is found in the declaration.
;; Specifically it is a dotted pair (A . B) where B is t when a
;; other `c-typedef-decl-kwds' (e.g. class, struct, enum)
;; specifier is present. I.e., (some of) the declared
;; identifier(s) are types.
- ;;
+ ;;
;; If a cast is parsed:
;;
;; The point is left at the first token after the closing paren of
(let* ((start (point)) kwd-sym kwd-clause-end found-type)
;; Look for a specifier keyword clause.
- (when (looking-at c-prefix-spec-kwds-re)
+ (when (or (looking-at c-prefix-spec-kwds-re)
+ (and (c-major-mode-is 'java-mode)
+ (looking-at "@[A-Za-z0-9]+")))
(if (looking-at c-typedef-key)
(setq at-typedef t))
(setq kwd-sym (c-keyword-sym (match-string 1)))
;; `c-font-lock-declarators'.)
(while (and (looking-at c-type-decl-prefix-key)
(if (and (c-major-mode-is 'c++-mode)
- (match-beginning 2))
+ (match-beginning 3))
;; If the second submatch matches in C++ then
;; we're looking at an identifier that's a
;; prefix only if it specifies a member pointer.
(if backup-at-type
(progn
- ;; CASE 3
- (when (= (point) start)
- ;; Got a plain list of identifiers. If a colon follows it's
- ;; a valid label. Otherwise the last one probably is the
- ;; declared identifier and we should back up to the previous
- ;; type, providing it isn't a cast.
+
+ ;; CASE 3
+ (when (= (point) start)
+ ;; Got a plain list of identifiers. If a colon follows it's
+ ;; a valid label, or maybe a bitfield. Otherwise the last
+ ;; one probably is the declared identifier and we should
+ ;; back up to the previous type, providing it isn't a cast.
(if (and (eq (char-after) ?:)
(not (c-major-mode-is 'java-mode)))
- ;; If we've found a specifier keyword then it's a
- ;; declaration regardless.
- (throw 'at-decl-or-cast (eq at-decl-or-cast t))
- (setq backup-if-not-cast t)
- (throw 'at-decl-or-cast t)))
+ (cond
+ ;; If we've found a specifier keyword then it's a
+ ;; declaration regardless.
+ ((eq at-decl-or-cast t)
+ (throw 'at-decl-or-cast t))
+ ((and c-has-bitfields
+ (eq at-decl-or-cast 'ids)) ; bitfield.
+ (setq backup-if-not-cast t)
+ (throw 'at-decl-or-cast t)))
+
+ (setq backup-if-not-cast t)
+ (throw 'at-decl-or-cast t)))
;; CASE 4
(when (and got-suffix
;; colon). Currently (2006-03), this applies only to Objective C's
;; keywords "@private", "@protected", and "@public". Returns t.
;;
- ;; One of the things which will NOT be recognised as a label is a bit-field
+ ;; One of the things which will NOT be recognized as a label is a bit-field
;; element of a struct, something like "int foo:5".
;;
;; The end of the label is taken to be just after the colon, or the end of
;; Check that we're not after a token that can't precede a label.
(or
;; Trivially succeeds when there's no preceding token.
+ ;; Succeeds when we're at a virtual semicolon.
(if preceding-token-end
(<= preceding-token-end (point-min))
(save-excursion
(c-backward-syntactic-ws)
(setq preceding-token-end (point))
- (bobp)))
+ (or (bobp)
+ (c-at-vsemi-p))))
;; Check if we're after a label, if we're after a closing
;; paren that belong to statement, and with
(back-to-indentation)
(vector (point) open-paren-pos))))))
+(defmacro c-pull-open-brace (ps)
+ ;; Pull the next open brace from PS (which has the form of paren-state),
+ ;; skipping over any brace pairs. Returns NIL when PS is exhausted.
+ `(progn
+ (while (consp (car ,ps))
+ (setq ,ps (cdr ,ps)))
+ (prog1 (car ,ps)
+ (setq ,ps (cdr ,ps)))))
+
+(defun c-most-enclosing-decl-block (paren-state)
+ ;; Return the buffer position of the most enclosing decl-block brace (in the
+ ;; sense of c-looking-at-decl-block) in the PAREN-STATE structure, or nil if
+ ;; none was found.
+ (let* ((open-brace (c-pull-open-brace paren-state))
+ (next-open-brace (c-pull-open-brace paren-state)))
+ (while (and open-brace
+ (save-excursion
+ (goto-char open-brace)
+ (not (c-looking-at-decl-block next-open-brace nil))))
+ (setq open-brace next-open-brace
+ next-open-brace (c-pull-open-brace paren-state)))
+ open-brace))
+
(defun c-inside-bracelist-p (containing-sexp paren-state)
;; return the buffer position of the beginning of the brace list
;; statement if we're inside a brace list, otherwise return nil.
paren-state)
containing-sexp)))))
+(defun c-at-macro-vsemi-p (&optional pos)
+ ;; Is there a "virtual semicolon" at POS or point?
+ ;; (See cc-defs.el for full details of "virtual semicolons".)
+ ;;
+ ;; This is true when point is at the last non syntactic WS position on the
+ ;; line, there is a macro call last on the line, and this particular macro's
+ ;; name is defined by the regexp `c-vs-macro-regexp' as not needing a
+ ;; semicolon.
+ (save-excursion
+ (save-restriction
+ (widen)
+ (if pos
+ (goto-char pos)
+ (setq pos (point)))
+ (and
+ c-macro-with-semi-re
+ (not (c-in-literal))
+ (eq (skip-chars-backward " \t") 0)
+
+ ;; Check we've got nothing after this except comments and empty lines
+ ;; joined by escaped EOLs.
+ (skip-chars-forward " \t") ; always returns non-nil.
+ (progn
+ (while ; go over 1 block comment per iteration.
+ (and
+ (looking-at "\\(\\\\[\n\r][ \t]*\\)*")
+ (goto-char (match-end 0))
+ (cond
+ ((looking-at c-block-comment-start-regexp)
+ (and (forward-comment 1)
+ (skip-chars-forward " \t"))) ; always returns non-nil
+ ((looking-at c-line-comment-start-regexp)
+ (end-of-line)
+ nil)
+ (t nil))))
+ (eolp))
+
+ (goto-char pos)
+ (progn (c-backward-syntactic-ws)
+ (eq (point) pos))
+
+ ;; Check for one of the listed macros being before point.
+ (or (not (eq (char-before) ?\)))
+ (when (c-go-list-backward)
+ (c-backward-syntactic-ws)
+ t))
+ (c-simple-skip-symbol-backward)
+ (looking-at c-macro-with-semi-re)))))
+
+(defun c-macro-vsemi-status-unknown-p () t) ; See cc-defs.el.
+
\f
;; `c-guess-basic-syntax' and the functions that precedes it below
;; implements the main decision tree for determining the syntactic
;; CASE B.4: Continued statement with block open. The most
;; accurate analysis is perhaps `statement-cont' together with
;; `block-open' but we play DWIM and use `substatement-open'
- ;; instead. The rationaly is that this typically is a macro
+ ;; instead. The rationale is that this typically is a macro
;; followed by a block which makes it very similar to a
;; statement with a substatement block.
(t
(c-beginning-of-statement-1 containing-sexp)
(c-add-syntax 'annotation-var-cont (point)))
+ ;; CASE G: a template list continuation?
+ ;; Mostly a duplication of case 5D.3 to fix templates-19:
+ ((and (c-major-mode-is 'c++-mode)
+ (save-excursion
+ (goto-char indent-point)
+ (c-with-syntax-table c++-template-syntax-table
+ (setq placeholder (c-up-list-backward)))
+ (and placeholder
+ (eq (char-after placeholder) ?<)
+ (/= (char-before placeholder) ?<)
+ (progn
+ (goto-char (1+ placeholder))
+ (not (looking-at c-<-op-cont-regexp))))))
+ (c-with-syntax-table c++-template-syntax-table
+ (goto-char placeholder)
+ (c-beginning-of-statement-1 containing-sexp t)
+ (if (save-excursion
+ (c-backward-syntactic-ws containing-sexp)
+ (eq (char-before) ?<))
+ ;; In a nested template arglist.
+ (progn
+ (goto-char placeholder)
+ (c-syntactic-skip-backward "^,;" containing-sexp t)
+ (c-forward-syntactic-ws))
+ (back-to-indentation)))
+ ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
+ ;; template aware.
+ (c-add-syntax 'template-args-cont (point) placeholder))
+
;; CASE D: continued statement.
(t
(c-beginning-of-statement-1 containing-sexp)
(defun c-guess-basic-syntax ()
"Return the syntactic context of the current line."
(save-excursion
- (beginning-of-line)
- (c-save-buffer-state
- ((indent-point (point))
- (case-fold-search nil)
- ;; A whole ugly bunch of various temporary variables. Have
- ;; to declare them here since it's not possible to declare
- ;; a variable with only the scope of a cond test and the
- ;; following result clauses, and most of this function is a
- ;; single gigantic cond. :P
- literal char-before-ip before-ws-ip char-after-ip macro-start
- in-macro-expr c-syntactic-context placeholder c-in-literal-cache
- step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
- containing-<
- ;; The following record some positions for the containing
- ;; declaration block if we're directly within one:
- ;; `containing-decl-open' is the position of the open
- ;; brace. `containing-decl-start' is the start of the
- ;; declaration. `containing-decl-kwd' is the keyword
- ;; symbol of the keyword that tells what kind of block it
- ;; is.
- containing-decl-open
- containing-decl-start
- containing-decl-kwd
- ;; The open paren of the closest surrounding sexp or nil if
- ;; there is none.
- containing-sexp
- ;; The position after the closest preceding brace sexp
- ;; (nested sexps are ignored), or the position after
- ;; `containing-sexp' if there is none, or (point-min) if
- ;; `containing-sexp' is nil.
- lim
- ;; The paren state outside `containing-sexp', or at
- ;; `indent-point' if `containing-sexp' is nil.
- (paren-state (c-parse-state))
- ;; There's always at most one syntactic element which got
- ;; an anchor pos. It's stored in syntactic-relpos.
- syntactic-relpos
- (c-stmt-delim-chars c-stmt-delim-chars))
-
- ;; Check if we're directly inside an enclosing declaration
- ;; level block.
- (when (and (setq containing-sexp
- (c-most-enclosing-brace paren-state))
- (progn
- (goto-char containing-sexp)
- (eq (char-after) ?{))
- (setq placeholder
- (c-looking-at-decl-block
- (c-most-enclosing-brace paren-state
- containing-sexp)
- t)))
- (setq containing-decl-open containing-sexp
- containing-decl-start (point)
- containing-sexp nil)
- (goto-char placeholder)
- (setq containing-decl-kwd (and (looking-at c-keywords-regexp)
- (c-keyword-sym (match-string 1)))))
-
- ;; Init some position variables.
- (if c-state-cache
- (progn
- (setq containing-sexp (car paren-state)
- paren-state (cdr paren-state))
- (if (consp containing-sexp)
- (progn
- (setq lim (cdr containing-sexp))
- (if (cdr c-state-cache)
- ;; Ignore balanced paren. The next entry
- ;; can't be another one.
- (setq containing-sexp (car (cdr c-state-cache))
- paren-state (cdr paren-state))
- ;; If there is no surrounding open paren then
- ;; put the last balanced pair back on paren-state.
- (setq paren-state (cons containing-sexp paren-state)
- containing-sexp nil)))
- (setq lim (1+ containing-sexp))))
- (setq lim (point-min)))
-
- ;; If we're in a parenthesis list then ',' delimits the
- ;; "statements" rather than being an operator (with the
- ;; exception of the "for" clause). This difference is
- ;; typically only noticeable when statements are used in macro
- ;; arglists.
- (when (and containing-sexp
- (eq (char-after containing-sexp) ?\())
- (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
- ;; cache char before and after indent point, and move point to
- ;; the most likely position to perform the majority of tests
- (goto-char indent-point)
- (c-backward-syntactic-ws lim)
- (setq before-ws-ip (point)
- char-before-ip (char-before))
- (goto-char indent-point)
- (skip-chars-forward " \t")
- (setq char-after-ip (char-after))
-
- ;; are we in a literal?
- (setq literal (c-in-literal lim))
-
- ;; now figure out syntactic qualities of the current line
- (cond
+ (beginning-of-line)
+ (c-save-buffer-state
+ ((indent-point (point))
+ (case-fold-search nil)
+ ;; A whole ugly bunch of various temporary variables. Have
+ ;; to declare them here since it's not possible to declare
+ ;; a variable with only the scope of a cond test and the
+ ;; following result clauses, and most of this function is a
+ ;; single gigantic cond. :P
+ literal char-before-ip before-ws-ip char-after-ip macro-start
+ in-macro-expr c-syntactic-context placeholder c-in-literal-cache
+ step-type tmpsymbol keyword injava-inher special-brace-list tmp-pos
+ containing-<
+ ;; The following record some positions for the containing
+ ;; declaration block if we're directly within one:
+ ;; `containing-decl-open' is the position of the open
+ ;; brace. `containing-decl-start' is the start of the
+ ;; declaration. `containing-decl-kwd' is the keyword
+ ;; symbol of the keyword that tells what kind of block it
+ ;; is.
+ containing-decl-open
+ containing-decl-start
+ containing-decl-kwd
+ ;; The open paren of the closest surrounding sexp or nil if
+ ;; there is none.
+ containing-sexp
+ ;; The position after the closest preceding brace sexp
+ ;; (nested sexps are ignored), or the position after
+ ;; `containing-sexp' if there is none, or (point-min) if
+ ;; `containing-sexp' is nil.
+ lim
+ ;; The paren state outside `containing-sexp', or at
+ ;; `indent-point' if `containing-sexp' is nil.
+ (paren-state (c-parse-state))
+ ;; There's always at most one syntactic element which got
+ ;; an anchor pos. It's stored in syntactic-relpos.
+ syntactic-relpos
+ (c-stmt-delim-chars c-stmt-delim-chars))
+
+ ;; Check if we're directly inside an enclosing declaration
+ ;; level block.
+ (when (and (setq containing-sexp
+ (c-most-enclosing-brace paren-state))
+ (progn
+ (goto-char containing-sexp)
+ (eq (char-after) ?{))
+ (setq placeholder
+ (c-looking-at-decl-block
+ (c-most-enclosing-brace paren-state
+ containing-sexp)
+ t)))
+ (setq containing-decl-open containing-sexp
+ containing-decl-start (point)
+ containing-sexp nil)
+ (goto-char placeholder)
+ (setq containing-decl-kwd (and (looking-at c-keywords-regexp)
+ (c-keyword-sym (match-string 1)))))
+
+ ;; Init some position variables.
+ (if c-state-cache
+ (progn
+ (setq containing-sexp (car paren-state)
+ paren-state (cdr paren-state))
+ (if (consp containing-sexp)
+ (progn
+ (setq lim (cdr containing-sexp))
+ (if (cdr c-state-cache)
+ ;; Ignore balanced paren. The next entry
+ ;; can't be another one.
+ (setq containing-sexp (car (cdr c-state-cache))
+ paren-state (cdr paren-state))
+ ;; If there is no surrounding open paren then
+ ;; put the last balanced pair back on paren-state.
+ (setq paren-state (cons containing-sexp paren-state)
+ containing-sexp nil)))
+ (setq lim (1+ containing-sexp))))
+ (setq lim (point-min)))
+
+ ;; If we're in a parenthesis list then ',' delimits the
+ ;; "statements" rather than being an operator (with the
+ ;; exception of the "for" clause). This difference is
+ ;; typically only noticeable when statements are used in macro
+ ;; arglists.
+ (when (and containing-sexp
+ (eq (char-after containing-sexp) ?\())
+ (setq c-stmt-delim-chars c-stmt-delim-chars-with-comma))
+ ;; cache char before and after indent point, and move point to
+ ;; the most likely position to perform the majority of tests
+ (goto-char indent-point)
+ (c-backward-syntactic-ws lim)
+ (setq before-ws-ip (point)
+ char-before-ip (char-before))
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (setq char-after-ip (char-after))
+
+ ;; are we in a literal?
+ (setq literal (c-in-literal lim))
+
+ ;; now figure out syntactic qualities of the current line
+ (cond
- ;; CASE 1: in a string.
- ((eq literal 'string)
- (c-add-syntax 'string (c-point 'bopl)))
-
- ;; CASE 2: in a C or C++ style comment.
- ((and (memq literal '(c c++))
- ;; This is a kludge for XEmacs where we use
- ;; `buffer-syntactic-context', which doesn't correctly
- ;; recognize "\*/" to end a block comment.
- ;; `parse-partial-sexp' which is used by
- ;; `c-literal-limits' will however do that in most
- ;; versions, which results in that we get nil from
- ;; `c-literal-limits' even when `c-in-literal' claims
- ;; we're inside a comment.
- (setq placeholder (c-literal-limits lim)))
- (c-add-syntax literal (car placeholder)))
-
- ;; CASE 3: in a cpp preprocessor macro continuation.
- ((and (save-excursion
- (when (c-beginning-of-macro)
- (setq macro-start (point))))
- (/= macro-start (c-point 'boi))
- (progn
- (setq tmpsymbol 'cpp-macro-cont)
- (or (not c-syntactic-indentation-in-macros)
- (save-excursion
- (goto-char macro-start)
- ;; If at the beginning of the body of a #define
- ;; directive then analyze as cpp-define-intro
- ;; only. Go on with the syntactic analysis
- ;; otherwise. in-macro-expr is set if we're in a
- ;; cpp expression, i.e. before the #define body
- ;; or anywhere in a non-#define directive.
- (if (c-forward-to-cpp-define-body)
- (let ((indent-boi (c-point 'boi indent-point)))
- (setq in-macro-expr (> (point) indent-boi)
- tmpsymbol 'cpp-define-intro)
- (= (point) indent-boi))
- (setq in-macro-expr t)
- nil)))))
- (c-add-syntax tmpsymbol macro-start)
- (setq macro-start nil))
-
- ;; CASE 11: an else clause?
- ((looking-at "else\\>[^_]")
- (c-beginning-of-statement-1 containing-sexp)
- (c-add-stmt-syntax 'else-clause nil t
- containing-sexp paren-state))
+ ;; CASE 1: in a string.
+ ((eq literal 'string)
+ (c-add-syntax 'string (c-point 'bopl)))
+
+ ;; CASE 2: in a C or C++ style comment.
+ ((and (memq literal '(c c++))
+ ;; This is a kludge for XEmacs where we use
+ ;; `buffer-syntactic-context', which doesn't correctly
+ ;; recognize "\*/" to end a block comment.
+ ;; `parse-partial-sexp' which is used by
+ ;; `c-literal-limits' will however do that in most
+ ;; versions, which results in that we get nil from
+ ;; `c-literal-limits' even when `c-in-literal' claims
+ ;; we're inside a comment.
+ (setq placeholder (c-literal-limits lim)))
+ (c-add-syntax literal (car placeholder)))
+
+ ;; CASE 3: in a cpp preprocessor macro continuation.
+ ((and (save-excursion
+ (when (c-beginning-of-macro)
+ (setq macro-start (point))))
+ (/= macro-start (c-point 'boi))
+ (progn
+ (setq tmpsymbol 'cpp-macro-cont)
+ (or (not c-syntactic-indentation-in-macros)
+ (save-excursion
+ (goto-char macro-start)
+ ;; If at the beginning of the body of a #define
+ ;; directive then analyze as cpp-define-intro
+ ;; only. Go on with the syntactic analysis
+ ;; otherwise. in-macro-expr is set if we're in a
+ ;; cpp expression, i.e. before the #define body
+ ;; or anywhere in a non-#define directive.
+ (if (c-forward-to-cpp-define-body)
+ (let ((indent-boi (c-point 'boi indent-point)))
+ (setq in-macro-expr (> (point) indent-boi)
+ tmpsymbol 'cpp-define-intro)
+ (= (point) indent-boi))
+ (setq in-macro-expr t)
+ nil)))))
+ (c-add-syntax tmpsymbol macro-start)
+ (setq macro-start nil))
+
+ ;; CASE 11: an else clause?
+ ((looking-at "else\\>[^_]")
+ (c-beginning-of-statement-1 containing-sexp)
+ (c-add-stmt-syntax 'else-clause nil t
+ containing-sexp paren-state))
- ;; CASE 12: while closure of a do/while construct?
- ((and (looking-at "while\\>[^_]")
- (save-excursion
- (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
- 'beginning)
- (setq placeholder (point)))))
- (goto-char placeholder)
- (c-add-stmt-syntax 'do-while-closure nil t
- containing-sexp paren-state))
+ ;; CASE 12: while closure of a do/while construct?
+ ((and (looking-at "while\\>[^_]")
+ (save-excursion
+ (prog1 (eq (c-beginning-of-statement-1 containing-sexp)
+ 'beginning)
+ (setq placeholder (point)))))
+ (goto-char placeholder)
+ (c-add-stmt-syntax 'do-while-closure nil t
+ containing-sexp paren-state))
- ;; CASE 13: A catch or finally clause? This case is simpler
- ;; than if-else and do-while, because a block is required
- ;; after every try, catch and finally.
- ((save-excursion
- (and (cond ((c-major-mode-is 'c++-mode)
- (looking-at "catch\\>[^_]"))
- ((c-major-mode-is 'java-mode)
- (looking-at "\\(catch\\|finally\\)\\>[^_]")))
- (and (c-safe (c-backward-syntactic-ws)
- (c-backward-sexp)
- t)
- (eq (char-after) ?{)
- (c-safe (c-backward-syntactic-ws)
- (c-backward-sexp)
- t)
- (if (eq (char-after) ?\()
- (c-safe (c-backward-sexp) t)
- t))
- (looking-at "\\(try\\|catch\\)\\>[^_]")
- (setq placeholder (point))))
- (goto-char placeholder)
- (c-add-stmt-syntax 'catch-clause nil t
- containing-sexp paren-state))
+ ;; CASE 13: A catch or finally clause? This case is simpler
+ ;; than if-else and do-while, because a block is required
+ ;; after every try, catch and finally.
+ ((save-excursion
+ (and (cond ((c-major-mode-is 'c++-mode)
+ (looking-at "catch\\>[^_]"))
+ ((c-major-mode-is 'java-mode)
+ (looking-at "\\(catch\\|finally\\)\\>[^_]")))
+ (and (c-safe (c-backward-syntactic-ws)
+ (c-backward-sexp)
+ t)
+ (eq (char-after) ?{)
+ (c-safe (c-backward-syntactic-ws)
+ (c-backward-sexp)
+ t)
+ (if (eq (char-after) ?\()
+ (c-safe (c-backward-sexp) t)
+ t))
+ (looking-at "\\(try\\|catch\\)\\>[^_]")
+ (setq placeholder (point))))
+ (goto-char placeholder)
+ (c-add-stmt-syntax 'catch-clause nil t
+ containing-sexp paren-state))
- ;; CASE 18: A substatement we can recognize by keyword.
- ((save-excursion
- (and c-opt-block-stmt-key
- (not (eq char-before-ip ?\;))
- (not (c-at-vsemi-p before-ws-ip))
- (not (memq char-after-ip '(?\) ?\] ?,)))
- (or (not (eq char-before-ip ?}))
- (c-looking-at-inexpr-block-backward c-state-cache))
- (> (point)
- (progn
- ;; Ought to cache the result from the
- ;; c-beginning-of-statement-1 calls here.
+ ;; CASE 18: A substatement we can recognize by keyword.
+ ((save-excursion
+ (and c-opt-block-stmt-key
+ (not (eq char-before-ip ?\;))
+ (not (c-at-vsemi-p before-ws-ip))
+ (not (memq char-after-ip '(?\) ?\] ?,)))
+ (or (not (eq char-before-ip ?}))
+ (c-looking-at-inexpr-block-backward c-state-cache))
+ (> (point)
+ (progn
+ ;; Ought to cache the result from the
+ ;; c-beginning-of-statement-1 calls here.
+ (setq placeholder (point))
+ (while (eq (setq step-type
+ (c-beginning-of-statement-1 lim))
+ 'label))
+ (if (eq step-type 'previous)
+ (goto-char placeholder)
(setq placeholder (point))
- (while (eq (setq step-type
- (c-beginning-of-statement-1 lim))
- 'label))
- (if (eq step-type 'previous)
- (goto-char placeholder)
- (setq placeholder (point))
- (if (and (eq step-type 'same)
- (not (looking-at c-opt-block-stmt-key)))
- ;; Step up to the containing statement if we
- ;; stayed in the same one.
- (let (step)
- (while (eq
- (setq step
- (c-beginning-of-statement-1 lim))
- 'label))
- (if (eq step 'up)
- (setq placeholder (point))
- ;; There was no containing statement afterall.
- (goto-char placeholder)))))
- placeholder))
- (if (looking-at c-block-stmt-2-key)
- ;; Require a parenthesis after these keywords.
- ;; Necessary to catch e.g. synchronized in Java,
- ;; which can be used both as statement and
- ;; modifier.
- (and (zerop (c-forward-token-2 1 nil))
- (eq (char-after) ?\())
- (looking-at c-opt-block-stmt-key))))
-
- (if (eq step-type 'up)
- ;; CASE 18A: Simple substatement.
- (progn
- (goto-char placeholder)
- (cond
- ((eq char-after-ip ?{)
- (c-add-stmt-syntax 'substatement-open nil nil
- containing-sexp paren-state))
- ((save-excursion
- (goto-char indent-point)
- (back-to-indentation)
- (c-forward-label))
- (c-add-stmt-syntax 'substatement-label nil nil
- containing-sexp paren-state))
- (t
- (c-add-stmt-syntax 'substatement nil nil
- containing-sexp paren-state))))
-
- ;; CASE 18B: Some other substatement. This is shared
- ;; with case 10.
- (c-guess-continued-construct indent-point
- char-after-ip
- placeholder
- lim
- paren-state)))
-
- ;; CASE 14: A case or default label
- ((looking-at c-label-kwds-regexp)
- (if containing-sexp
- (progn
- (goto-char containing-sexp)
- (setq lim (c-most-enclosing-brace c-state-cache
- containing-sexp))
- (c-backward-to-block-anchor lim)
- (c-add-stmt-syntax 'case-label nil t lim paren-state))
- ;; Got a bogus label at the top level. In lack of better
- ;; alternatives, anchor it on (point-min).
- (c-add-syntax 'case-label (point-min))))
-
- ;; CASE 15: any other label
- ((save-excursion
- (back-to-indentation)
- (and (not (looking-at c-syntactic-ws-start))
- (c-forward-label)))
- (cond (containing-decl-open
- (setq placeholder (c-add-class-syntax 'inclass
- containing-decl-open
- containing-decl-start
- containing-decl-kwd
- paren-state))
- ;; Append access-label with the same anchor point as
- ;; inclass gets.
- (c-append-syntax 'access-label placeholder))
-
- (containing-sexp
- (goto-char containing-sexp)
- (setq lim (c-most-enclosing-brace c-state-cache
- containing-sexp))
- (save-excursion
- (setq tmpsymbol
- (if (and (eq (c-beginning-of-statement-1 lim) 'up)
- (looking-at "switch\\>[^_]"))
- ;; If the surrounding statement is a switch then
- ;; let's analyze all labels as switch labels, so
- ;; that they get lined up consistently.
- 'case-label
- 'label)))
- (c-backward-to-block-anchor lim)
- (c-add-stmt-syntax tmpsymbol nil t lim paren-state))
+ (if (and (eq step-type 'same)
+ (not (looking-at c-opt-block-stmt-key)))
+ ;; Step up to the containing statement if we
+ ;; stayed in the same one.
+ (let (step)
+ (while (eq
+ (setq step
+ (c-beginning-of-statement-1 lim))
+ 'label))
+ (if (eq step 'up)
+ (setq placeholder (point))
+ ;; There was no containing statement afterall.
+ (goto-char placeholder)))))
+ placeholder))
+ (if (looking-at c-block-stmt-2-key)
+ ;; Require a parenthesis after these keywords.
+ ;; Necessary to catch e.g. synchronized in Java,
+ ;; which can be used both as statement and
+ ;; modifier.
+ (and (zerop (c-forward-token-2 1 nil))
+ (eq (char-after) ?\())
+ (looking-at c-opt-block-stmt-key))))
+
+ (if (eq step-type 'up)
+ ;; CASE 18A: Simple substatement.
+ (progn
+ (goto-char placeholder)
+ (cond
+ ((eq char-after-ip ?{)
+ (c-add-stmt-syntax 'substatement-open nil nil
+ containing-sexp paren-state))
+ ((save-excursion
+ (goto-char indent-point)
+ (back-to-indentation)
+ (c-forward-label))
+ (c-add-stmt-syntax 'substatement-label nil nil
+ containing-sexp paren-state))
+ (t
+ (c-add-stmt-syntax 'substatement nil nil
+ containing-sexp paren-state))))
+
+ ;; CASE 18B: Some other substatement. This is shared
+ ;; with case 10.
+ (c-guess-continued-construct indent-point
+ char-after-ip
+ placeholder
+ lim
+ paren-state)))
- (t
- ;; A label on the top level. Treat it as a class
- ;; context. (point-min) is the closest we get to the
- ;; class open brace.
- (c-add-syntax 'access-label (point-min)))))
+ ;; CASE 14: A case or default label
+ ((looking-at c-label-kwds-regexp)
+ (if containing-sexp
+ (progn
+ (goto-char containing-sexp)
+ (setq lim (c-most-enclosing-brace c-state-cache
+ containing-sexp))
+ (c-backward-to-block-anchor lim)
+ (c-add-stmt-syntax 'case-label nil t lim paren-state))
+ ;; Got a bogus label at the top level. In lack of better
+ ;; alternatives, anchor it on (point-min).
+ (c-add-syntax 'case-label (point-min))))
- ;; CASE 4: In-expression statement. C.f. cases 7B, 16A and
- ;; 17E.
- ((setq placeholder (c-looking-at-inexpr-block
- (c-safe-position containing-sexp paren-state)
- containing-sexp
- ;; Have to turn on the heuristics after
- ;; the point even though it doesn't work
- ;; very well. C.f. test case class-16.pike.
- t))
- (setq tmpsymbol (assq (car placeholder)
- '((inexpr-class . class-open)
- (inexpr-statement . block-open))))
- (if tmpsymbol
- ;; It's a statement block or an anonymous class.
- (setq tmpsymbol (cdr tmpsymbol))
- ;; It's a Pike lambda. Check whether we are between the
- ;; lambda keyword and the argument list or at the defun
- ;; opener.
- (setq tmpsymbol (if (eq char-after-ip ?{)
- 'inline-open
- 'lambda-intro-cont)))
- (goto-char (cdr placeholder))
+ ;; CASE 15: any other label
+ ((save-excursion
(back-to-indentation)
- (c-add-stmt-syntax tmpsymbol nil t
- (c-most-enclosing-brace c-state-cache (point))
- paren-state)
- (unless (eq (point) (cdr placeholder))
- (c-add-syntax (car placeholder))))
-
- ;; CASE 5: Line is inside a declaration level block or at top level.
- ((or containing-decl-open (null containing-sexp))
- (cond
-
- ;; CASE 5A: we are looking at a defun, brace list, class,
- ;; or inline-inclass method opening brace
- ((setq special-brace-list
- (or (and c-special-brace-lists
- (c-looking-at-special-brace-list))
- (eq char-after-ip ?{)))
- (cond
+ (and (not (looking-at c-syntactic-ws-start))
+ (c-forward-label)))
+ (cond (containing-decl-open
+ (setq placeholder (c-add-class-syntax 'inclass
+ containing-decl-open
+ containing-decl-start
+ containing-decl-kwd
+ paren-state))
+ ;; Append access-label with the same anchor point as
+ ;; inclass gets.
+ (c-append-syntax 'access-label placeholder))
+
+ (containing-sexp
+ (goto-char containing-sexp)
+ (setq lim (c-most-enclosing-brace c-state-cache
+ containing-sexp))
+ (save-excursion
+ (setq tmpsymbol
+ (if (and (eq (c-beginning-of-statement-1 lim) 'up)
+ (looking-at "switch\\>[^_]"))
+ ;; If the surrounding statement is a switch then
+ ;; let's analyze all labels as switch labels, so
+ ;; that they get lined up consistently.
+ 'case-label
+ 'label)))
+ (c-backward-to-block-anchor lim)
+ (c-add-stmt-syntax tmpsymbol nil t lim paren-state))
- ;; CASE 5A.1: Non-class declaration block open.
- ((save-excursion
- (let (tmp)
- (and (eq char-after-ip ?{)
- (setq tmp (c-looking-at-decl-block containing-sexp t))
- (progn
- (setq placeholder (point))
- (goto-char tmp)
- (looking-at c-symbol-key))
- (c-keyword-member
- (c-keyword-sym (setq keyword (match-string 0)))
- 'c-other-block-decl-kwds))))
- (goto-char placeholder)
- (c-add-stmt-syntax
- (if (string-equal keyword "extern")
- ;; Special case for extern-lang-open.
- 'extern-lang-open
- (intern (concat keyword "-open")))
- nil t containing-sexp paren-state))
-
- ;; CASE 5A.2: we are looking at a class opening brace
- ((save-excursion
- (goto-char indent-point)
- (skip-chars-forward " \t")
- (and (eq (char-after) ?{)
- (c-looking-at-decl-block containing-sexp t)
- (setq placeholder (point))))
- (c-add-syntax 'class-open placeholder))
-
- ;; CASE 5A.3: brace list open
- ((save-excursion
- (c-beginning-of-decl-1 lim)
- (while (looking-at c-specifier-key)
- (goto-char (match-end 1))
- (c-forward-syntactic-ws indent-point))
- (setq placeholder (c-point 'boi))
- (or (consp special-brace-list)
- (and (or (save-excursion
- (goto-char indent-point)
- (setq tmpsymbol nil)
- (while (and (> (point) placeholder)
- (zerop (c-backward-token-2 1 t))
- (/= (char-after) ?=))
- (and c-opt-inexpr-brace-list-key
- (not tmpsymbol)
- (looking-at c-opt-inexpr-brace-list-key)
- (setq tmpsymbol 'topmost-intro-cont)))
- (eq (char-after) ?=))
- (looking-at c-brace-list-key))
- (save-excursion
- (while (and (< (point) indent-point)
- (zerop (c-forward-token-2 1 t))
- (not (memq (char-after) '(?\; ?\()))))
- (not (memq (char-after) '(?\; ?\()))
- ))))
- (if (and (not c-auto-newline-analysis)
- (c-major-mode-is 'java-mode)
- (eq tmpsymbol 'topmost-intro-cont))
- ;; We're in Java and have found that the open brace
- ;; belongs to a "new Foo[]" initialization list,
- ;; which means the brace list is part of an
- ;; expression and not a top level definition. We
- ;; therefore treat it as any topmost continuation
- ;; even though the semantically correct symbol still
- ;; is brace-list-open, on the same grounds as in
- ;; case B.2.
- (progn
- (c-beginning-of-statement-1 lim)
- (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
- (c-add-syntax 'brace-list-open placeholder)))
-
- ;; CASE 5A.4: inline defun open
- ((and containing-decl-open
- (not (c-keyword-member containing-decl-kwd
- 'c-other-block-decl-kwds)))
- (c-add-syntax 'inline-open)
- (c-add-class-syntax 'inclass
- containing-decl-open
- containing-decl-start
- containing-decl-kwd
- paren-state))
-
- ;; CASE 5A.5: ordinary defun open
- (t
- (save-excursion
- (c-beginning-of-decl-1 lim)
- (while (looking-at c-specifier-key)
- (goto-char (match-end 1))
- (c-forward-syntactic-ws indent-point))
- (c-add-syntax 'defun-open (c-point 'boi))
- ;; Bogus to use bol here, but it's the legacy. (Resolved,
- ;; 2007-11-09)
- ))))
-
- ;; CASE 5B: After a function header but before the body (or
- ;; the ending semicolon if there's no body).
- ((save-excursion
- (when (setq placeholder (c-just-after-func-arglist-p lim))
- (setq tmp-pos (point))))
- (cond
+ (t
+ ;; A label on the top level. Treat it as a class
+ ;; context. (point-min) is the closest we get to the
+ ;; class open brace.
+ (c-add-syntax 'access-label (point-min)))))
+
+ ;; CASE 4: In-expression statement. C.f. cases 7B, 16A and
+ ;; 17E.
+ ((setq placeholder (c-looking-at-inexpr-block
+ (c-safe-position containing-sexp paren-state)
+ containing-sexp
+ ;; Have to turn on the heuristics after
+ ;; the point even though it doesn't work
+ ;; very well. C.f. test case class-16.pike.
+ t))
+ (setq tmpsymbol (assq (car placeholder)
+ '((inexpr-class . class-open)
+ (inexpr-statement . block-open))))
+ (if tmpsymbol
+ ;; It's a statement block or an anonymous class.
+ (setq tmpsymbol (cdr tmpsymbol))
+ ;; It's a Pike lambda. Check whether we are between the
+ ;; lambda keyword and the argument list or at the defun
+ ;; opener.
+ (setq tmpsymbol (if (eq char-after-ip ?{)
+ 'inline-open
+ 'lambda-intro-cont)))
+ (goto-char (cdr placeholder))
+ (back-to-indentation)
+ (c-add-stmt-syntax tmpsymbol nil t
+ (c-most-enclosing-brace c-state-cache (point))
+ paren-state)
+ (unless (eq (point) (cdr placeholder))
+ (c-add-syntax (car placeholder))))
- ;; CASE 5B.1: Member init list.
- ((eq (char-after tmp-pos) ?:)
- (if (or (> tmp-pos indent-point)
- (= (c-point 'bosws) (1+ tmp-pos)))
- (progn
- ;; There is no preceding member init clause.
- ;; Indent relative to the beginning of indentation
- ;; for the topmost-intro line that contains the
- ;; prototype's open paren.
- (goto-char placeholder)
- (c-add-syntax 'member-init-intro (c-point 'boi)))
- ;; Indent relative to the first member init clause.
- (goto-char (1+ tmp-pos))
- (c-forward-syntactic-ws)
- (c-add-syntax 'member-init-cont (point))))
+ ;; CASE 5: Line is inside a declaration level block or at top level.
+ ((or containing-decl-open (null containing-sexp))
+ (cond
- ;; CASE 5B.2: K&R arg decl intro
- ((and c-recognize-knr-p
- (c-in-knr-argdecl lim))
- (c-beginning-of-statement-1 lim)
- (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
- (if containing-decl-open
- (c-add-class-syntax 'inclass
- containing-decl-open
- containing-decl-start
- containing-decl-kwd
- paren-state)))
-
- ;; CASE 5B.4: Nether region after a C++ or Java func
- ;; decl, which could include a `throws' declaration.
- (t
- (c-beginning-of-statement-1 lim)
- (c-add-syntax 'func-decl-cont (c-point 'boi))
- )))
+ ;; CASE 5A: we are looking at a defun, brace list, class,
+ ;; or inline-inclass method opening brace
+ ((setq special-brace-list
+ (or (and c-special-brace-lists
+ (c-looking-at-special-brace-list))
+ (eq char-after-ip ?{)))
+ (cond
- ;; CASE 5C: inheritance line. could be first inheritance
- ;; line, or continuation of a multiple inheritance
- ((or (and (c-major-mode-is 'c++-mode)
+ ;; CASE 5A.1: Non-class declaration block open.
+ ((save-excursion
+ (let (tmp)
+ (and (eq char-after-ip ?{)
+ (setq tmp (c-looking-at-decl-block containing-sexp t))
(progn
- (when (eq char-after-ip ?,)
- (skip-chars-forward " \t")
- (forward-char))
- (looking-at c-opt-postfix-decl-spec-key)))
- (and (or (eq char-before-ip ?:)
- ;; watch out for scope operator
- (save-excursion
- (and (eq char-after-ip ?:)
- (c-safe (forward-char 1) t)
- (not (eq (char-after) ?:))
- )))
- (save-excursion
- (c-backward-syntactic-ws lim)
- (if (eq char-before-ip ?:)
- (progn
- (forward-char -1)
- (c-backward-syntactic-ws lim)))
- (back-to-indentation)
- (looking-at c-class-key)))
- ;; for Java
- (and (c-major-mode-is 'java-mode)
- (let ((fence (save-excursion
- (c-beginning-of-statement-1 lim)
- (point)))
- cont done)
- (save-excursion
- (while (not done)
- (cond ((looking-at c-opt-postfix-decl-spec-key)
- (setq injava-inher (cons cont (point))
- done t))
- ((or (not (c-safe (c-forward-sexp -1) t))
- (<= (point) fence))
- (setq done t))
- )
- (setq cont t)))
- injava-inher)
- (not (c-crosses-statement-barrier-p (cdr injava-inher)
- (point)))
- ))
- (cond
-
- ;; CASE 5C.1: non-hanging colon on an inher intro
- ((eq char-after-ip ?:)
- (c-beginning-of-statement-1 lim)
- (c-add-syntax 'inher-intro (c-point 'boi))
- ;; don't add inclass symbol since relative point already
- ;; contains any class offset
- )
+ (setq placeholder (point))
+ (goto-char tmp)
+ (looking-at c-symbol-key))
+ (c-keyword-member
+ (c-keyword-sym (setq keyword (match-string 0)))
+ 'c-other-block-decl-kwds))))
+ (goto-char placeholder)
+ (c-add-stmt-syntax
+ (if (string-equal keyword "extern")
+ ;; Special case for extern-lang-open.
+ 'extern-lang-open
+ (intern (concat keyword "-open")))
+ nil t containing-sexp paren-state))
- ;; CASE 5C.2: hanging colon on an inher intro
- ((eq char-before-ip ?:)
- (c-beginning-of-statement-1 lim)
- (c-add-syntax 'inher-intro (c-point 'boi))
- (if containing-decl-open
- (c-add-class-syntax 'inclass
- containing-decl-open
- containing-decl-start
- containing-decl-kwd
- paren-state)))
-
- ;; CASE 5C.3: in a Java implements/extends
- (injava-inher
- (let ((where (cdr injava-inher))
- (cont (car injava-inher)))
- (goto-char where)
- (cond ((looking-at "throws\\>[^_]")
- (c-add-syntax 'func-decl-cont
- (progn (c-beginning-of-statement-1 lim)
- (c-point 'boi))))
- (cont (c-add-syntax 'inher-cont where))
- (t (c-add-syntax 'inher-intro
- (progn (goto-char (cdr injava-inher))
- (c-beginning-of-statement-1 lim)
- (point))))
- )))
-
- ;; CASE 5C.4: a continued inheritance line
- (t
- (c-beginning-of-inheritance-list lim)
- (c-add-syntax 'inher-cont (point))
- ;; don't add inclass symbol since relative point already
- ;; contains any class offset
- )))
-
- ;; CASE 5D: this could be a top-level initialization, a
- ;; member init list continuation, or a template argument
- ;; list continuation.
+ ;; CASE 5A.2: we are looking at a class opening brace
((save-excursion
- ;; Note: We use the fact that lim is always after any
- ;; preceding brace sexp.
- (if c-recognize-<>-arglists
- (while (and
- (progn
- (c-syntactic-skip-backward "^;,=<>" lim t)
- (> (point) lim))
- (or
- (when c-overloadable-operators-regexp
- (when (setq placeholder (c-after-special-operator-id lim))
- (goto-char placeholder)
- t))
- (cond
- ((eq (char-before) ?>)
- (or (c-backward-<>-arglist nil lim)
- (backward-char))
- t)
- ((eq (char-before) ?<)
- (backward-char)
- (if (save-excursion
- (c-forward-<>-arglist nil))
- (progn (forward-char)
- nil)
- t))
- (t nil)))))
- ;; NB: No c-after-special-operator-id stuff in this
- ;; clause - we assume only C++ needs it.
- (c-syntactic-skip-backward "^;,=" lim t))
- (memq (char-before) '(?, ?= ?<)))
- (cond
-
- ;; CASE 5D.3: perhaps a template list continuation?
- ((and (c-major-mode-is 'c++-mode)
- (save-excursion
- (save-restriction
- (c-with-syntax-table c++-template-syntax-table
- (goto-char indent-point)
- (setq placeholder (c-up-list-backward))
- (and placeholder
- (eq (char-after placeholder) ?<))))))
- (c-with-syntax-table c++-template-syntax-table
- (goto-char placeholder)
- (c-beginning-of-statement-1 lim t)
- (if (save-excursion
- (c-backward-syntactic-ws lim)
- (eq (char-before) ?<))
- ;; In a nested template arglist.
- (progn
- (goto-char placeholder)
- (c-syntactic-skip-backward "^,;" lim t)
- (c-forward-syntactic-ws))
- (back-to-indentation)))
- ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
- ;; template aware.
- (c-add-syntax 'template-args-cont (point) placeholder))
-
- ;; CASE 5D.4: perhaps a multiple inheritance line?
- ((and (c-major-mode-is 'c++-mode)
- (save-excursion
- (c-beginning-of-statement-1 lim)
- (setq placeholder (point))
- (if (looking-at "static\\>[^_]")
- (c-forward-token-2 1 nil indent-point))
- (and (looking-at c-class-key)
- (zerop (c-forward-token-2 2 nil indent-point))
- (if (eq (char-after) ?<)
- (c-with-syntax-table c++-template-syntax-table
- (zerop (c-forward-token-2 1 t indent-point)))
- t)
- (eq (char-after) ?:))))
- (goto-char placeholder)
- (c-add-syntax 'inher-cont (c-point 'boi)))
-
- ;; CASE 5D.5: Continuation of the "expression part" of a
- ;; top level construct. Or, perhaps, an unrecognised construct.
- (t
- (while (and (setq placeholder (point))
- (eq (car (c-beginning-of-decl-1 containing-sexp))
- 'same)
- (save-excursion
- (c-backward-syntactic-ws)
- (eq (char-before) ?}))
- (< (point) placeholder)))
- (c-add-stmt-syntax
- (cond
- ((eq (point) placeholder) 'statement) ; unrecognised construct
- ;; A preceding comma at the top level means that a
- ;; new variable declaration starts here. Use
- ;; topmost-intro-cont for it, for consistency with
- ;; the first variable declaration. C.f. case 5N.
- ((eq char-before-ip ?,) 'topmost-intro-cont)
- (t 'statement-cont))
- nil nil containing-sexp paren-state))
- ))
-
- ;; CASE 5F: Close of a non-class declaration level block.
- ((and (eq char-after-ip ?})
- (c-keyword-member containing-decl-kwd
- 'c-other-block-decl-kwds))
- ;; This is inconsistent: Should use `containing-decl-open'
- ;; here if it's at boi, like in case 5J.
- (goto-char containing-decl-start)
- (c-add-stmt-syntax
- (if (string-equal (symbol-name containing-decl-kwd) "extern")
- ;; Special case for compatibility with the
- ;; extern-lang syntactic symbols.
- 'extern-lang-close
- (intern (concat (symbol-name containing-decl-kwd)
- "-close")))
- nil t
- (c-most-enclosing-brace paren-state (point))
- paren-state))
-
- ;; CASE 5G: we are looking at the brace which closes the
- ;; enclosing nested class decl
- ((and containing-sexp
- (eq char-after-ip ?})
- (eq containing-decl-open containing-sexp))
- (c-add-class-syntax 'class-close
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (and (eq (char-after) ?{)
+ (c-looking-at-decl-block containing-sexp t)
+ (setq placeholder (point))))
+ (c-add-syntax 'class-open placeholder))
+
+ ;; CASE 5A.3: brace list open
+ ((save-excursion
+ (c-beginning-of-decl-1 lim)
+ (while (looking-at c-specifier-key)
+ (goto-char (match-end 1))
+ (c-forward-syntactic-ws indent-point))
+ (setq placeholder (c-point 'boi))
+ (or (consp special-brace-list)
+ (and (or (save-excursion
+ (goto-char indent-point)
+ (setq tmpsymbol nil)
+ (while (and (> (point) placeholder)
+ (zerop (c-backward-token-2 1 t))
+ (/= (char-after) ?=))
+ (and c-opt-inexpr-brace-list-key
+ (not tmpsymbol)
+ (looking-at c-opt-inexpr-brace-list-key)
+ (setq tmpsymbol 'topmost-intro-cont)))
+ (eq (char-after) ?=))
+ (looking-at c-brace-list-key))
+ (save-excursion
+ (while (and (< (point) indent-point)
+ (zerop (c-forward-token-2 1 t))
+ (not (memq (char-after) '(?\; ?\()))))
+ (not (memq (char-after) '(?\; ?\()))
+ ))))
+ (if (and (not c-auto-newline-analysis)
+ (c-major-mode-is 'java-mode)
+ (eq tmpsymbol 'topmost-intro-cont))
+ ;; We're in Java and have found that the open brace
+ ;; belongs to a "new Foo[]" initialization list,
+ ;; which means the brace list is part of an
+ ;; expression and not a top level definition. We
+ ;; therefore treat it as any topmost continuation
+ ;; even though the semantically correct symbol still
+ ;; is brace-list-open, on the same grounds as in
+ ;; case B.2.
+ (progn
+ (c-beginning-of-statement-1 lim)
+ (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+ (c-add-syntax 'brace-list-open placeholder)))
+
+ ;; CASE 5A.4: inline defun open
+ ((and containing-decl-open
+ (not (c-keyword-member containing-decl-kwd
+ 'c-other-block-decl-kwds)))
+ (c-add-syntax 'inline-open)
+ (c-add-class-syntax 'inclass
containing-decl-open
containing-decl-start
containing-decl-kwd
paren-state))
- ;; CASE 5H: we could be looking at subsequent knr-argdecls
+ ;; CASE 5A.5: ordinary defun open
+ (t
+ (save-excursion
+ (c-beginning-of-decl-1 lim)
+ (while (looking-at c-specifier-key)
+ (goto-char (match-end 1))
+ (c-forward-syntactic-ws indent-point))
+ (c-add-syntax 'defun-open (c-point 'boi))
+ ;; Bogus to use bol here, but it's the legacy. (Resolved,
+ ;; 2007-11-09)
+ ))))
+
+ ;; CASE 5B: After a function header but before the body (or
+ ;; the ending semicolon if there's no body).
+ ((save-excursion
+ (when (setq placeholder (c-just-after-func-arglist-p lim))
+ (setq tmp-pos (point))))
+ (cond
+
+ ;; CASE 5B.1: Member init list.
+ ((eq (char-after tmp-pos) ?:)
+ (if (or (> tmp-pos indent-point)
+ (= (c-point 'bosws) (1+ tmp-pos)))
+ (progn
+ ;; There is no preceding member init clause.
+ ;; Indent relative to the beginning of indentation
+ ;; for the topmost-intro line that contains the
+ ;; prototype's open paren.
+ (goto-char placeholder)
+ (c-add-syntax 'member-init-intro (c-point 'boi)))
+ ;; Indent relative to the first member init clause.
+ (goto-char (1+ tmp-pos))
+ (c-forward-syntactic-ws)
+ (c-add-syntax 'member-init-cont (point))))
+
+ ;; CASE 5B.2: K&R arg decl intro
((and c-recognize-knr-p
- (not containing-sexp) ; can't be knr inside braces.
- (not (eq char-before-ip ?}))
- (save-excursion
- (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
- (and placeholder
- ;; Do an extra check to avoid tripping up on
- ;; statements that occur in invalid contexts
- ;; (e.g. in macro bodies where we don't really
- ;; know the context of what we're looking at).
- (not (and c-opt-block-stmt-key
- (looking-at c-opt-block-stmt-key)))))
- (< placeholder indent-point))
- (goto-char placeholder)
- (c-add-syntax 'knr-argdecl (point)))
-
- ;; CASE 5I: ObjC method definition.
- ((and c-opt-method-key
- (looking-at c-opt-method-key))
- (c-beginning-of-statement-1 nil t)
- (if (= (point) indent-point)
- ;; Handle the case when it's the first (non-comment)
- ;; thing in the buffer. Can't look for a 'same return
- ;; value from cbos1 since ObjC directives currently
- ;; aren't recognized fully, so that we get 'same
- ;; instead of 'previous if it moved over a preceding
- ;; directive.
- (goto-char (point-min)))
- (c-add-syntax 'objc-method-intro (c-point 'boi)))
-
- ;; CASE 5P: AWK pattern or function or continuation
- ;; thereof.
- ((c-major-mode-is 'awk-mode)
- (setq placeholder (point))
- (c-add-stmt-syntax
- (if (and (eq (c-beginning-of-statement-1) 'same)
- (/= (point) placeholder))
- 'topmost-intro-cont
- 'topmost-intro)
- nil nil
- containing-sexp paren-state))
-
- ;; CASE 5N: At a variable declaration that follows a class
- ;; definition or some other block declaration that doesn't
- ;; end at the closing '}'. C.f. case 5D.5.
- ((progn
- (c-backward-syntactic-ws lim)
- (and (eq (char-before) ?})
+ (c-in-knr-argdecl lim))
+ (c-beginning-of-statement-1 lim)
+ (c-add-syntax 'knr-argdecl-intro (c-point 'boi))
+ (if containing-decl-open
+ (c-add-class-syntax 'inclass
+ containing-decl-open
+ containing-decl-start
+ containing-decl-kwd
+ paren-state)))
+
+ ;; CASE 5B.4: Nether region after a C++ or Java func
+ ;; decl, which could include a `throws' declaration.
+ (t
+ (c-beginning-of-statement-1 lim)
+ (c-add-syntax 'func-decl-cont (c-point 'boi))
+ )))
+
+ ;; CASE 5C: inheritance line. could be first inheritance
+ ;; line, or continuation of a multiple inheritance
+ ((or (and (c-major-mode-is 'c++-mode)
+ (progn
+ (when (eq char-after-ip ?,)
+ (skip-chars-forward " \t")
+ (forward-char))
+ (looking-at c-opt-postfix-decl-spec-key)))
+ (and (or (eq char-before-ip ?:)
+ ;; watch out for scope operator
+ (save-excursion
+ (and (eq char-after-ip ?:)
+ (c-safe (forward-char 1) t)
+ (not (eq (char-after) ?:))
+ )))
(save-excursion
- (let ((start (point)))
- (if (and c-state-cache
- (consp (car c-state-cache))
- (eq (cdar c-state-cache) (point)))
- ;; Speed up the backward search a bit.
- (goto-char (caar c-state-cache)))
- (c-beginning-of-decl-1 containing-sexp)
- (setq placeholder (point))
- (if (= start (point))
- ;; The '}' is unbalanced.
- nil
- (c-end-of-decl-1)
- (>= (point) indent-point))))))
- (goto-char placeholder)
- (c-add-stmt-syntax 'topmost-intro-cont nil nil
- containing-sexp paren-state))
+ (c-backward-syntactic-ws lim)
+ (if (eq char-before-ip ?:)
+ (progn
+ (forward-char -1)
+ (c-backward-syntactic-ws lim)))
+ (back-to-indentation)
+ (looking-at c-class-key)))
+ ;; for Java
+ (and (c-major-mode-is 'java-mode)
+ (let ((fence (save-excursion
+ (c-beginning-of-statement-1 lim)
+ (point)))
+ cont done)
+ (save-excursion
+ (while (not done)
+ (cond ((looking-at c-opt-postfix-decl-spec-key)
+ (setq injava-inher (cons cont (point))
+ done t))
+ ((or (not (c-safe (c-forward-sexp -1) t))
+ (<= (point) fence))
+ (setq done t))
+ )
+ (setq cont t)))
+ injava-inher)
+ (not (c-crosses-statement-barrier-p (cdr injava-inher)
+ (point)))
+ ))
+ (cond
- ;; NOTE: The point is at the end of the previous token here.
+ ;; CASE 5C.1: non-hanging colon on an inher intro
+ ((eq char-after-ip ?:)
+ (c-beginning-of-statement-1 lim)
+ (c-add-syntax 'inher-intro (c-point 'boi))
+ ;; don't add inclass symbol since relative point already
+ ;; contains any class offset
+ )
- ;; CASE 5J: we are at the topmost level, make
- ;; sure we skip back past any access specifiers
- ((and
- ;; A macro continuation line is never at top level.
- (not (and macro-start
- (> indent-point macro-start)))
- (save-excursion
- (setq placeholder (point))
- (or (memq char-before-ip '(?\; ?{ ?} nil))
- (c-at-vsemi-p before-ws-ip)
- (when (and (eq char-before-ip ?:)
- (eq (c-beginning-of-statement-1 lim)
- 'label))
- (c-backward-syntactic-ws lim)
- (setq placeholder (point)))
- (and (c-major-mode-is 'objc-mode)
- (catch 'not-in-directive
- (c-beginning-of-statement-1 lim)
- (setq placeholder (point))
- (while (and (c-forward-objc-directive)
- (< (point) indent-point))
- (c-forward-syntactic-ws)
- (if (>= (point) indent-point)
- (throw 'not-in-directive t))
- (setq placeholder (point)))
- nil)))))
- ;; For historic reasons we anchor at bol of the last
- ;; line of the previous declaration. That's clearly
- ;; highly bogus and useless, and it makes our lives hard
- ;; to remain compatible. :P
- (goto-char placeholder)
- (c-add-syntax 'topmost-intro (c-point 'bol))
+ ;; CASE 5C.2: hanging colon on an inher intro
+ ((eq char-before-ip ?:)
+ (c-beginning-of-statement-1 lim)
+ (c-add-syntax 'inher-intro (c-point 'boi))
(if containing-decl-open
- (if (c-keyword-member containing-decl-kwd
- 'c-other-block-decl-kwds)
- (progn
- (goto-char (c-brace-anchor-point containing-decl-open))
- (c-add-stmt-syntax
- (if (string-equal (symbol-name containing-decl-kwd)
- "extern")
- ;; Special case for compatibility with the
- ;; extern-lang syntactic symbols.
- 'inextern-lang
- (intern (concat "in"
- (symbol-name containing-decl-kwd))))
- nil t
- (c-most-enclosing-brace paren-state (point))
- paren-state))
- (c-add-class-syntax 'inclass
- containing-decl-open
- containing-decl-start
- containing-decl-kwd
- paren-state)))
- (when (and c-syntactic-indentation-in-macros
- macro-start
- (/= macro-start (c-point 'boi indent-point)))
- (c-add-syntax 'cpp-define-intro)
- (setq macro-start nil)))
-
- ;; CASE 5K: we are at an ObjC method definition
- ;; continuation line.
- ((and c-opt-method-key
+ (c-add-class-syntax 'inclass
+ containing-decl-open
+ containing-decl-start
+ containing-decl-kwd
+ paren-state)))
+
+ ;; CASE 5C.3: in a Java implements/extends
+ (injava-inher
+ (let ((where (cdr injava-inher))
+ (cont (car injava-inher)))
+ (goto-char where)
+ (cond ((looking-at "throws\\>[^_]")
+ (c-add-syntax 'func-decl-cont
+ (progn (c-beginning-of-statement-1 lim)
+ (c-point 'boi))))
+ (cont (c-add-syntax 'inher-cont where))
+ (t (c-add-syntax 'inher-intro
+ (progn (goto-char (cdr injava-inher))
+ (c-beginning-of-statement-1 lim)
+ (point))))
+ )))
+
+ ;; CASE 5C.4: a continued inheritance line
+ (t
+ (c-beginning-of-inheritance-list lim)
+ (c-add-syntax 'inher-cont (point))
+ ;; don't add inclass symbol since relative point already
+ ;; contains any class offset
+ )))
+
+ ;; CASE 5D: this could be a top-level initialization, a
+ ;; member init list continuation, or a template argument
+ ;; list continuation.
+ ((save-excursion
+ ;; Note: We use the fact that lim is always after any
+ ;; preceding brace sexp.
+ (if c-recognize-<>-arglists
+ (while (and
+ (progn
+ (c-syntactic-skip-backward "^;,=<>" lim t)
+ (> (point) lim))
+ (or
+ (when c-overloadable-operators-regexp
+ (when (setq placeholder (c-after-special-operator-id lim))
+ (goto-char placeholder)
+ t))
+ (cond
+ ((eq (char-before) ?>)
+ (or (c-backward-<>-arglist nil lim)
+ (backward-char))
+ t)
+ ((eq (char-before) ?<)
+ (backward-char)
+ (if (save-excursion
+ (c-forward-<>-arglist nil))
+ (progn (forward-char)
+ nil)
+ t))
+ (t nil)))))
+ ;; NB: No c-after-special-operator-id stuff in this
+ ;; clause - we assume only C++ needs it.
+ (c-syntactic-skip-backward "^;,=" lim t))
+ (memq (char-before) '(?, ?= ?<)))
+ (cond
+
+ ;; CASE 5D.3: perhaps a template list continuation?
+ ((and (c-major-mode-is 'c++-mode)
+ (save-excursion
+ (save-restriction
+ (c-with-syntax-table c++-template-syntax-table
+ (goto-char indent-point)
+ (setq placeholder (c-up-list-backward))
+ (and placeholder
+ (eq (char-after placeholder) ?<))))))
+ (c-with-syntax-table c++-template-syntax-table
+ (goto-char placeholder)
+ (c-beginning-of-statement-1 lim t)
+ (if (save-excursion
+ (c-backward-syntactic-ws lim)
+ (eq (char-before) ?<))
+ ;; In a nested template arglist.
+ (progn
+ (goto-char placeholder)
+ (c-syntactic-skip-backward "^,;" lim t)
+ (c-forward-syntactic-ws))
+ (back-to-indentation)))
+ ;; FIXME: Should use c-add-stmt-syntax, but it's not yet
+ ;; template aware.
+ (c-add-syntax 'template-args-cont (point) placeholder))
+
+ ;; CASE 5D.4: perhaps a multiple inheritance line?
+ ((and (c-major-mode-is 'c++-mode)
(save-excursion
(c-beginning-of-statement-1 lim)
- (beginning-of-line)
- (when (looking-at c-opt-method-key)
- (setq placeholder (point)))))
- (c-add-syntax 'objc-method-args-cont placeholder))
+ (setq placeholder (point))
+ (if (looking-at "static\\>[^_]")
+ (c-forward-token-2 1 nil indent-point))
+ (and (looking-at c-class-key)
+ (zerop (c-forward-token-2 2 nil indent-point))
+ (if (eq (char-after) ?<)
+ (c-with-syntax-table c++-template-syntax-table
+ (zerop (c-forward-token-2 1 t indent-point)))
+ t)
+ (eq (char-after) ?:))))
+ (goto-char placeholder)
+ (c-add-syntax 'inher-cont (c-point 'boi)))
- ;; CASE 5L: we are at the first argument of a template
+ ;; CASE 5D.5: Continuation of the "expression part" of a
+ ;; top level construct. Or, perhaps, an unrecognized construct.
+ (t
+ (while (and (setq placeholder (point))
+ (eq (car (c-beginning-of-decl-1 containing-sexp))
+ 'same)
+ (save-excursion
+ (c-backward-syntactic-ws)
+ (eq (char-before) ?}))
+ (< (point) placeholder)))
+ (c-add-stmt-syntax
+ (cond
+ ((eq (point) placeholder) 'statement) ; unrecognized construct
+ ;; A preceding comma at the top level means that a
+ ;; new variable declaration starts here. Use
+ ;; topmost-intro-cont for it, for consistency with
+ ;; the first variable declaration. C.f. case 5N.
+ ((eq char-before-ip ?,) 'topmost-intro-cont)
+ (t 'statement-cont))
+ nil nil containing-sexp paren-state))
+ ))
+
+ ;; CASE 5F: Close of a non-class declaration level block.
+ ((and (eq char-after-ip ?})
+ (c-keyword-member containing-decl-kwd
+ 'c-other-block-decl-kwds))
+ ;; This is inconsistent: Should use `containing-decl-open'
+ ;; here if it's at boi, like in case 5J.
+ (goto-char containing-decl-start)
+ (c-add-stmt-syntax
+ (if (string-equal (symbol-name containing-decl-kwd) "extern")
+ ;; Special case for compatibility with the
+ ;; extern-lang syntactic symbols.
+ 'extern-lang-close
+ (intern (concat (symbol-name containing-decl-kwd)
+ "-close")))
+ nil t
+ (c-most-enclosing-brace paren-state (point))
+ paren-state))
+
+ ;; CASE 5G: we are looking at the brace which closes the
+ ;; enclosing nested class decl
+ ((and containing-sexp
+ (eq char-after-ip ?})
+ (eq containing-decl-open containing-sexp))
+ (c-add-class-syntax 'class-close
+ containing-decl-open
+ containing-decl-start
+ containing-decl-kwd
+ paren-state))
+
+ ;; CASE 5H: we could be looking at subsequent knr-argdecls
+ ((and c-recognize-knr-p
+ (not containing-sexp) ; can't be knr inside braces.
+ (not (eq char-before-ip ?}))
+ (save-excursion
+ (setq placeholder (cdr (c-beginning-of-decl-1 lim)))
+ (and placeholder
+ ;; Do an extra check to avoid tripping up on
+ ;; statements that occur in invalid contexts
+ ;; (e.g. in macro bodies where we don't really
+ ;; know the context of what we're looking at).
+ (not (and c-opt-block-stmt-key
+ (looking-at c-opt-block-stmt-key)))))
+ (< placeholder indent-point))
+ (goto-char placeholder)
+ (c-add-syntax 'knr-argdecl (point)))
+
+ ;; CASE 5I: ObjC method definition.
+ ((and c-opt-method-key
+ (looking-at c-opt-method-key))
+ (c-beginning-of-statement-1 nil t)
+ (if (= (point) indent-point)
+ ;; Handle the case when it's the first (non-comment)
+ ;; thing in the buffer. Can't look for a 'same return
+ ;; value from cbos1 since ObjC directives currently
+ ;; aren't recognized fully, so that we get 'same
+ ;; instead of 'previous if it moved over a preceding
+ ;; directive.
+ (goto-char (point-min)))
+ (c-add-syntax 'objc-method-intro (c-point 'boi)))
+
+ ;; CASE 5P: AWK pattern or function or continuation
+ ;; thereof.
+ ((c-major-mode-is 'awk-mode)
+ (setq placeholder (point))
+ (c-add-stmt-syntax
+ (if (and (eq (c-beginning-of-statement-1) 'same)
+ (/= (point) placeholder))
+ 'topmost-intro-cont
+ 'topmost-intro)
+ nil nil
+ containing-sexp paren-state))
+
+ ;; CASE 5N: At a variable declaration that follows a class
+ ;; definition or some other block declaration that doesn't
+ ;; end at the closing '}'. C.f. case 5D.5.
+ ((progn
+ (c-backward-syntactic-ws lim)
+ (and (eq (char-before) ?})
+ (save-excursion
+ (let ((start (point)))
+ (if (and c-state-cache
+ (consp (car c-state-cache))
+ (eq (cdar c-state-cache) (point)))
+ ;; Speed up the backward search a bit.
+ (goto-char (caar c-state-cache)))
+ (c-beginning-of-decl-1 containing-sexp)
+ (setq placeholder (point))
+ (if (= start (point))
+ ;; The '}' is unbalanced.
+ nil
+ (c-end-of-decl-1)
+ (>= (point) indent-point))))))
+ (goto-char placeholder)
+ (c-add-stmt-syntax 'topmost-intro-cont nil nil
+ containing-sexp paren-state))
+
+ ;; NOTE: The point is at the end of the previous token here.
+
+ ;; CASE 5J: we are at the topmost level, make
+ ;; sure we skip back past any access specifiers
+ ((and
+ ;; A macro continuation line is never at top level.
+ (not (and macro-start
+ (> indent-point macro-start)))
+ (save-excursion
+ (setq placeholder (point))
+ (or (memq char-before-ip '(?\; ?{ ?} nil))
+ (c-at-vsemi-p before-ws-ip)
+ (when (and (eq char-before-ip ?:)
+ (eq (c-beginning-of-statement-1 lim)
+ 'label))
+ (c-backward-syntactic-ws lim)
+ (setq placeholder (point)))
+ (and (c-major-mode-is 'objc-mode)
+ (catch 'not-in-directive
+ (c-beginning-of-statement-1 lim)
+ (setq placeholder (point))
+ (while (and (c-forward-objc-directive)
+ (< (point) indent-point))
+ (c-forward-syntactic-ws)
+ (if (>= (point) indent-point)
+ (throw 'not-in-directive t))
+ (setq placeholder (point)))
+ nil)))))
+ ;; For historic reasons we anchor at bol of the last
+ ;; line of the previous declaration. That's clearly
+ ;; highly bogus and useless, and it makes our lives hard
+ ;; to remain compatible. :P
+ (goto-char placeholder)
+ (c-add-syntax 'topmost-intro (c-point 'bol))
+ (if containing-decl-open
+ (if (c-keyword-member containing-decl-kwd
+ 'c-other-block-decl-kwds)
+ (progn
+ (goto-char (c-brace-anchor-point containing-decl-open))
+ (c-add-stmt-syntax
+ (if (string-equal (symbol-name containing-decl-kwd)
+ "extern")
+ ;; Special case for compatibility with the
+ ;; extern-lang syntactic symbols.
+ 'inextern-lang
+ (intern (concat "in"
+ (symbol-name containing-decl-kwd))))
+ nil t
+ (c-most-enclosing-brace paren-state (point))
+ paren-state))
+ (c-add-class-syntax 'inclass
+ containing-decl-open
+ containing-decl-start
+ containing-decl-kwd
+ paren-state)))
+ (when (and c-syntactic-indentation-in-macros
+ macro-start
+ (/= macro-start (c-point 'boi indent-point)))
+ (c-add-syntax 'cpp-define-intro)
+ (setq macro-start nil)))
+
+ ;; CASE 5K: we are at an ObjC method definition
+ ;; continuation line.
+ ((and c-opt-method-key
+ (save-excursion
+ (c-beginning-of-statement-1 lim)
+ (beginning-of-line)
+ (when (looking-at c-opt-method-key)
+ (setq placeholder (point)))))
+ (c-add-syntax 'objc-method-args-cont placeholder))
+
+ ;; CASE 5L: we are at the first argument of a template
;; arglist that begins on the previous line.
((and c-recognize-<>-arglists
(eq (char-before) ?<)
(c-beginning-of-statement-1 containing-sexp)
(c-add-stmt-syntax 'statement nil t containing-sexp paren-state))
- ;;CASE 5N: We are at a tompmost continuation line and the only
- ;;preceding items are annotations.
+ ;;CASE 5N: We are at a tompmost continuation line and the only
+ ;;preceding items are annotations.
((and (c-major-mode-is 'java-mode)
(setq placeholder (point))
- (c-beginning-of-statement-1)
- (progn
+ (c-beginning-of-statement-1)
+ (progn
(while (and (c-forward-annotation))
- (c-forward-syntactic-ws))
- t)
- (prog1
- (>= (point) placeholder)
- (goto-char placeholder)))
- (c-add-syntax 'annotation-top-cont (c-point 'boi)))
+ (c-forward-syntactic-ws))
+ t)
+ (prog1
+ (>= (point) placeholder)
+ (goto-char placeholder)))
+ (c-add-syntax 'annotation-top-cont (c-point 'boi)))
;; CASE 5M: we are at a topmost continuation line
(t
(c-beginning-of-statement-1 (c-safe-position (point) paren-state))
- (when (c-major-mode-is 'objc-mode)
- (setq placeholder (point))
- (while (and (c-forward-objc-directive)
- (< (point) indent-point))
- (c-forward-syntactic-ws)
- (setq placeholder (point)))
- (goto-char placeholder))
- (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
- ))
+ (when (c-major-mode-is 'objc-mode)
+ (setq placeholder (point))
+ (while (and (c-forward-objc-directive)
+ (< (point) indent-point))
+ (c-forward-syntactic-ws)
+ (setq placeholder (point)))
+ (goto-char placeholder))
+ (c-add-syntax 'topmost-intro-cont (c-point 'boi)))
+ ))
;; (CASE 6 has been removed.)
(cond
;; CASE 7A: we are looking at the arglist closing paren.
- ;; C.f. case 7F.
- ((memq char-after-ip '(?\) ?\]))
- (goto-char containing-sexp)
- (setq placeholder (c-point 'boi))
- (if (and (c-safe (backward-up-list 1) t)
- (>= (point) placeholder))
- (progn
- (forward-char)
- (skip-chars-forward " \t"))
- (goto-char placeholder))
- (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
+ ;; C.f. case 7F.
+ ((memq char-after-ip '(?\) ?\]))
+ (goto-char containing-sexp)
+ (setq placeholder (c-point 'boi))
+ (if (and (c-safe (backward-up-list 1) t)
+ (>= (point) placeholder))
+ (progn
+ (forward-char)
+ (skip-chars-forward " \t"))
+ (goto-char placeholder))
+ (c-add-stmt-syntax 'arglist-close (list containing-sexp) t
(c-most-enclosing-brace paren-state (point))
paren-state))
- ;; CASE 19: line is an expression, not a statement, and is directly
- ;; contained by a template delimiter. Most likely, we are in a
- ;; template arglist within a statement. This case is based on CASE
- ;; 7. At some point in the future, we may wish to create more
- ;; syntactic symbols such as `template-intro',
- ;; `template-cont-nonempty', etc., and distinguish between them as we
- ;; do for `arglist-intro' etc. (2009-12-07).
- ((and c-recognize-<>-arglists
- (setq containing-< (c-up-list-backward indent-point containing-sexp))
- (eq (char-after containing-<) ?\<))
- (setq placeholder (c-point 'boi containing-<))
- (goto-char containing-sexp) ; Most nested Lbrace/Lparen (but not
- ; '<') before indent-point.
- (if (>= (point) placeholder)
- (progn
- (forward-char)
- (skip-chars-forward " \t"))
- (goto-char placeholder))
- (c-add-stmt-syntax 'template-args-cont (list containing-<) t
- (c-most-enclosing-brace c-state-cache (point))
- paren-state))
-
;; CASE 7B: Looking at the opening brace of an
;; in-expression block or brace list. C.f. cases 4, 16A
;; and 17E.
- ((and (eq char-after-ip ?{)
- (progn
- (setq placeholder (c-inside-bracelist-p (point)
- paren-state))
- (if placeholder
- (setq tmpsymbol '(brace-list-open . inexpr-class))
- (setq tmpsymbol '(block-open . inexpr-statement)
- placeholder
- (cdr-safe (c-looking-at-inexpr-block
- (c-safe-position containing-sexp
- paren-state)
- containing-sexp)))
- ;; placeholder is nil if it's a block directly in
- ;; a function arglist. That makes us skip out of
- ;; this case.
- )))
- (goto-char placeholder)
- (back-to-indentation)
- (c-add-stmt-syntax (car tmpsymbol) nil t
- (c-most-enclosing-brace paren-state (point))
- paren-state)
- (if (/= (point) placeholder)
- (c-add-syntax (cdr tmpsymbol))))
+ ((and (eq char-after-ip ?{)
+ (progn
+ (setq placeholder (c-inside-bracelist-p (point)
+ paren-state))
+ (if placeholder
+ (setq tmpsymbol '(brace-list-open . inexpr-class))
+ (setq tmpsymbol '(block-open . inexpr-statement)
+ placeholder
+ (cdr-safe (c-looking-at-inexpr-block
+ (c-safe-position containing-sexp
+ paren-state)
+ containing-sexp)))
+ ;; placeholder is nil if it's a block directly in
+ ;; a function arglist. That makes us skip out of
+ ;; this case.
+ )))
+ (goto-char placeholder)
+ (back-to-indentation)
+ (c-add-stmt-syntax (car tmpsymbol) nil t
+ (c-most-enclosing-brace paren-state (point))
+ paren-state)
+ (if (/= (point) placeholder)
+ (c-add-syntax (cdr tmpsymbol))))
+
+ ;; CASE 7C: we are looking at the first argument in an empty
+ ;; argument list. Use arglist-close if we're actually
+ ;; looking at a close paren or bracket.
+ ((memq char-before-ip '(?\( ?\[))
+ (goto-char containing-sexp)
+ (setq placeholder (c-point 'boi))
+ (if (and (c-safe (backward-up-list 1) t)
+ (>= (point) placeholder))
+ (progn
+ (forward-char)
+ (skip-chars-forward " \t"))
+ (goto-char placeholder))
+ (c-add-stmt-syntax 'arglist-intro (list containing-sexp) t
+ (c-most-enclosing-brace paren-state (point))
+ paren-state))
- ;; CASE 7C: we are looking at the first argument in an empty
- ;; argument list. Use arglist-close if we're actually
- ;; looking at a close paren or bracket.
- ((memq char-before-ip '(?\( ?\[))
+ ;; CASE 7D: we are inside a conditional test clause. treat
+ ;; these things as statements
+ ((progn
(goto-char containing-sexp)
- (setq placeholder (c-point 'boi))
- (if (and (c-safe (backward-up-list 1) t)
- (>= (point) placeholder))
- (progn
- (forward-char)
- (skip-chars-forward " \t"))
- (goto-char placeholder))
- (c-add-stmt-syntax 'arglist-intro (list containing-sexp) t
- (c-most-enclosing-brace paren-state (point))
- paren-state))
+ (and (c-safe (c-forward-sexp -1) t)
+ (looking-at "\\<for\\>[^_]")))
+ (goto-char (1+ containing-sexp))
+ (c-forward-syntactic-ws indent-point)
+ (if (eq char-before-ip ?\;)
+ (c-add-syntax 'statement (point))
+ (c-add-syntax 'statement-cont (point))
+ ))
+
+ ;; CASE 7E: maybe a continued ObjC method call. This is the
+ ;; case when we are inside a [] bracketed exp, and what
+ ;; precede the opening bracket is not an identifier.
+ ((and c-opt-method-key
+ (eq (char-after containing-sexp) ?\[)
+ (progn
+ (goto-char (1- containing-sexp))
+ (c-backward-syntactic-ws (c-point 'bod))
+ (if (not (looking-at c-symbol-key))
+ (c-add-syntax 'objc-method-call-cont containing-sexp))
+ )))
- ;; CASE 7D: we are inside a conditional test clause. treat
- ;; these things as statements
- ((progn
- (goto-char containing-sexp)
- (and (c-safe (c-forward-sexp -1) t)
- (looking-at "\\<for\\>[^_]")))
+ ;; CASE 7F: we are looking at an arglist continuation line,
+ ;; but the preceding argument is on the same line as the
+ ;; opening paren. This case includes multi-line
+ ;; mathematical paren groupings, but we could be on a
+ ;; for-list continuation line. C.f. case 7A.
+ ((progn
(goto-char (1+ containing-sexp))
- (c-forward-syntactic-ws indent-point)
- (if (eq char-before-ip ?\;)
- (c-add-syntax 'statement (point))
- (c-add-syntax 'statement-cont (point))
- ))
-
- ;; CASE 7E: maybe a continued ObjC method call. This is the
- ;; case when we are inside a [] bracketed exp, and what
- ;; precede the opening bracket is not an identifier.
- ((and c-opt-method-key
- (eq (char-after containing-sexp) ?\[)
- (progn
- (goto-char (1- containing-sexp))
- (c-backward-syntactic-ws (c-point 'bod))
- (if (not (looking-at c-symbol-key))
- (c-add-syntax 'objc-method-call-cont containing-sexp))
- )))
+ (< (save-excursion
+ (c-forward-syntactic-ws)
+ (point))
+ (c-point 'bonl)))
+ (goto-char containing-sexp) ; paren opening the arglist
+ (setq placeholder (c-point 'boi))
+ (if (and (c-safe (backward-up-list 1) t)
+ (>= (point) placeholder))
+ (progn
+ (forward-char)
+ (skip-chars-forward " \t"))
+ (goto-char placeholder))
+ (c-add-stmt-syntax 'arglist-cont-nonempty (list containing-sexp) t
+ (c-most-enclosing-brace c-state-cache (point))
+ paren-state))
- ;; CASE 7F: we are looking at an arglist continuation line,
- ;; but the preceding argument is on the same line as the
- ;; opening paren. This case includes multi-line
- ;; mathematical paren groupings, but we could be on a
- ;; for-list continuation line. C.f. case 7A.
- ((progn
- (goto-char (1+ containing-sexp))
- (< (save-excursion
- (c-forward-syntactic-ws)
- (point))
- (c-point 'bonl)))
- (goto-char containing-sexp) ; paren opening the arglist
- (setq placeholder (c-point 'boi))
- (if (and (c-safe (backward-up-list 1) t)
- (>= (point) placeholder))
- (progn
- (forward-char)
- (skip-chars-forward " \t"))
- (goto-char placeholder))
- (c-add-stmt-syntax 'arglist-cont-nonempty (list containing-sexp) t
- (c-most-enclosing-brace c-state-cache (point))
- paren-state))
+ ;; CASE 7G: we are looking at just a normal arglist
+ ;; continuation line
+ (t (c-forward-syntactic-ws indent-point)
+ (c-add-syntax 'arglist-cont (c-point 'boi)))
+ ))
- ;; CASE 7G: we are looking at just a normal arglist
- ;; continuation line
- (t (c-forward-syntactic-ws indent-point)
- (c-add-syntax 'arglist-cont (c-point 'boi)))
- ))
+ ;; CASE 8: func-local multi-inheritance line
+ ((and (c-major-mode-is 'c++-mode)
+ (save-excursion
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (looking-at c-opt-postfix-decl-spec-key)))
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+ (cond
- ;; CASE 8: func-local multi-inheritance line
- ((and (c-major-mode-is 'c++-mode)
- (save-excursion
- (goto-char indent-point)
- (skip-chars-forward " \t")
- (looking-at c-opt-postfix-decl-spec-key)))
- (goto-char indent-point)
- (skip-chars-forward " \t")
- (cond
+ ;; CASE 8A: non-hanging colon on an inher intro
+ ((eq char-after-ip ?:)
+ (c-backward-syntactic-ws lim)
+ (c-add-syntax 'inher-intro (c-point 'boi)))
- ;; CASE 8A: non-hanging colon on an inher intro
- ((eq char-after-ip ?:)
- (c-backward-syntactic-ws lim)
- (c-add-syntax 'inher-intro (c-point 'boi)))
+ ;; CASE 8B: hanging colon on an inher intro
+ ((eq char-before-ip ?:)
+ (c-add-syntax 'inher-intro (c-point 'boi)))
- ;; CASE 8B: hanging colon on an inher intro
- ((eq char-before-ip ?:)
- (c-add-syntax 'inher-intro (c-point 'boi)))
+ ;; CASE 8C: a continued inheritance line
+ (t
+ (c-beginning-of-inheritance-list lim)
+ (c-add-syntax 'inher-cont (point))
+ )))
+
+ ;; CASE 9: we are inside a brace-list
+ ((and (not (c-major-mode-is 'awk-mode)) ; Maybe this isn't needed (ACM, 2002/3/29)
+ (setq special-brace-list
+ (or (and c-special-brace-lists ;;;; ALWAYS NIL FOR AWK!!
+ (save-excursion
+ (goto-char containing-sexp)
+ (c-looking-at-special-brace-list)))
+ (c-inside-bracelist-p containing-sexp paren-state))))
+ (cond
- ;; CASE 8C: a continued inheritance line
- (t
- (c-beginning-of-inheritance-list lim)
- (c-add-syntax 'inher-cont (point))
- )))
+ ;; CASE 9A: In the middle of a special brace list opener.
+ ((and (consp special-brace-list)
+ (save-excursion
+ (goto-char containing-sexp)
+ (eq (char-after) ?\())
+ (eq char-after-ip (car (cdr special-brace-list))))
+ (goto-char (car (car special-brace-list)))
+ (skip-chars-backward " \t")
+ (if (and (bolp)
+ (assoc 'statement-cont
+ (setq placeholder (c-guess-basic-syntax))))
+ (setq c-syntactic-context placeholder)
+ (c-beginning-of-statement-1
+ (c-safe-position (1- containing-sexp) paren-state))
+ (c-forward-token-2 0)
+ (while (looking-at c-specifier-key)
+ (goto-char (match-end 1))
+ (c-forward-syntactic-ws))
+ (c-add-syntax 'brace-list-open (c-point 'boi))))
+
+ ;; CASE 9B: brace-list-close brace
+ ((if (consp special-brace-list)
+ ;; Check special brace list closer.
+ (progn
+ (goto-char (car (car special-brace-list)))
+ (save-excursion
+ (goto-char indent-point)
+ (back-to-indentation)
+ (or
+ ;; We were between the special close char and the `)'.
+ (and (eq (char-after) ?\))
+ (eq (1+ (point)) (cdr (car special-brace-list))))
+ ;; We were before the special close char.
+ (and (eq (char-after) (cdr (cdr special-brace-list)))
+ (zerop (c-forward-token-2))
+ (eq (1+ (point)) (cdr (car special-brace-list)))))))
+ ;; Normal brace list check.
+ (and (eq char-after-ip ?})
+ (c-safe (goto-char (c-up-list-backward (point))) t)
+ (= (point) containing-sexp)))
+ (if (eq (point) (c-point 'boi))
+ (c-add-syntax 'brace-list-close (point))
+ (setq lim (c-most-enclosing-brace c-state-cache (point)))
+ (c-beginning-of-statement-1 lim)
+ (c-add-stmt-syntax 'brace-list-close nil t lim paren-state)))
- ;; CASE 9: we are inside a brace-list
- ((and (not (c-major-mode-is 'awk-mode)) ; Maybe this isn't needed (ACM, 2002/3/29)
- (setq special-brace-list
- (or (and c-special-brace-lists ;;;; ALWAYS NIL FOR AWK!!
- (save-excursion
- (goto-char containing-sexp)
- (c-looking-at-special-brace-list)))
- (c-inside-bracelist-p containing-sexp paren-state))))
+ (t
+ ;; Prepare for the rest of the cases below by going to the
+ ;; token following the opening brace
+ (if (consp special-brace-list)
+ (progn
+ (goto-char (car (car special-brace-list)))
+ (c-forward-token-2 1 nil indent-point))
+ (goto-char containing-sexp))
+ (forward-char)
+ (let ((start (point)))
+ (c-forward-syntactic-ws indent-point)
+ (goto-char (max start (c-point 'bol))))
+ (c-skip-ws-forward indent-point)
(cond
- ;; CASE 9A: In the middle of a special brace list opener.
- ((and (consp special-brace-list)
- (save-excursion
- (goto-char containing-sexp)
- (eq (char-after) ?\())
- (eq char-after-ip (car (cdr special-brace-list))))
- (goto-char (car (car special-brace-list)))
- (skip-chars-backward " \t")
- (if (and (bolp)
- (assoc 'statement-cont
- (setq placeholder (c-guess-basic-syntax))))
- (setq c-syntactic-context placeholder)
- (c-beginning-of-statement-1
- (c-safe-position (1- containing-sexp) paren-state))
- (c-forward-token-2 0)
- (while (looking-at c-specifier-key)
- (goto-char (match-end 1))
- (c-forward-syntactic-ws))
- (c-add-syntax 'brace-list-open (c-point 'boi))))
-
- ;; CASE 9B: brace-list-close brace
- ((if (consp special-brace-list)
- ;; Check special brace list closer.
- (progn
- (goto-char (car (car special-brace-list)))
- (save-excursion
- (goto-char indent-point)
- (back-to-indentation)
- (or
- ;; We were between the special close char and the `)'.
- (and (eq (char-after) ?\))
- (eq (1+ (point)) (cdr (car special-brace-list))))
- ;; We were before the special close char.
- (and (eq (char-after) (cdr (cdr special-brace-list)))
- (zerop (c-forward-token-2))
- (eq (1+ (point)) (cdr (car special-brace-list)))))))
- ;; Normal brace list check.
- (and (eq char-after-ip ?})
- (c-safe (goto-char (c-up-list-backward (point))) t)
- (= (point) containing-sexp)))
+ ;; CASE 9C: we're looking at the first line in a brace-list
+ ((= (point) indent-point)
+ (if (consp special-brace-list)
+ (goto-char (car (car special-brace-list)))
+ (goto-char containing-sexp))
(if (eq (point) (c-point 'boi))
- (c-add-syntax 'brace-list-close (point))
+ (c-add-syntax 'brace-list-intro (point))
(setq lim (c-most-enclosing-brace c-state-cache (point)))
(c-beginning-of-statement-1 lim)
- (c-add-stmt-syntax 'brace-list-close nil t lim paren-state)))
+ (c-add-stmt-syntax 'brace-list-intro nil t lim paren-state)))
- (t
- ;; Prepare for the rest of the cases below by going to the
- ;; token following the opening brace
- (if (consp special-brace-list)
- (progn
- (goto-char (car (car special-brace-list)))
- (c-forward-token-2 1 nil indent-point))
- (goto-char containing-sexp))
- (forward-char)
- (let ((start (point)))
- (c-forward-syntactic-ws indent-point)
- (goto-char (max start (c-point 'bol))))
- (c-skip-ws-forward indent-point)
- (cond
+ ;; CASE 9D: this is just a later brace-list-entry or
+ ;; brace-entry-open
+ (t (if (or (eq char-after-ip ?{)
+ (and c-special-brace-lists
+ (save-excursion
+ (goto-char indent-point)
+ (c-forward-syntactic-ws (c-point 'eol))
+ (c-looking-at-special-brace-list (point)))))
+ (c-add-syntax 'brace-entry-open (point))
+ (c-add-syntax 'brace-list-entry (point))
+ ))
+ ))))
+
+ ;; CASE 10: A continued statement or top level construct.
+ ((and (not (memq char-before-ip '(?\; ?:)))
+ (not (c-at-vsemi-p before-ws-ip))
+ (or (not (eq char-before-ip ?}))
+ (c-looking-at-inexpr-block-backward c-state-cache))
+ (> (point)
+ (save-excursion
+ (c-beginning-of-statement-1 containing-sexp)
+ (setq placeholder (point))))
+ (/= placeholder containing-sexp))
+ ;; This is shared with case 18.
+ (c-guess-continued-construct indent-point
+ char-after-ip
+ placeholder
+ containing-sexp
+ paren-state))
+
+ ;; CASE 16: block close brace, possibly closing the defun or
+ ;; the class
+ ((eq char-after-ip ?})
+ ;; From here on we have the next containing sexp in lim.
+ (setq lim (c-most-enclosing-brace paren-state))
+ (goto-char containing-sexp)
+ (cond
- ;; CASE 9C: we're looking at the first line in a brace-list
- ((= (point) indent-point)
- (if (consp special-brace-list)
- (goto-char (car (car special-brace-list)))
- (goto-char containing-sexp))
- (if (eq (point) (c-point 'boi))
- (c-add-syntax 'brace-list-intro (point))
- (setq lim (c-most-enclosing-brace c-state-cache (point)))
- (c-beginning-of-statement-1 lim)
- (c-add-stmt-syntax 'brace-list-intro nil t lim paren-state)))
-
- ;; CASE 9D: this is just a later brace-list-entry or
- ;; brace-entry-open
- (t (if (or (eq char-after-ip ?{)
- (and c-special-brace-lists
- (save-excursion
- (goto-char indent-point)
- (c-forward-syntactic-ws (c-point 'eol))
- (c-looking-at-special-brace-list (point)))))
- (c-add-syntax 'brace-entry-open (point))
- (c-add-syntax 'brace-list-entry (point))
- ))
- ))))
-
- ;; CASE 10: A continued statement or top level construct.
- ((and (not (memq char-before-ip '(?\; ?:)))
- (not (c-at-vsemi-p before-ws-ip))
- (or (not (eq char-before-ip ?}))
- (c-looking-at-inexpr-block-backward c-state-cache))
- (> (point)
- (save-excursion
- (c-beginning-of-statement-1 containing-sexp)
- (setq placeholder (point))))
- (/= placeholder containing-sexp))
- ;; This is shared with case 18.
- (c-guess-continued-construct indent-point
- char-after-ip
- placeholder
- containing-sexp
- paren-state))
-
- ;; CASE 16: block close brace, possibly closing the defun or
- ;; the class
- ((eq char-after-ip ?})
- ;; From here on we have the next containing sexp in lim.
- (setq lim (c-most-enclosing-brace paren-state))
+ ;; CASE 16E: Closing a statement block? This catches
+ ;; cases where it's preceded by a statement keyword,
+ ;; which works even when used in an "invalid" context,
+ ;; e.g. a macro argument.
+ ((c-after-conditional)
+ (c-backward-to-block-anchor lim)
+ (c-add-stmt-syntax 'block-close nil t lim paren-state))
+
+ ;; CASE 16A: closing a lambda defun or an in-expression
+ ;; block? C.f. cases 4, 7B and 17E.
+ ((setq placeholder (c-looking-at-inexpr-block
+ (c-safe-position containing-sexp paren-state)
+ nil))
+ (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+ 'inline-close
+ 'block-close))
(goto-char containing-sexp)
- (cond
+ (back-to-indentation)
+ (if (= containing-sexp (point))
+ (c-add-syntax tmpsymbol (point))
+ (goto-char (cdr placeholder))
+ (back-to-indentation)
+ (c-add-stmt-syntax tmpsymbol nil t
+ (c-most-enclosing-brace paren-state (point))
+ paren-state)
+ (if (/= (point) (cdr placeholder))
+ (c-add-syntax (car placeholder)))))
- ;; CASE 16E: Closing a statement block? This catches
- ;; cases where it's preceded by a statement keyword,
- ;; which works even when used in an "invalid" context,
- ;; e.g. a macro argument.
- ((c-after-conditional)
- (c-backward-to-block-anchor lim)
- (c-add-stmt-syntax 'block-close nil t lim paren-state))
-
- ;; CASE 16A: closing a lambda defun or an in-expression
- ;; block? C.f. cases 4, 7B and 17E.
- ((setq placeholder (c-looking-at-inexpr-block
- (c-safe-position containing-sexp paren-state)
- nil))
- (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
- 'inline-close
- 'block-close))
- (goto-char containing-sexp)
- (back-to-indentation)
- (if (= containing-sexp (point))
- (c-add-syntax tmpsymbol (point))
- (goto-char (cdr placeholder))
- (back-to-indentation)
- (c-add-stmt-syntax tmpsymbol nil t
- (c-most-enclosing-brace paren-state (point))
- paren-state)
- (if (/= (point) (cdr placeholder))
- (c-add-syntax (car placeholder)))))
-
- ;; CASE 16B: does this close an inline or a function in
- ;; a non-class declaration level block?
- ((save-excursion
- (and lim
- (progn
- (goto-char lim)
- (c-looking-at-decl-block
- (c-most-enclosing-brace paren-state lim)
- nil))
- (setq placeholder (point))))
- (c-backward-to-decl-anchor lim)
- (back-to-indentation)
- (if (save-excursion
- (goto-char placeholder)
- (looking-at c-other-decl-block-key))
- (c-add-syntax 'defun-close (point))
- (c-add-syntax 'inline-close (point))))
-
- ;; CASE 16F: Can be a defun-close of a function declared
- ;; in a statement block, e.g. in Pike or when using gcc
- ;; extensions, but watch out for macros followed by
- ;; blocks. Let it through to be handled below.
- ;; C.f. cases B.3 and 17G.
- ((save-excursion
- (and (not (c-at-statement-start-p))
- (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
- (setq placeholder (point))
- (let ((c-recognize-typeless-decls nil))
- ;; Turn off recognition of constructs that
- ;; lacks a type in this case, since that's more
- ;; likely to be a macro followed by a block.
- (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
- (back-to-indentation)
- (if (/= (point) containing-sexp)
- (goto-char placeholder))
- (c-add-stmt-syntax 'defun-close nil t lim paren-state))
-
- ;; CASE 16C: If there is an enclosing brace then this is
- ;; a block close since defun closes inside declaration
- ;; level blocks have been handled above.
- (lim
- ;; If the block is preceded by a case/switch label on
- ;; the same line, we anchor at the first preceding label
- ;; at boi. The default handling in c-add-stmt-syntax
- ;; really fixes it better, but we do like this to keep
- ;; the indentation compatible with version 5.28 and
- ;; earlier. C.f. case 17H.
- (while (and (/= (setq placeholder (point)) (c-point 'boi))
- (eq (c-beginning-of-statement-1 lim) 'label)))
- (goto-char placeholder)
- (if (looking-at c-label-kwds-regexp)
- (c-add-syntax 'block-close (point))
- (goto-char containing-sexp)
- ;; c-backward-to-block-anchor not necessary here; those
- ;; situations are handled in case 16E above.
- (c-add-stmt-syntax 'block-close nil t lim paren-state)))
-
- ;; CASE 16D: Only top level defun close left.
- (t
- (goto-char containing-sexp)
- (c-backward-to-decl-anchor lim)
- (c-add-stmt-syntax 'defun-close nil nil
- (c-most-enclosing-brace paren-state)
- paren-state))
- ))
+ ;; CASE 16B: does this close an inline or a function in
+ ;; a non-class declaration level block?
+ ((save-excursion
+ (and lim
+ (progn
+ (goto-char lim)
+ (c-looking-at-decl-block
+ (c-most-enclosing-brace paren-state lim)
+ nil))
+ (setq placeholder (point))))
+ (c-backward-to-decl-anchor lim)
+ (back-to-indentation)
+ (if (save-excursion
+ (goto-char placeholder)
+ (looking-at c-other-decl-block-key))
+ (c-add-syntax 'defun-close (point))
+ (c-add-syntax 'inline-close (point))))
+
+ ;; CASE 16F: Can be a defun-close of a function declared
+ ;; in a statement block, e.g. in Pike or when using gcc
+ ;; extensions, but watch out for macros followed by
+ ;; blocks. Let it through to be handled below.
+ ;; C.f. cases B.3 and 17G.
+ ((save-excursion
+ (and (not (c-at-statement-start-p))
+ (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
+ (setq placeholder (point))
+ (let ((c-recognize-typeless-decls nil))
+ ;; Turn off recognition of constructs that
+ ;; lacks a type in this case, since that's more
+ ;; likely to be a macro followed by a block.
+ (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+ (back-to-indentation)
+ (if (/= (point) containing-sexp)
+ (goto-char placeholder))
+ (c-add-stmt-syntax 'defun-close nil t lim paren-state))
+
+ ;; CASE 16C: If there is an enclosing brace then this is
+ ;; a block close since defun closes inside declaration
+ ;; level blocks have been handled above.
+ (lim
+ ;; If the block is preceded by a case/switch label on
+ ;; the same line, we anchor at the first preceding label
+ ;; at boi. The default handling in c-add-stmt-syntax
+ ;; really fixes it better, but we do like this to keep
+ ;; the indentation compatible with version 5.28 and
+ ;; earlier. C.f. case 17H.
+ (while (and (/= (setq placeholder (point)) (c-point 'boi))
+ (eq (c-beginning-of-statement-1 lim) 'label)))
+ (goto-char placeholder)
+ (if (looking-at c-label-kwds-regexp)
+ (c-add-syntax 'block-close (point))
+ (goto-char containing-sexp)
+ ;; c-backward-to-block-anchor not necessary here; those
+ ;; situations are handled in case 16E above.
+ (c-add-stmt-syntax 'block-close nil t lim paren-state)))
- ;; CASE 17: Statement or defun catchall.
+ ;; CASE 16D: Only top level defun close left.
(t
- (goto-char indent-point)
- ;; Back up statements until we find one that starts at boi.
- (while (let* ((prev-point (point))
- (last-step-type (c-beginning-of-statement-1
- containing-sexp)))
- (if (= (point) prev-point)
- (progn
- (setq step-type (or step-type last-step-type))
- nil)
- (setq step-type last-step-type)
- (/= (point) (c-point 'boi)))))
- (cond
+ (goto-char containing-sexp)
+ (c-backward-to-decl-anchor lim)
+ (c-add-stmt-syntax 'defun-close nil nil
+ (c-most-enclosing-brace paren-state)
+ paren-state))
+ ))
+
+ ;; CASE 19: line is an expression, not a statement, and is directly
+ ;; contained by a template delimiter. Most likely, we are in a
+ ;; template arglist within a statement. This case is based on CASE
+ ;; 7. At some point in the future, we may wish to create more
+ ;; syntactic symbols such as `template-intro',
+ ;; `template-cont-nonempty', etc., and distinguish between them as we
+ ;; do for `arglist-intro' etc. (2009-12-07).
+ ((and c-recognize-<>-arglists
+ (setq containing-< (c-up-list-backward indent-point containing-sexp))
+ (eq (char-after containing-<) ?\<))
+ (setq placeholder (c-point 'boi containing-<))
+ (goto-char containing-sexp) ; Most nested Lbrace/Lparen (but not
+ ; '<') before indent-point.
+ (if (>= (point) placeholder)
+ (progn
+ (forward-char)
+ (skip-chars-forward " \t"))
+ (goto-char placeholder))
+ (c-add-stmt-syntax 'template-args-cont (list containing-<) t
+ (c-most-enclosing-brace c-state-cache (point))
+ paren-state))
- ;; CASE 17B: continued statement
- ((and (eq step-type 'same)
- (/= (point) indent-point))
- (c-add-stmt-syntax 'statement-cont nil nil
- containing-sexp paren-state))
-
- ;; CASE 17A: After a case/default label?
- ((progn
- (while (and (eq step-type 'label)
- (not (looking-at c-label-kwds-regexp)))
- (setq step-type
- (c-beginning-of-statement-1 containing-sexp)))
- (eq step-type 'label))
- (c-add-stmt-syntax (if (eq char-after-ip ?{)
- 'statement-case-open
- 'statement-case-intro)
- nil t containing-sexp paren-state))
-
- ;; CASE 17D: any old statement
- ((progn
- (while (eq step-type 'label)
- (setq step-type
- (c-beginning-of-statement-1 containing-sexp)))
- (eq step-type 'previous))
- (c-add-stmt-syntax 'statement nil t
- containing-sexp paren-state)
- (if (eq char-after-ip ?{)
- (c-add-syntax 'block-open)))
-
- ;; CASE 17I: Inside a substatement block.
- ((progn
- ;; The following tests are all based on containing-sexp.
- (goto-char containing-sexp)
- ;; From here on we have the next containing sexp in lim.
- (setq lim (c-most-enclosing-brace paren-state containing-sexp))
- (c-after-conditional))
- (c-backward-to-block-anchor lim)
- (c-add-stmt-syntax 'statement-block-intro nil t
- lim paren-state)
- (if (eq char-after-ip ?{)
- (c-add-syntax 'block-open)))
-
- ;; CASE 17E: first statement in an in-expression block.
- ;; C.f. cases 4, 7B and 16A.
- ((setq placeholder (c-looking-at-inexpr-block
- (c-safe-position containing-sexp paren-state)
- nil))
- (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
- 'defun-block-intro
- 'statement-block-intro))
- (back-to-indentation)
- (if (= containing-sexp (point))
- (c-add-syntax tmpsymbol (point))
- (goto-char (cdr placeholder))
- (back-to-indentation)
- (c-add-stmt-syntax tmpsymbol nil t
- (c-most-enclosing-brace c-state-cache (point))
- paren-state)
- (if (/= (point) (cdr placeholder))
- (c-add-syntax (car placeholder))))
- (if (eq char-after-ip ?{)
- (c-add-syntax 'block-open)))
-
- ;; CASE 17F: first statement in an inline, or first
- ;; statement in a top-level defun. we can tell this is it
- ;; if there are no enclosing braces that haven't been
- ;; narrowed out by a class (i.e. don't use bod here).
- ((save-excursion
- (or (not (setq placeholder (c-most-enclosing-brace
- paren-state)))
- (and (progn
- (goto-char placeholder)
- (eq (char-after) ?{))
- (c-looking-at-decl-block (c-most-enclosing-brace
- paren-state (point))
- nil))))
- (c-backward-to-decl-anchor lim)
- (back-to-indentation)
- (c-add-syntax 'defun-block-intro (point)))
+ ;; CASE 17: Statement or defun catchall.
+ (t
+ (goto-char indent-point)
+ ;; Back up statements until we find one that starts at boi.
+ (while (let* ((prev-point (point))
+ (last-step-type (c-beginning-of-statement-1
+ containing-sexp)))
+ (if (= (point) prev-point)
+ (progn
+ (setq step-type (or step-type last-step-type))
+ nil)
+ (setq step-type last-step-type)
+ (/= (point) (c-point 'boi)))))
+ (cond
- ;; CASE 17G: First statement in a function declared inside
- ;; a normal block. This can occur in Pike and with
- ;; e.g. the gcc extensions, but watch out for macros
- ;; followed by blocks. C.f. cases B.3 and 16F.
- ((save-excursion
- (and (not (c-at-statement-start-p))
- (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
- (setq placeholder (point))
- (let ((c-recognize-typeless-decls nil))
- ;; Turn off recognition of constructs that lacks
- ;; a type in this case, since that's more likely
- ;; to be a macro followed by a block.
- (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+ ;; CASE 17B: continued statement
+ ((and (eq step-type 'same)
+ (/= (point) indent-point))
+ (c-add-stmt-syntax 'statement-cont nil nil
+ containing-sexp paren-state))
+
+ ;; CASE 17A: After a case/default label?
+ ((progn
+ (while (and (eq step-type 'label)
+ (not (looking-at c-label-kwds-regexp)))
+ (setq step-type
+ (c-beginning-of-statement-1 containing-sexp)))
+ (eq step-type 'label))
+ (c-add-stmt-syntax (if (eq char-after-ip ?{)
+ 'statement-case-open
+ 'statement-case-intro)
+ nil t containing-sexp paren-state))
+
+ ;; CASE 17D: any old statement
+ ((progn
+ (while (eq step-type 'label)
+ (setq step-type
+ (c-beginning-of-statement-1 containing-sexp)))
+ (eq step-type 'previous))
+ (c-add-stmt-syntax 'statement nil t
+ containing-sexp paren-state)
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'block-open)))
+
+ ;; CASE 17I: Inside a substatement block.
+ ((progn
+ ;; The following tests are all based on containing-sexp.
+ (goto-char containing-sexp)
+ ;; From here on we have the next containing sexp in lim.
+ (setq lim (c-most-enclosing-brace paren-state containing-sexp))
+ (c-after-conditional))
+ (c-backward-to-block-anchor lim)
+ (c-add-stmt-syntax 'statement-block-intro nil t
+ lim paren-state)
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'block-open)))
+
+ ;; CASE 17E: first statement in an in-expression block.
+ ;; C.f. cases 4, 7B and 16A.
+ ((setq placeholder (c-looking-at-inexpr-block
+ (c-safe-position containing-sexp paren-state)
+ nil))
+ (setq tmpsymbol (if (eq (car placeholder) 'inlambda)
+ 'defun-block-intro
+ 'statement-block-intro))
+ (back-to-indentation)
+ (if (= containing-sexp (point))
+ (c-add-syntax tmpsymbol (point))
+ (goto-char (cdr placeholder))
(back-to-indentation)
- (if (/= (point) containing-sexp)
- (goto-char placeholder))
- (c-add-stmt-syntax 'defun-block-intro nil t
- lim paren-state))
+ (c-add-stmt-syntax tmpsymbol nil t
+ (c-most-enclosing-brace c-state-cache (point))
+ paren-state)
+ (if (/= (point) (cdr placeholder))
+ (c-add-syntax (car placeholder))))
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'block-open)))
+
+ ;; CASE 17F: first statement in an inline, or first
+ ;; statement in a top-level defun. we can tell this is it
+ ;; if there are no enclosing braces that haven't been
+ ;; narrowed out by a class (i.e. don't use bod here).
+ ((save-excursion
+ (or (not (setq placeholder (c-most-enclosing-brace
+ paren-state)))
+ (and (progn
+ (goto-char placeholder)
+ (eq (char-after) ?{))
+ (c-looking-at-decl-block (c-most-enclosing-brace
+ paren-state (point))
+ nil))))
+ (c-backward-to-decl-anchor lim)
+ (back-to-indentation)
+ (c-add-syntax 'defun-block-intro (point)))
- ;; CASE 17H: First statement in a block.
- (t
- ;; If the block is preceded by a case/switch label on the
- ;; same line, we anchor at the first preceding label at
- ;; boi. The default handling in c-add-stmt-syntax is
- ;; really fixes it better, but we do like this to keep the
- ;; indentation compatible with version 5.28 and earlier.
- ;; C.f. case 16C.
- (while (and (/= (setq placeholder (point)) (c-point 'boi))
- (eq (c-beginning-of-statement-1 lim) 'label)))
- (goto-char placeholder)
- (if (looking-at c-label-kwds-regexp)
- (c-add-syntax 'statement-block-intro (point))
- (goto-char containing-sexp)
- ;; c-backward-to-block-anchor not necessary here; those
- ;; situations are handled in case 17I above.
- (c-add-stmt-syntax 'statement-block-intro nil t
- lim paren-state))
- (if (eq char-after-ip ?{)
- (c-add-syntax 'block-open)))
- ))
- )
+ ;; CASE 17G: First statement in a function declared inside
+ ;; a normal block. This can occur in Pike and with
+ ;; e.g. the gcc extensions, but watch out for macros
+ ;; followed by blocks. C.f. cases B.3 and 16F.
+ ((save-excursion
+ (and (not (c-at-statement-start-p))
+ (eq (c-beginning-of-statement-1 lim nil nil t) 'same)
+ (setq placeholder (point))
+ (let ((c-recognize-typeless-decls nil))
+ ;; Turn off recognition of constructs that lacks
+ ;; a type in this case, since that's more likely
+ ;; to be a macro followed by a block.
+ (c-forward-decl-or-cast-1 (c-point 'bosws) nil nil))))
+ (back-to-indentation)
+ (if (/= (point) containing-sexp)
+ (goto-char placeholder))
+ (c-add-stmt-syntax 'defun-block-intro nil t
+ lim paren-state))
- ;; now we need to look at any modifiers
- (goto-char indent-point)
- (skip-chars-forward " \t")
+ ;; CASE 17H: First statement in a block.
+ (t
+ ;; If the block is preceded by a case/switch label on the
+ ;; same line, we anchor at the first preceding label at
+ ;; boi. The default handling in c-add-stmt-syntax is
+ ;; really fixes it better, but we do like this to keep the
+ ;; indentation compatible with version 5.28 and earlier.
+ ;; C.f. case 16C.
+ (while (and (/= (setq placeholder (point)) (c-point 'boi))
+ (eq (c-beginning-of-statement-1 lim) 'label)))
+ (goto-char placeholder)
+ (if (looking-at c-label-kwds-regexp)
+ (c-add-syntax 'statement-block-intro (point))
+ (goto-char containing-sexp)
+ ;; c-backward-to-block-anchor not necessary here; those
+ ;; situations are handled in case 17I above.
+ (c-add-stmt-syntax 'statement-block-intro nil t
+ lim paren-state))
+ (if (eq char-after-ip ?{)
+ (c-add-syntax 'block-open)))
+ ))
+ )
+
+ ;; now we need to look at any modifiers
+ (goto-char indent-point)
+ (skip-chars-forward " \t")
+
+ ;; are we looking at a comment only line?
+ (when (and (looking-at c-comment-start-regexp)
+ (/= (c-forward-token-2 0 nil (c-point 'eol)) 0))
+ (c-append-syntax 'comment-intro))
+
+ ;; we might want to give additional offset to friends (in C++).
+ (when (and c-opt-friend-key
+ (looking-at c-opt-friend-key))
+ (c-append-syntax 'friend))
+
+ ;; Set syntactic-relpos.
+ (let ((p c-syntactic-context))
+ (while (and p
+ (if (integerp (c-langelem-pos (car p)))
+ (progn
+ (setq syntactic-relpos (c-langelem-pos (car p)))
+ nil)
+ t))
+ (setq p (cdr p))))
- ;; are we looking at a comment only line?
- (when (and (looking-at c-comment-start-regexp)
- (/= (c-forward-token-2 0 nil (c-point 'eol)) 0))
- (c-append-syntax 'comment-intro))
-
- ;; we might want to give additional offset to friends (in C++).
- (when (and c-opt-friend-key
- (looking-at c-opt-friend-key))
- (c-append-syntax 'friend))
-
- ;; Set syntactic-relpos.
- (let ((p c-syntactic-context))
- (while (and p
- (if (integerp (c-langelem-pos (car p)))
- (progn
- (setq syntactic-relpos (c-langelem-pos (car p)))
- nil)
- t))
- (setq p (cdr p))))
-
- ;; Start of or a continuation of a preprocessor directive?
- (if (and macro-start
- (eq macro-start (c-point 'boi))
- (not (and (c-major-mode-is 'pike-mode)
- (eq (char-after (1+ macro-start)) ?\"))))
- (c-append-syntax 'cpp-macro)
- (when (and c-syntactic-indentation-in-macros macro-start)
- (if in-macro-expr
- (when (or
- (< syntactic-relpos macro-start)
- (not (or
- (assq 'arglist-intro c-syntactic-context)
- (assq 'arglist-cont c-syntactic-context)
- (assq 'arglist-cont-nonempty c-syntactic-context)
- (assq 'arglist-close c-syntactic-context))))
- ;; If inside a cpp expression, i.e. anywhere in a
- ;; cpp directive except a #define body, we only let
- ;; through the syntactic analysis that is internal
- ;; in the expression. That means the arglist
- ;; elements, if they are anchored inside the cpp
- ;; expression.
- (setq c-syntactic-context nil)
- (c-add-syntax 'cpp-macro-cont macro-start))
- (when (and (eq macro-start syntactic-relpos)
- (not (assq 'cpp-define-intro c-syntactic-context))
- (save-excursion
- (goto-char macro-start)
- (or (not (c-forward-to-cpp-define-body))
- (<= (point) (c-point 'boi indent-point)))))
- ;; Inside a #define body and the syntactic analysis is
- ;; anchored on the start of the #define. In this case
- ;; we add cpp-define-intro to get the extra
- ;; indentation of the #define body.
- (c-add-syntax 'cpp-define-intro)))))
-
- ;; return the syntax
- c-syntactic-context)))
+ ;; Start of or a continuation of a preprocessor directive?
+ (if (and macro-start
+ (eq macro-start (c-point 'boi))
+ (not (and (c-major-mode-is 'pike-mode)
+ (eq (char-after (1+ macro-start)) ?\"))))
+ (c-append-syntax 'cpp-macro)
+ (when (and c-syntactic-indentation-in-macros macro-start)
+ (if in-macro-expr
+ (when (or
+ (< syntactic-relpos macro-start)
+ (not (or
+ (assq 'arglist-intro c-syntactic-context)
+ (assq 'arglist-cont c-syntactic-context)
+ (assq 'arglist-cont-nonempty c-syntactic-context)
+ (assq 'arglist-close c-syntactic-context))))
+ ;; If inside a cpp expression, i.e. anywhere in a
+ ;; cpp directive except a #define body, we only let
+ ;; through the syntactic analysis that is internal
+ ;; in the expression. That means the arglist
+ ;; elements, if they are anchored inside the cpp
+ ;; expression.
+ (setq c-syntactic-context nil)
+ (c-add-syntax 'cpp-macro-cont macro-start))
+ (when (and (eq macro-start syntactic-relpos)
+ (not (assq 'cpp-define-intro c-syntactic-context))
+ (save-excursion
+ (goto-char macro-start)
+ (or (not (c-forward-to-cpp-define-body))
+ (<= (point) (c-point 'boi indent-point)))))
+ ;; Inside a #define body and the syntactic analysis is
+ ;; anchored on the start of the #define. In this case
+ ;; we add cpp-define-intro to get the extra
+ ;; indentation of the #define body.
+ (c-add-syntax 'cpp-define-intro)))))
+
+ ;; return the syntax
+ c-syntactic-context)))
\f
;; Indentation calculation.
\f
(cc-provide 'cc-engine)
-;; arch-tag: 149add18-4673-4da5-ac47-6805e4eae089
;;; cc-engine.el ends here
HCoop / bpt / emacs.git / blobdiff