1 ;;; cc-align.el --- custom indentation functions for CC Mode
3 ;; Copyright (C) 1985,1987,1992-2003, 2004, 2005 Free Software Foundation, Inc.
5 ;; Authors: 1998- Martin Stjernholm
6 ;; 1992-1999 Barry A. Warsaw
7 ;; 1987 Dave Detlefs and Stewart Clamen
8 ;; 1985 Richard M. Stallman
9 ;; Maintainer: bug-cc-mode@gnu.org
10 ;; Created: 22-Apr-1997 (split from cc-mode.el)
11 ;; Version: See cc-mode.el
12 ;; Keywords: c languages oop
14 ;; This file is part of GNU Emacs.
16 ;; GNU Emacs is free software; you can redistribute it and/or modify
17 ;; it under the terms of the GNU General Public License as published by
18 ;; the Free Software Foundation; either version 2, or (at your option)
21 ;; GNU Emacs is distributed in the hope that it will be useful,
22 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 ;; GNU General Public License for more details.
26 ;; You should have received a copy of the GNU General Public License
27 ;; along with this program; see the file COPYING. If not, write to
28 ;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
29 ;; Boston, MA 02110-1301, USA.
37 (if (and (boundp 'byte-compile-dest-file)
38 (stringp byte-compile-dest-file))
39 (cons (file-name-directory byte-compile-dest-file) load-path)
41 (load "cc-bytecomp" nil t)))
45 (cc-require 'cc-engine)
48 ;; Standard line-up functions
50 ;; See the section "Custom Indentation Functions" in the manual for
51 ;; details on the calling convention.
53 (defun c-lineup-topmost-intro-cont (langelem)
54 "Line up declaration continuation lines zero or one indentation step.
55 For lines in the \"header\" of a definition, zero is used. For other
56 lines, `c-basic-offset' is added to the indentation. E.g:
59 neg (int i) <- c-lineup-topmost-intro-cont
65 larch <- c-lineup-topmost-intro-cont
69 the_larch, <- c-lineup-topmost-intro-cont
70 another_larch; <- c-lineup-topmost-intro-cont
74 the_larch, <- c-lineup-topmost-intro-cont
75 another_larch; <- c-lineup-topmost-intro-cont
77 \(This function is mainly provided to mimic the behavior of CC Mode
78 5.28 and earlier where this case wasn't handled consistently so that
79 these lines could be analyzed as either topmost-intro-cont or
82 Works with: topmost-intro-cont."
85 (c-backward-syntactic-ws (c-langelem-pos langelem))
86 (if (and (memq (char-before) '(?} ?,))
87 (not (and c-overloadable-operators-regexp
88 (c-after-special-operator-id))))
91 (defun c-block-in-arglist-dwim (arglist-start)
92 ;; This function implements the DWIM to avoid far indentation of
93 ;; brace block constructs in arguments in `c-lineup-arglist' etc.
94 ;; Return non-nil if a brace block construct is detected within the
95 ;; arglist starting at ARGLIST-START.
98 ;; Check if the syntactic context contains any of the symbols for
99 ;; in-expression constructs. This can both save the work that we
100 ;; have to do below, and it also detect the brace list constructs
101 ;; that `c-looking-at-inexpr-block' currently misses (they are
102 ;; recognized by `c-inside-bracelist-p' instead).
103 (assq 'inexpr-class c-syntactic-context)
104 (assq 'inexpr-statement c-syntactic-context)
105 (assq 'inlambda c-syntactic-context)
108 ;; Search for open braces from the arglist start to the end of the
110 (narrow-to-region arglist-start (c-point 'eol arglist-start))
112 (goto-char arglist-start)
113 (while (and (c-syntactic-re-search-forward "{" nil t)
117 ;; Ignore starts of special brace lists.
118 (and c-special-brace-lists
121 (c-looking-at-special-brace-list)))
122 ;; Ignore complete blocks.
123 (c-safe (c-forward-sexp) t))))
128 (let (containing-sexp)
129 (goto-char arglist-start)
130 ;; `c-syntactic-eol' always matches somewhere on the line.
131 (re-search-forward c-syntactic-eol)
132 (goto-char (match-beginning 0))
133 (c-forward-syntactic-ws)
134 (setq containing-sexp (c-most-enclosing-brace (c-parse-state)))
135 (c-looking-at-inexpr-block
136 (c-safe-position (or containing-sexp (point)) c-state-cache)
139 (defun c-lineup-arglist (langelem)
140 "Line up the current argument line under the first argument.
142 As a special case, if the indented line is inside a brace block
143 construct, the indentation is `c-basic-offset' only. This is intended
144 as a \"DWIM\" measure in cases like macros that contains statement
147 A_VERY_LONG_MACRO_NAME ({
148 some (code, with + long, lines * in[it]);
152 This is motivated partly because it's more in line with how code
153 blocks are handled, and partly since it approximates the behavior of
154 earlier CC Mode versions, which due to inaccurate analysis tended to
155 indent such cases this way.
157 Works with: arglist-cont-nonempty, arglist-close."
159 (let ((indent-pos (point)))
161 (if (c-block-in-arglist-dwim (c-langelem-2nd-pos c-syntactic-element))
162 c-basic-offset ; DWIM case.
164 ;; Normal case. Indent to the token after the arglist open paren.
165 (goto-char (c-langelem-2nd-pos c-syntactic-element))
166 (if (and c-special-brace-lists
167 (c-looking-at-special-brace-list))
168 ;; Skip a special brace list opener like "({".
169 (progn (c-forward-token-2)
172 (let ((arglist-content-start (point)))
173 (c-forward-syntactic-ws)
174 (when (< (point) indent-pos)
175 (goto-char arglist-content-start)
176 (skip-chars-forward " \t"))
177 (vector (current-column)))))))
179 ;; Contributed by Kevin Ryde <user42@zip.com.au>.
180 (defun c-lineup-argcont (elem)
181 "Line up a continued argument.
183 foo (xyz, aaa + bbb + ccc
184 + ddd + eee + fff); <- c-lineup-argcont
186 Only continuation lines like this are touched, nil is returned on lines
187 which are the start of an argument.
189 Within a gcc asm block, \":\" is recognized as an argument separator,
190 but of course only between operand specifications, not in the expressions
193 Works with: arglist-cont, arglist-cont-nonempty."
198 (when (eq (car elem) 'arglist-cont-nonempty)
199 ;; Our argument list might not be the innermost one. If it
200 ;; isn't, go back to the last position in it. We do this by
201 ;; stepping back over open parens until we get to the open paren
202 ;; of our argument list.
203 (let ((open-paren (c-langelem-2nd-pos c-syntactic-element))
204 (paren-state (c-parse-state)))
205 (while (not (eq (car paren-state) open-paren))
206 (unless (consp (car paren-state)) ;; ignore matched braces
207 (goto-char (car paren-state)))
208 (setq paren-state (cdr paren-state)))))
210 (let ((start (point)) c)
213 ;; Previous line ending in a comma means we're the start of an
214 ;; argument. This should quickly catch most cases not for us.
215 ;; This case is only applicable if we're the innermost arglist.
216 (c-backward-syntactic-ws)
217 (setq c (char-before)))
220 ;; In a gcc asm, ":" on the previous line means the start of an
221 ;; argument. And lines starting with ":" are not for us, don't
222 ;; want them to indent to the preceding operand.
223 (let ((gcc-asm (save-excursion
230 (looking-at "[ \t]*:"))))
232 (c-lineup-argcont-scan (if gcc-asm ?:))
233 (vector (current-column))))))))
235 (defun c-lineup-argcont-scan (&optional other-match)
236 ;; Find the start of an argument, for `c-lineup-argcont'.
237 (when (zerop (c-backward-token-2 1 t))
238 (let ((c (char-after)))
239 (if (or (eq c ?,) (eq c other-match))
242 (c-forward-syntactic-ws))
243 (c-lineup-argcont-scan other-match)))))
245 (defun c-lineup-arglist-intro-after-paren (langelem)
246 "Line up a line to just after the open paren of the surrounding paren
249 Works with: defun-block-intro, brace-list-intro,
250 statement-block-intro, statement-case-intro, arglist-intro."
254 (skip-chars-forward " \t" (c-point 'eol))
255 (vector (1+ (current-column)))))
257 (defun c-lineup-arglist-close-under-paren (langelem)
258 "Line up a line under the enclosing open paren.
259 Normally used to line up a closing paren in the same column as its
260 corresponding open paren, but can also be used with arglist-cont and
261 arglist-cont-nonempty to line up all lines inside a parenthesis under
264 As a special case, if a brace block construct starts at the same line
265 as the open parenthesis of the argument list, the indentation is
266 `c-basic-offset' only. See `c-lineup-arglist' for further discussion
267 of this \"DWIM\" measure.
269 Works with: Almost all symbols, but are typically most useful on
270 arglist-close, brace-list-close, arglist-cont and arglist-cont-nonempty."
272 (if (memq (c-langelem-sym langelem)
273 '(arglist-cont-nonempty arglist-close))
274 (goto-char (c-langelem-2nd-pos c-syntactic-element))
276 (c-go-up-list-backward))
278 (if (save-excursion (c-block-in-arglist-dwim (point)))
279 c-basic-offset ; DWIM case.
281 ;; Normal case. Indent to the arglist open paren.
283 (if (and c-special-brace-lists
284 (setq special-list (c-looking-at-special-brace-list)))
285 ;; Cope if we're in the middle of a special brace list
287 (goto-char (car (car special-list))))
288 (vector (current-column))))))
290 (defun c-lineup-arglist-operators (langelem)
291 "Line up lines starting with an infix operator under the open paren.
292 Return nil on lines that don't start with an operator, to leave those
293 cases to other line-up functions. Example:
296 || at_limit (x, <- c-lineup-arglist-operators
297 list) <- c-lineup-arglist-operators returns nil
300 Since this function doesn't do anything for lines without an infix
301 operator you typically want to use it together with some other line-up
302 settings, e.g. as follows \(the arglist-close setting is just a
303 suggestion to get a consistent style):
305 \(c-set-offset 'arglist-cont '(c-lineup-arglist-operators 0))
306 \(c-set-offset 'arglist-cont-nonempty '(c-lineup-arglist-operators
308 \(c-set-offset 'arglist-close '(c-lineup-arglist-close-under-paren))
310 Works with: arglist-cont, arglist-cont-nonempty."
312 (back-to-indentation)
313 (when (looking-at "[-+|&*%<>=]\\|\\(/[^/*]\\)")
314 ;; '-' can be both an infix and a prefix operator, but I'm lazy now..
315 (c-lineup-arglist-close-under-paren langelem))))
317 (defun c-lineup-close-paren (langelem)
318 "Line up the closing paren under its corresponding open paren if the
319 open paren is followed by code. If the open paren ends its line, no
320 indentation is added. E.g:
324 ) <-> ) <- c-lineup-close-paren
326 As a special case, if a brace block construct starts at the same line
327 as the open parenthesis of the argument list, the indentation is
328 `c-basic-offset' instead of the open paren column. See
329 `c-lineup-arglist' for further discussion of this \"DWIM\" measure.
331 Works with: All *-close symbols."
333 (if (memq (c-langelem-sym langelem)
334 '(arglist-cont-nonempty arglist-close))
335 (goto-char (c-langelem-2nd-pos c-syntactic-element))
337 (c-go-up-list-backward))
339 (let (special-list arglist-start)
340 (if (and c-special-brace-lists
341 (setq special-list (c-looking-at-special-brace-list)))
342 ;; Cope if we're in the middle of a special brace list
345 (goto-char (setq arglist-start (car (car special-list))))
348 (setq arglist-start (point))
351 (cond ((looking-at c-syntactic-eol)
352 0) ; The arglist is "empty".
354 ((c-block-in-arglist-dwim (point))
355 c-basic-offset) ; DWIM case.
358 ;; Normal case. Indent to the arglist open paren.
359 (goto-char arglist-start)
360 (vector (current-column)))))))
362 (defun c-lineup-streamop (langelem)
363 "Line up C++ stream operators under each other.
365 Works with: stream-op."
367 (goto-char (c-langelem-pos langelem))
368 (re-search-forward "<<\\|>>" (c-point 'eol) 'move)
369 (goto-char (match-beginning 0))
370 (vector (current-column))))
372 (defun c-lineup-multi-inher (langelem)
373 "Line up the classes in C++ multiple inheritance clauses and member
374 initializers under each other. E.g:
376 class Foo: Foo::Foo (int a, int b):
377 public Cyphr, Cyphr (a),
378 public Bar <-> Bar (b) <- c-lineup-multi-inher
380 class Foo Foo::Foo (int a, int b)
381 : public Cyphr, : Cyphr (a),
382 public Bar <-> Bar (b) <- c-lineup-multi-inher
384 class Foo Foo::Foo (int a, int b)
385 : public Cyphr : Cyphr (a)
386 , public Bar <-> , Bar (b) <- c-lineup-multi-inher
388 Works with: inher-cont, member-init-cont."
390 (back-to-indentation)
391 (let* ((eol (c-point 'eol))
393 (char-after-ip (char-after)))
394 (if (c-langelem-pos langelem)
395 (goto-char (c-langelem-pos langelem)))
397 ;; This kludge is necessary to support both inher-cont and
398 ;; member-init-cont, since they have different anchor positions.
399 (c-backward-syntactic-ws)
400 (when (eq (char-before) ?:)
402 (c-backward-syntactic-ws))
404 (c-syntactic-re-search-forward ":" eol 'move)
405 (if (looking-at c-syntactic-eol)
406 (c-forward-syntactic-ws here)
407 (if (eq char-after-ip ?,)
409 (skip-chars-forward " \t" eol)))
411 (vector (current-column)))
414 (defun c-lineup-java-inher (langelem)
415 "Line up Java implements and extends declarations.
416 If class names follow on the same line as the implements/extends
417 keyword, they are lined up under each other. Otherwise, they are
418 indented by adding `c-basic-offset' to the column of the keyword.
422 extends extends Cyphr,
423 Bar <-> Bar <- c-lineup-java-inher
426 Works with: inher-cont."
428 (goto-char (c-langelem-pos langelem))
430 (if (looking-at "[ \t]*$")
432 (c-forward-syntactic-ws)
433 (vector (current-column)))))
435 (defun c-lineup-java-throws (langelem)
436 "Line up Java throws declarations.
437 If exception names follow on the same line as the throws keyword,
438 they are lined up under each other. Otherwise, they are indented by
439 adding `c-basic-offset' to the column of the throws keyword. The
440 throws keyword itself is also indented by `c-basic-offset' from the
441 function declaration start if it doesn't hang. E.g:
443 int foo() int foo() throws Cyphr,
444 throws <-> Bar, <- c-lineup-java-throws
445 Bar <-> Vlod <- c-lineup-java-throws
446 <--><--> c-basic-offset
448 Works with: func-decl-cont."
450 (let* ((lim (1- (c-point 'bol)))
452 (goto-char (c-langelem-pos langelem))
453 (while (zerop (c-forward-token-2 1 t lim))
454 (if (looking-at "throws\\>[^_]")
457 (if (zerop (c-forward-token-2 1 nil (c-point 'eol)))
458 (vector (current-column))
459 (back-to-indentation)
460 (vector (+ (current-column) c-basic-offset)))
463 (defun c-indent-one-line-block (langelem)
464 "Indent a one line block `c-basic-offset' extra.
467 if (n > 0) if (n > 0)
468 {m+=n; n=0;} <-> { <- c-indent-one-line-block
469 <--> c-basic-offset m+=n; n=0;
472 The block may use any kind of parenthesis character. nil is returned
473 if the line doesn't start with a one line block, which makes the
474 function usable in list expressions.
476 Work with: Almost all syntactic symbols, but most useful on *-open."
478 (let ((eol (c-point 'eol)))
479 (back-to-indentation)
480 (if (and (eq (char-syntax (char-after)) ?\()
481 (c-safe (progn (c-forward-sexp) t))
486 (defun c-indent-multi-line-block (langelem)
487 "Indent a multi line block `c-basic-offset' extra.
490 int *foo[] = { int *foo[] = {
492 {17}, <-> { <- c-indent-multi-line-block
497 The block may use any kind of parenthesis character. nil is returned
498 if the line doesn't start with a multi line block, which makes the
499 function usable in list expressions.
501 Work with: Almost all syntactic symbols, but most useful on *-open."
503 (let ((eol (c-point 'eol)))
504 (back-to-indentation)
505 (if (and (eq (char-syntax (char-after)) ?\()
506 (or (not (c-safe (progn (c-forward-sexp) t)))
511 (defun c-lineup-C-comments (langelem)
512 "Line up C block comment continuation lines.
513 Various heuristics are used to handle many of the common comment
514 styles. Some examples:
516 /* /** /* /* text /* /**
517 * text * text text text ** text ** text
520 /*********************************************************************
522 ********************************************************************/
524 /*********************************************************************
525 Free form text comments:
526 In comments with a long delimiter line at the start, the indentation
527 is kept unchanged for lines that start with an empty comment line
528 prefix. The delimiter line is whatever matches the
529 `comment-start-skip' regexp.
530 *********************************************************************/
532 The variable `c-comment-prefix-regexp' is used to recognize the
533 comment line prefix, e.g. the `*' that usually starts every line
536 Works with: The `c' syntactic symbol."
538 (let* ((here (point))
539 (prefixlen (progn (back-to-indentation)
540 (if (looking-at c-current-comment-prefix)
541 (- (match-end 0) (point))
544 ;; Get the length of the comment starter, not including
545 ;; the first '/'. We check if the comment prefix matched
546 ;; on the current line matches the starter or if it
547 ;; matches comment-start-skip, and choose whichever is
550 (goto-char (1+ (c-langelem-pos langelem)))
551 (if (and (match-string 0)
552 (looking-at (regexp-quote (match-string 0))))
553 (- (match-end 0) (match-beginning 0))
556 (goto-char (c-langelem-pos langelem))
557 (looking-at comment-start-skip)
560 (goto-char (match-end 0))
561 (skip-chars-backward " \t")
565 (if (and (> starterlen 10) (zerop prefixlen))
566 ;; The comment has a long starter and the line doesn't have
567 ;; a nonempty comment prefix. Treat it as free form text
568 ;; and don't change the indentation.
569 (vector (current-column))
570 ;; Go back to the previous non-blank line, if any.
574 (back-to-indentation)
575 (and (> (point) (c-langelem-pos langelem))
576 (looking-at "[ \t]*$"))))
577 ;; Is the starting line the first continuation line with content?
578 (if (>= (c-langelem-pos langelem) (point))
579 (if (zerop prefixlen)
580 ;; No nonempty comment prefix. Align after comment
583 (looking-at comment-start-skip)
584 (goto-char (match-end 0))
585 ;; The following should not be necessary, since
586 ;; comment-start-skip should match everything (i.e.
587 ;; typically whitespace) that leads up to the text.
588 ;;(if (looking-at "\\([ \t]+\\).+$")
589 ;; ;; Align with the text that hangs after the
590 ;; ;; comment starter.
591 ;; (goto-char (match-end 1)))
592 (vector (current-column)))
593 ;; How long is the comment starter? if greater than the
594 ;; length of the comment prefix, align left. if less
595 ;; than or equal, align right. this should also pick up
596 ;; Javadoc style comments.
597 (if (> starterlen prefixlen)
599 (goto-char (c-langelem-pos langelem))
600 (vector (1+ (current-column))))
601 (goto-char (+ (c-langelem-pos langelem) starterlen 1))
602 (vector (- (current-column) prefixlen))))
603 ;; We didn't start on the first non-blank continuation line. If the
604 ;; previous line has a nonempty comment prefix, align with it.
605 ;; Otherwise, align with the previous nonempty line, but align the
606 ;; comment ender with the starter.
607 (when (or (not (looking-at c-current-comment-prefix))
608 (eq (match-beginning 0) (match-end 0)))
610 (back-to-indentation)
611 (if (looking-at (concat "\\(" c-current-comment-prefix "\\)\\*/"))
612 (goto-char (c-langelem-pos langelem))
613 (while (and (zerop (forward-line -1))
614 (looking-at "^[ \t]*$")))
615 (back-to-indentation)
616 (if (< (point) (c-langelem-pos langelem))
617 ;; Align with the comment starter rather than
618 ;; with the code before it.
619 (goto-char (c-langelem-pos langelem)))))
620 (vector (current-column)))))))
622 (defun c-lineup-comment (langelem)
623 "Line up a comment start according to `c-comment-only-line-offset'.
624 If the comment is lined up with a comment starter on the previous
625 line, that alignment is preserved.
627 Works with: comment-intro."
629 (back-to-indentation)
630 (let ((col (current-column)))
632 ;; CASE 1: preserve aligned comments
634 (and (c-backward-single-comment)
635 (= col (current-column))))
636 (vector col)) ; Return an absolute column.
637 ;; indent as specified by c-comment-only-line-offset
639 (or (car-safe c-comment-only-line-offset)
640 c-comment-only-line-offset))
642 (or (cdr-safe c-comment-only-line-offset)
643 (car-safe c-comment-only-line-offset)
644 -1000)) ;jam it against the left side
647 (defun c-lineup-knr-region-comment (langelem)
648 "Line up a comment in the \"K&R region\" with the declaration.
649 That is the region between the function or class header and the
650 beginning of the block. E.g:
653 /* This is the main function. */ <- c-lineup-knr-region-comment
658 Return nil if called in any other situation, to be useful in list
661 Works with: comment-intro."
662 (when (or (assq 'topmost-intro-cont c-syntactic-context)
663 (assq 'func-decl-cont c-syntactic-context)
664 (assq 'knr-argdecl-intro c-syntactic-context)
665 (assq 'lambda-intro-cont c-syntactic-context))
668 (c-beginning-of-statement-1)
669 (vector (current-column)))))
671 (defun c-lineup-runin-statements (langelem)
672 "Line up statements when the first statement is on the same line as
673 the block opening brace. E.g:
676 { puts (\"Hello world!\");
677 return 0; <- c-lineup-runin-statements
680 If there is no statement after the opening brace to align with, nil is
681 returned. This makes the function usable in list expressions.
683 Works with: The `statement' syntactic symbol."
684 (if (eq (char-after (c-langelem-pos langelem)) ?{)
686 (if (c-langelem-pos langelem)
687 (goto-char (c-langelem-pos langelem)))
689 (skip-chars-forward " \t")
691 (vector (current-column))))))
693 (defun c-lineup-assignments (langelem)
694 "Line up the current line after the assignment operator on the first
695 line in the statement. If there isn't any, return nil to allow
696 stacking with other line-up functions. If the current line contains
697 an assignment operator too, try to align it with the first one.
699 Works with: topmost-intro-cont, statement-cont, arglist-cont,
700 arglist-cont-nonempty."
701 (let (startpos endpos equalp)
703 (if (eq (c-langelem-sym langelem) 'arglist-cont-nonempty)
704 ;; If it's an arglist-cont-nonempty then we're only interested
705 ;; in equal signs outside it. We don't search for a "=" on
706 ;; the current line since that'd have a different nesting
707 ;; compared to the one we should align with.
710 (setq endpos (c-langelem-2nd-pos c-syntactic-element))
711 (narrow-to-region (c-langelem-pos langelem) endpos)
712 (if (setq startpos (c-up-list-backward endpos))
713 (setq startpos (1+ startpos))
714 (setq startpos (c-langelem-pos langelem)))))
716 (setq startpos (c-langelem-pos langelem)
719 ;; Find a syntactically relevant and unnested "=" token on the
720 ;; current line. equalp is in that case set to the number of
721 ;; columns to left shift the current line to align it with the
725 (when (c-syntactic-re-search-forward
726 c-assignment-op-regexp
727 (c-point 'eol) t t t)
728 (setq equalp (- (or (match-beginning 1)
734 (if (or (if (c-syntactic-re-search-forward
735 c-assignment-op-regexp
736 (min endpos (c-point 'eol)) t t t)
738 (goto-char (or (match-beginning 1)
743 (c-forward-syntactic-ws (c-point 'eol))
745 ;; There's no equal sign on the line, or there is one but
746 ;; nothing follows it.
749 ;; calculate indentation column after equals and ws, unless
750 ;; our line contains an equals sign
753 (skip-chars-forward " \t")
756 (vector (- (current-column) equalp)))
759 (defun c-lineup-math (langelem)
760 "Like `c-lineup-assignments' but indent with `c-basic-offset' if no
761 assignment operator was found on the first line. I.e. this function
762 is the same as specifying a list (c-lineup-assignments +). It's
763 provided for compatibility with old configurations.
765 Works with: topmost-intro-cont, statement-cont, arglist-cont,
766 arglist-cont-nonempty."
767 (or (c-lineup-assignments langelem)
770 (defun c-lineup-cascaded-calls (langelem)
771 "Line up \"cascaded calls\" under each other.
772 If the line begins with \"->\" or \".\" and the preceding line ends
773 with one or more function calls preceded by the same token, then the
774 arrow is lined up with the first of those tokens. E.g:
776 result = proc->add(17)->add(18)
777 ->add(19) + <- c-lineup-cascaded-calls
778 offset; <- c-lineup-cascaded-calls (inactive)
780 In any other situation nil is returned to allow use in list
783 Works with: topmost-intro-cont, statement-cont, arglist-cont,
784 arglist-cont-nonempty."
786 (if (and (eq (c-langelem-sym langelem) 'arglist-cont-nonempty)
787 (not (eq (c-langelem-2nd-pos c-syntactic-element)
788 (c-most-enclosing-brace (c-parse-state)))))
789 ;; The innermost open paren is not our one, so don't do
790 ;; anything. This can occur for arglist-cont-nonempty with
791 ;; nested arglist starts on the same line.
795 (back-to-indentation)
796 (let ((operator (and (looking-at "->\\|\\.")
797 (regexp-quote (match-string 0))))
798 (stmt-start (c-langelem-pos langelem)) col)
801 (looking-at operator)
802 (zerop (c-backward-token-2 1 t stmt-start))
803 (eq (char-after) ?\()
804 (zerop (c-backward-token-2 2 t stmt-start))
805 (looking-at operator))
806 (setq col (current-column))
808 (while (and (zerop (c-backward-token-2 1 t stmt-start))
809 (eq (char-after) ?\()
810 (zerop (c-backward-token-2 2 t stmt-start))
811 (looking-at operator))
812 (setq col (current-column)))
816 (defun c-lineup-string-cont (langelem)
817 "Line up a continued string under the one it continues.
818 A continued string in this sense is where a string literal follows
819 directly after another one. E.g:
821 result = prefix + \"A message \"
822 \"string.\"; <- c-lineup-string-cont
824 Nil is returned in other situations, to allow stacking with other
827 Works with: topmost-intro-cont, statement-cont, arglist-cont,
828 arglist-cont-nonempty."
830 (back-to-indentation)
831 (and (looking-at "\\s\"")
832 (let ((quote (char-after)) pos)
833 (while (and (progn (c-backward-syntactic-ws)
834 (eq (char-before) quote))
835 (c-safe (c-backward-sexp) t)
836 (/= (setq pos (point)) (c-point 'boi))))
839 (vector (current-column)))))))
841 (defun c-lineup-template-args (langelem)
842 "Line up template argument lines under the first argument.
843 To allow this function to be used in a list expression, nil is
844 returned if there's no template argument on the first line.
846 Works with: template-args-cont."
848 (c-with-syntax-table c++-template-syntax-table
851 (if (and (eq (char-after) ?<)
852 (zerop (c-forward-token-2 1 nil (c-point 'eol))))
853 (vector (current-column))))))
855 (defun c-lineup-ObjC-method-call (langelem)
856 "Line up selector args as Emacs Lisp mode does with function args:
857 Go to the position right after the message receiver, and if you are at
858 the end of the line, indent the current line c-basic-offset columns
859 from the opening bracket; otherwise you are looking at the first
860 character of the first method call argument, so line up the current
863 Works with: objc-method-call-cont."
865 (let* ((extra (save-excursion
866 (back-to-indentation)
867 (c-backward-syntactic-ws (c-langelem-pos langelem))
868 (if (eq (char-before) ?:)
871 (open-bracket-pos (c-langelem-pos langelem))
872 (open-bracket-col (progn
873 (goto-char open-bracket-pos)
878 (skip-chars-forward " \t")
880 (+ open-bracket-col c-basic-offset)
883 (- target-col open-bracket-col extra))))
885 (defun c-lineup-ObjC-method-args (langelem)
886 "Line up the colons that separate args.
887 The colon on the current line is aligned with the one on the first
890 Works with: objc-method-args-cont."
892 (let* ((here (c-point 'boi))
893 (curcol (progn (goto-char here) (current-column)))
895 (relpos (c-langelem-pos langelem))
896 (first-col-column (progn
898 (skip-chars-forward "^:" eol)
899 (and (eq (char-after) ?:)
901 (if (not first-col-column)
904 (skip-chars-forward "^:" eol)
905 (if (eq (char-after) ?:)
906 (+ curcol (- first-col-column (current-column)))
909 (defun c-lineup-ObjC-method-args-2 (langelem)
910 "Line up the colons that separate args.
911 The colon on the current line is aligned with the one on the previous
914 Works with: objc-method-args-cont."
916 (let* ((here (c-point 'boi))
917 (curcol (progn (goto-char here) (current-column)))
919 (relpos (c-langelem-pos langelem))
920 (prev-col-column (progn
921 (skip-chars-backward "^:" relpos)
922 (and (eq (char-before) ?:)
923 (- (current-column) 1)))))
924 (if (not prev-col-column)
927 (skip-chars-forward "^:" eol)
928 (if (eq (char-after) ?:)
929 (+ curcol (- prev-col-column (current-column)))
932 (defun c-lineup-inexpr-block (langelem)
933 "Line up the block for constructs that use a block inside an expression,
934 e.g. anonymous classes in Java and lambda functions in Pike. The body
935 is aligned with the start of the header, e.g. with the \"new\" or
936 \"lambda\" keyword. Returns nil if the block isn't part of such a
939 Works with: inlambda, inexpr-statement, inexpr-class."
941 (back-to-indentation)
942 (let* ((paren-state (c-parse-state))
943 (containing-sexp (c-most-enclosing-brace paren-state))
944 (res (or (c-looking-at-inexpr-block
945 (c-safe-position containing-sexp paren-state)
948 (progn (goto-char containing-sexp)
949 (eq (char-after) ?{))
950 (progn (setq containing-sexp
951 (c-most-enclosing-brace paren-state
953 (c-looking-at-inexpr-block
954 (c-safe-position containing-sexp paren-state)
955 containing-sexp))))))
957 (goto-char (cdr res))
958 (vector (current-column))))))
960 (defun c-lineup-whitesmith-in-block (langelem)
961 "Line up lines inside a block in Whitesmith style.
962 It's done in a way that works both when the opening brace hangs and
963 when it doesn't. E.g:
967 foo; <-> foo; <- c-lineup-whitesmith-in-block
971 In the first case the indentation is kept unchanged, in the
972 second `c-basic-offset' is added.
974 Works with: defun-close, defun-block-intro, inline-close, block-close,
975 brace-list-close, brace-list-intro, statement-block-intro,
976 arglist-intro, arglist-cont-nonempty, arglist-close, and all in*
977 symbols, e.g. inclass and inextern-lang."
979 (if (and (c-go-up-list-backward)
980 (= (point) (c-point 'boi)))
984 (defun c-lineup-after-whitesmith-blocks (langelem)
985 "Compensate for Whitesmith style indentation of blocks.
986 Due to the way CC Mode calculates anchor positions for normal lines
987 inside blocks, this function is necessary for those lines to get
988 correct Whitesmith style indentation. Consider the following
996 x; <-> x; <- c-lineup-after-whitesmith-blocks
998 The fact that the line with \"x\" is preceded by a Whitesmith style
999 indented block in one case and not the other should not affect its
1000 indentation. But since CC Mode in cases like this uses the
1001 indentation of the preceding statement as anchor position, the \"x\"
1002 would in the rightmost case be indented too much if the offset for
1003 `statement' was set simply to zero.
1005 This lineup function corrects for this situation by detecting if the
1006 anchor position is at an open paren character. In that case, it
1007 instead indents relative to the surrounding block just like
1008 `c-lineup-whitesmith-in-block'.
1010 Works with: brace-list-entry, brace-entry-open, statement,
1013 (goto-char (c-langelem-pos langelem))
1014 (when (looking-at "\\s\(")
1015 (if (c-go-up-list-backward)
1016 (let ((pos (point)))
1017 (back-to-indentation)
1019 (vector (current-column))
1020 (vector (+ (current-column) c-basic-offset))))
1023 (defun c-lineup-cpp-define (langelem)
1024 "Line up macro continuation lines according to the indentation of
1025 the construct preceding the macro. E.g:
1027 v beg of preceding constr v beg of preceding constr
1029 const char msg[] = if (!running)
1030 \"Some text.\"; error(\"Not running!\");
1032 #define X(A, B) \ #define X(A, B) \
1033 do { \ <-> do { \ <- c-lineup-cpp-define
1034 printf (A, B); \ printf (A, B); \
1035 } while (0) } while (0)
1037 If `c-syntactic-indentation-in-macros' is non-nil, the function
1038 returns the relative indentation to the macro start line to allow
1039 accumulation with other offsets. E.g. in the following cases,
1040 cpp-define-intro is combined with the statement-block-intro that comes
1041 from the \"do {\" that hangs on the \"#define\" line:
1044 const char msg[] = if (!running)
1045 \"Some text.\"; error(\"Not running!\");
1047 #define X(A, B) do { \ #define X(A, B) do { \
1048 printf (A, B); \ <-> printf (A, B); \ <- c-lineup-cpp-define
1049 this->refs++; \ this->refs++; \
1050 } while (0) <-> } while (0) <- c-lineup-cpp-define
1052 The relative indentation returned by `c-lineup-cpp-define' is zero and
1053 two, respectively, in these two examples. They are then added to the
1054 two column indentation that statement-block-intro gives in both cases
1057 If the relative indentation is zero, then nil is returned instead.
1058 That is useful in a list expression to specify the default indentation
1061 If `c-syntactic-indentation-in-macros' is nil then this function keeps
1062 the current indentation, except for empty lines \(ignoring the ending
1063 backslash) where it takes the indentation from the closest preceding
1064 nonempty line in the macro. If there's no such line in the macro then
1065 the indentation is taken from the construct preceding it, as described
1068 Works with: cpp-define-intro."
1070 (if c-syntactic-indentation-in-macros
1071 ;; Go to the macro start and do a syntactic analysis of it.
1072 ;; Then remove the cpp-macro element it should contain and
1073 ;; calculate the indentation it then would get.
1075 (c-beginning-of-macro)
1076 (setq offset (- (c-get-syntactic-indentation
1077 (delete '(cpp-macro) (c-guess-basic-syntax)))
1079 (back-to-indentation)
1084 ;; Do not indent syntactically inside the macro.
1086 (let ((macro-start-line (save-excursion
1087 (goto-char (c-query-macro-start))
1091 ;; Check every line while inside the macro.
1092 (while (and (> (point) macro-start-line)
1093 (looking-at "[ \t]*\\\\?$")
1094 (= (forward-line -1) 0)))
1095 (if (<= (point) macro-start-line)
1096 ;; If we've stepped out of the macro we take the
1097 ;; syntactic offset.
1098 (setq offset (c-get-syntactic-indentation
1099 (delete '(cpp-macro) (c-guess-basic-syntax))))
1100 (setq offset (current-indentation)))
1103 (vector offset)))))))
1105 ;; Contributed by Kevin Ryde <user42@zip.com.au>.
1106 (defun c-lineup-gcc-asm-reg (elem)
1107 "Line up a gcc asm register under one on a previous line.
1109 asm (\"foo %1, %0\\n\"
1116 The \"x\" line is aligned to the text after the \":\" on the \"w\" line, and
1117 similarly \"z\" under \"y\".
1119 This is done only in an \"asm\" or \"__asm__\" block, and only to
1120 those lines mentioned. Anywhere else nil is returned. The usual
1121 arrangement is to have this routine as an extra feature at the start
1122 of arglist line-ups, e.g.
1124 (c-lineup-gcc-asm-reg c-lineup-arglist)
1126 Works with: arglist-cont, arglist-cont-nonempty."
1128 (let ((orig-pos (point))
1134 ;; Don't do anything if the innermost open paren isn't our one.
1135 ;; This can occur for arglist-cont-nonempty with nested arglist
1136 ;; starts on the same line.
1137 (or (not (eq (car elem) 'arglist-cont-nonempty))
1138 (eq (c-langelem-2nd-pos c-syntactic-element)
1139 (c-most-enclosing-brace (c-parse-state))))
1141 ;; Find the ":" to align to. Look for this first so as to quickly
1142 ;; eliminate pretty much all cases which are not for us.
1143 (re-search-backward "^[ \t]*:[ \t]*\\(.\\)?" (cdr elem) t)
1145 ;; Must have something after the ":".
1146 (setq alignto (match-beginning 1))
1148 ;; Don't touch ":" lines themselves.
1149 (progn (goto-char orig-pos)
1151 (not (looking-at "^[ \t]*:")))
1153 ;; Only operate in an asm statement.
1154 (progn (goto-char orig-pos)
1157 (vector (progn (goto-char alignto) (current-column)))))))
1159 (defun c-lineup-dont-change (langelem)
1160 "Do not change the indentation of the current line.
1162 Works with: Any syntactic symbol."
1164 (back-to-indentation)
1165 (vector (current-column))))
1168 (defun c-snug-do-while (syntax pos)
1169 "Dynamically calculate brace hanginess for do-while statements.
1170 Using this function, `while' clauses that end a `do-while' block will
1171 remain on the same line as the brace that closes that block.
1173 See `c-hanging-braces-alist' for how to utilize this function as an
1174 ACTION associated with `block-close' syntax."
1177 (if (and (eq syntax 'block-close)
1178 (setq langelem (assq 'block-close c-syntactic-context))
1179 (progn (goto-char (c-langelem-pos langelem))
1180 (if (eq (char-after) ?{)
1181 (c-safe (c-forward-sexp -1)))
1182 (looking-at "\\<do\\>[^_]")))
1186 (defun c-snug-1line-defun-close (syntax pos)
1187 "Determine the brace hanginess for an AWK defun-close.
1188 If the action/function being closed is a one-liner, keep it so. Otherwise put
1189 the closing brace on its own line."
1192 (if (> (c-point 'bol)
1193 (progn (up-list -1) (point)))
1197 (defun c-gnu-impose-minimum ()
1198 "Imposes a minimum indentation for lines inside code blocks.
1199 The variable `c-label-minimum-indentation' specifies the minimum
1200 indentation amount."
1203 ;; Don't adjust macro or comment-only lines.
1204 (or (assq 'cpp-macro c-syntactic-context)
1205 (assq 'comment-intro c-syntactic-context)))
1206 (c-intersect-lists c-inside-block-syms c-syntactic-context)
1208 (back-to-indentation)
1209 (< (current-column) c-label-minimum-indentation)))
1210 (c-shift-line-indentation (- c-label-minimum-indentation
1211 (current-indentation)))))
1214 ;; Useful for c-hanging-semi&comma-criteria
1216 (defun c-semi&comma-inside-parenlist ()
1217 "Controls newline insertion after semicolons in parenthesis lists.
1218 If a comma was inserted, no determination is made. If a semicolon was
1219 inserted inside a parenthesis list, no newline is added otherwise a
1220 newline is added. In either case, checking is stopped. This supports
1221 exactly the old newline insertion behavior."
1222 ;; newline only after semicolon, but only if that semicolon is not
1223 ;; inside a parenthesis list (e.g. a for loop statement)
1224 (if (not (eq last-command-char ?\;))
1225 nil ; continue checking
1226 (if (condition-case nil
1229 (not (eq (char-after) ?\()))
1234 ;; Suppresses newlines before non-blank lines
1235 (defun c-semi&comma-no-newlines-before-nonblanks ()
1236 "Controls newline insertion after semicolons.
1237 If a comma was inserted, no determination is made. If a semicolon was
1238 inserted, and the following line is not blank, no newline is inserted.
1239 Otherwise, no determination is made."
1241 (if (and (= last-command-char ?\;)
1243 ;; (save-excursion (skip-syntax-forward " ") (point))
1244 (zerop (forward-line 1))
1245 (bolp) ; forward-line has funny behavior at eob.
1246 (not (looking-at "^[ \t]*$")))
1250 ;; Suppresses new lines after semicolons in one-liners methods
1251 (defun c-semi&comma-no-newlines-for-oneline-inliners ()
1252 "Controls newline insertion after semicolons for some one-line methods.
1253 If a comma was inserted, no determination is made. Newlines are
1254 suppressed in one-liners, if the line is an in-class inline function.
1255 For other semicolon contexts, no determination is made."
1256 (let ((syntax (c-guess-basic-syntax))
1257 (bol (save-excursion
1258 (if (c-safe (up-list -1) t)
1261 (if (and (eq last-command-char ?\;)
1262 (eq (car (car syntax)) 'inclass)
1263 (eq (car (car (cdr syntax))) 'topmost-intro)
1264 (= (c-point 'bol) bol))
1269 (cc-provide 'cc-align)
1271 ;;; arch-tag: 4d71ed28-bf51-4509-a148-f39669669a2e
1272 ;;; cc-align.el ends here