(eval-when-compile
(let ((load-path
(if (and (boundp 'byte-compile-dest-file)
(stringp byte-compile-dest-file))
(cons (file-name-directory byte-compile-dest-file) load-path)
load-path)))
(require 'cc-bytecomp)))
(cc-require 'cc-defs)
(cc-require 'cc-vars)
(cc-require 'cc-langs)
(cc-require 'cc-engine)
(defun c-lineup-arglist (langelem)
"Line up the current argument line under the first argument.
Works with: arglist-cont-nonempty."
(save-excursion
(let* ((containing-sexp
(save-excursion
(if (memq (car langelem) '(arglist-intro arglist-cont-nonempty))
(progn
(beginning-of-line)
(backward-up-list 1)
(skip-chars-forward " \t" (c-point 'eol)))
(goto-char (cdr langelem)))
(point)))
(langelem-col (c-langelem-col langelem t)))
(if (save-excursion
(beginning-of-line)
(looking-at "[ \t]*)"))
(progn (goto-char (match-end 0))
(c-forward-sexp -1)
(forward-char 1)
(c-forward-syntactic-ws)
(- (current-column) langelem-col))
(goto-char containing-sexp)
(or (eolp)
(not (memq (char-after) '(?{ ?\( ?\[)))
(let ((eol (c-point 'eol))
(here (progn
(forward-char 1)
(skip-chars-forward " \t")
(point))))
(c-forward-syntactic-ws)
(if (< (point) eol)
(goto-char here))))
(- (current-column) langelem-col)
))))
(defun c-lineup-arglist-intro-after-paren (langelem)
"Line up a line just after the open paren of the surrounding paren or
brace block.
Works with: defun-block-intro, brace-list-intro,
statement-block-intro, statement-case-intro, arglist-intro."
(save-excursion
(let ((langelem-col (c-langelem-col langelem t))
(ce-curcol (save-excursion
(beginning-of-line)
(backward-up-list 1)
(skip-chars-forward " \t" (c-point 'eol))
(current-column))))
(- ce-curcol langelem-col -1))))
(defun c-lineup-arglist-close-under-paren (langelem)
"Line up a closing paren line under the corresponding open paren.
Works with: defun-close, class-close, inline-close, block-close,
brace-list-close, arglist-close, extern-lang-close, namespace-close
\(for most of these, a zero offset will normally produce the same
result, though)."
(save-excursion
(let ((langelem-col (c-langelem-col langelem t))
(ce-curcol (save-excursion
(beginning-of-line)
(backward-up-list 1)
(current-column))))
(- ce-curcol langelem-col))))
(defun c-lineup-close-paren (langelem)
"Line up the closing paren under its corresponding open paren if the
open paren is followed by code. If the open paren ends its line, no
indentation is added. E.g:
main (int, main (
char ** int, char **
) <-> ) <- c-lineup-close-paren
Works with: defun-close, class-close, inline-close, block-close,
brace-list-close, arglist-close, extern-lang-close, namespace-close."
(save-excursion
(condition-case nil
(let (opencol spec)
(beginning-of-line)
(backward-up-list 1)
(setq spec (c-looking-at-special-brace-list))
(if spec (goto-char (car (car spec))))
(setq opencol (current-column))
(forward-char 1)
(if spec (progn
(c-forward-syntactic-ws)
(forward-char 1)))
(c-forward-syntactic-ws (c-point 'eol))
(if (eolp)
0
(- opencol (c-langelem-col langelem t))))
(error nil))))
(defun c-lineup-streamop (langelem)
"Line up C++ stream operators under each other.
Works with: stream-op."
(save-excursion
(let ((langelem-col (c-langelem-col langelem)))
(re-search-forward "<<\\|>>" (c-point 'eol) 'move)
(goto-char (match-beginning 0))
(- (current-column) langelem-col))))
(defun c-lineup-multi-inher (langelem)
"Line up the classes in C++ multiple inheritance clauses and member
initializers under each other. E.g:
class Foo: Foo::Foo (int a, int b):
public Cyphr, Cyphr (a),
public Bar <-> Bar (b) <- c-lineup-multi-inher
class Foo Foo::Foo (int a, int b)
: public Cyphr, : Cyphr (a),
public Bar <-> Bar (b) <- c-lineup-multi-inher
class Foo Foo::Foo (int a, int b)
: public Cyphr : Cyphr (a)
, public Bar <-> , Bar (b) <- c-lineup-multi-inher
Works with: inher-cont, member-init-cont."
(save-excursion
(let* ((eol (c-point 'eol))
(here (point))
(char-after-ip (progn
(skip-chars-forward " \t")
(char-after)))
(langelem-col (c-langelem-col langelem)))
(c-backward-syntactic-ws)
(when (eq (char-before) ?:)
(backward-char)
(c-backward-syntactic-ws))
(skip-chars-forward "^:" eol)
(if (eq char-after-ip ?,)
(skip-chars-forward " \t" eol)
(skip-chars-forward " \t:" eol))
(if (or (eolp)
(looking-at c-comment-start-regexp))
(c-forward-syntactic-ws here))
(- (current-column) langelem-col)
)))
(defun c-lineup-java-inher (langelem)
"Line up Java implements and extends declarations.
If class names follows on the same line as the implements/extends
keyword, they are lined up under each other. Otherwise, they are
indented by adding `c-basic-offset' to the column of the keyword.
E.g:
class Foo class Foo
extends extends Cyphr,
Bar <-> Bar <- c-lineup-java-inher
<--> c-basic-offset
Works with: inher-cont."
(save-excursion
(let ((langelem-col (c-langelem-col langelem)))
(forward-word 1)
(if (looking-at "[ \t]*$")
c-basic-offset
(c-forward-syntactic-ws)
(- (current-column) langelem-col)))))
(defun c-lineup-java-throws (langelem)
"Line up Java throws declarations.
If exception names follows on the same line as the throws keyword,
they are lined up under each other. Otherwise, they are indented by
adding `c-basic-offset' to the column of the throws keyword. The
throws keyword itself is also indented by `c-basic-offset' from the
function declaration start if it doesn't hang. E.g:
int foo() int foo() throws Cyphr,
throws <-> Bar, <- c-lineup-java-throws
Bar <-> Vlod <- c-lineup-java-throws
<--><--> c-basic-offset
Works with: func-decl-cont."
(save-excursion
(let* ((lim (1- (c-point 'bol)))
(throws (catch 'done
(goto-char (cdr langelem))
(while (zerop (c-forward-token-1 1 t lim))
(if (looking-at "throws\\>[^_]")
(throw 'done t))))))
(if throws
(if (zerop (c-forward-token-1 1 nil (c-point 'eol)))
(- (current-column) (c-langelem-col langelem))
(back-to-indentation)
(+ (- (current-column) (c-langelem-col langelem))
c-basic-offset))
c-basic-offset))))
(defun c-indent-one-line-block (langelem)
"Indent a one line block `c-basic-offset' extra.
E.g:
if (n > 0) if (n > 0)
{m+=n; n=0;} <-> { <- c-indent-one-line-block
<--> c-basic-offset m+=n; n=0;
}
The block may use any kind of parenthesis character. nil is returned
if the line doesn't start with a one line block, which makes the
function usable in list expressions.
Work with: Almost all syntactic symbols, but most useful on *-open."
(save-excursion
(let ((eol (c-point 'eol)))
(back-to-indentation)
(if (and (eq (char-syntax (char-after)) ?\()
(c-safe (progn (c-forward-sexp) t))
(<= (point) eol))
c-basic-offset
nil))))
(defun c-indent-multi-line-block (langelem)
"Indent a multi line block `c-basic-offset' extra.
E.g:
int *foo[] = { int *foo[] = {
NULL, NULL,
{17}, <-> { <- c-indent-multi-line-block
17
}
<--> c-basic-offset
The block may use any kind of parenthesis character. nil is returned
if the line doesn't start with a multi line block, which makes the
function usable in list expressions.
Work with: Almost all syntactic symbols, but most useful on *-open."
(save-excursion
(let ((eol (c-point 'eol)))
(back-to-indentation)
(if (and (eq (char-syntax (char-after)) ?\()
(or (not (c-safe (progn (c-forward-sexp) t)))
(> (point) eol)))
c-basic-offset
nil))))
(defun c-lineup-C-comments (langelem)
"Line up C block comment continuation lines.
Various heuristics are used to handle many of the common comment
styles. Some examples:
/* /** /* /* text /* /**
* text * text text text ** text ** text
*/ */ */ */ */ */
/*********************************************************************
* text
********************************************************************/
/*********************************************************************
Free form text comments:
In comments with a long delimiter line at the start, the indentation
is kept unchanged for lines that start with an empty comment line
prefix. The delimiter line is whatever matches the
`comment-start-skip' regexp.
*********************************************************************/
The variable `c-comment-prefix-regexp' is used to recognize the
comment line prefix, e.g. the `*' that usually starts every line
inside a comment.
Works with: The `c' syntactic symbol."
(save-excursion
(let* ((here (point))
(prefixlen (progn (back-to-indentation)
(if (looking-at c-current-comment-prefix)
(- (match-end 0) (point))
0)))
(starterlen (save-excursion
(goto-char (cdr langelem))
(looking-at comment-start-skip)
(- (save-excursion
(goto-char (match-end 0))
(skip-chars-backward " \t")
(point))
(or (match-end 1) (point))
1))) (langelem-col (save-excursion (c-langelem-col langelem))))
(if (and (> starterlen 10) (zerop prefixlen))
(- (current-column) langelem-col)
(forward-line -1)
(back-to-indentation)
(if (>= (cdr langelem) (point))
(if (zerop prefixlen)
(progn
(goto-char (match-end 0))
(if (looking-at "\\([ \t]+\\).+$")
(goto-char (match-end 1)))
(- (current-column) langelem-col))
(if (> starterlen prefixlen)
(progn
(goto-char (cdr langelem))
(- (current-column) -1 langelem-col))
(goto-char (match-end 0))
(skip-chars-backward " \t")
(- (current-column) prefixlen langelem-col)))
(when (or (not (looking-at c-current-comment-prefix))
(eq (match-beginning 0) (match-end 0)))
(goto-char here)
(back-to-indentation)
(if (looking-at (concat "\\(" c-current-comment-prefix "\\)\\*/"))
(goto-char (cdr langelem))
(while (and (zerop (forward-line -1))
(looking-at "^[ \t]*$")))
(back-to-indentation)
(if (< (point) (cdr langelem))
(goto-char (cdr langelem)))))
(- (current-column) langelem-col))))))
(defun c-lineup-comment (langelem)
"Line up a comment start according to `c-comment-only-line-offset'.
If the comment is lined up with a comment starter on the previous
line, that alignment is preserved.
Works with: comment-intro."
(save-excursion
(back-to-indentation)
(let ((col (current-column)))
(cond
((save-excursion
(and (c-forward-comment -1)
(= col (current-column))))
(vector col)) ((not (bolp))
(or (car-safe c-comment-only-line-offset)
c-comment-only-line-offset))
(t
(or (cdr-safe c-comment-only-line-offset)
(car-safe c-comment-only-line-offset)
-1000)) ))))
(defun c-lineup-runin-statements (langelem)
"Line up statements when the first statement is on the same line as
the block opening brace. E.g:
int main()
{ puts (\"Hello world!\");
return 0; <- c-lineup-runin-statements
}
If there is no statement after the opening brace to align with, nil is
returned. This makes the function usable in list expressions.
Works with: The `statement' syntactic symbol."
(if (eq (char-after (cdr langelem)) ?{)
(save-excursion
(let ((langelem-col (c-langelem-col langelem)))
(forward-char 1)
(skip-chars-forward " \t")
(unless (eolp)
(- (current-column) langelem-col))))))
(defun c-lineup-math (langelem)
"Line up the current line after the equal sign on the first line in
the statement. If there isn't any, indent with `c-basic-offset'. If
the current line contains an equal sign too, try to align it with the
first one.
Works with: statement-cont."
(save-excursion
(let ((equalp (save-excursion
(goto-char (c-point 'boi))
(let ((eol (c-point 'eol)))
(c-forward-token-1 0 t eol)
(while (and (not (eq (char-after) ?=))
(= (c-forward-token-1 1 t eol) 0))))
(and (eq (char-after) ?=)
(- (point) (c-point 'boi)))))
(langelem-col (c-langelem-col langelem))
donep)
(while (and (not donep)
(< (point) (c-point 'eol)))
(skip-chars-forward "^=" (c-point 'eol))
(if (c-in-literal (cdr langelem))
(forward-char 1)
(setq donep t)))
(if (or (not (eq (char-after) ?=))
(save-excursion
(forward-char 1)
(c-forward-syntactic-ws (c-point 'eol))
(eolp)))
c-basic-offset
(if (not equalp)
(progn
(forward-char 1)
(skip-chars-forward " \t")
(setq equalp 0)))
(- (current-column) equalp langelem-col))
)))
(defun c-lineup-template-args (langelem)
"Line up template argument lines under the first argument.
To allow this function to be used in a list expression, nil is
returned if there's no template argument on the first line.
Works with: template-args-cont."
(save-excursion
(c-with-syntax-table c++-template-syntax-table
(beginning-of-line)
(backward-up-list 1)
(if (and (eq (char-after) ?<)
(zerop (c-forward-token-1 1 nil (c-point 'eol))))
(- (current-column) (c-langelem-col langelem))))))
(defun c-lineup-ObjC-method-call (langelem)
"Line up selector args as elisp-mode does with function args:
Go to the position right after the message receiver, and if you are at
the end of the line, indent the current line c-basic-offset columns
from the opening bracket; otherwise you are looking at the first
character of the first method call argument, so lineup the current
line with it.
Works with: objc-method-call-cont."
(save-excursion
(let* ((extra (save-excursion
(back-to-indentation)
(c-backward-syntactic-ws (cdr langelem))
(if (eq (char-before) ?:)
(- c-basic-offset)
0)))
(open-bracket-pos (cdr langelem))
(open-bracket-col (progn
(goto-char open-bracket-pos)
(current-column)))
(target-col (progn
(forward-char)
(c-forward-sexp)
(skip-chars-forward " \t")
(if (eolp)
(+ open-bracket-col c-basic-offset)
(current-column))))
)
(- target-col open-bracket-col extra))))
(defun c-lineup-ObjC-method-args (langelem)
"Line up the colons that separate args.
The colon on the current line is aligned with the one on the first
line.
Works with: objc-method-args-cont."
(save-excursion
(let* ((here (c-point 'boi))
(curcol (progn (goto-char here) (current-column)))
(eol (c-point 'eol))
(relpos (cdr langelem))
(first-col-column (progn
(goto-char relpos)
(skip-chars-forward "^:" eol)
(and (eq (char-after) ?:)
(current-column)))))
(if (not first-col-column)
c-basic-offset
(goto-char here)
(skip-chars-forward "^:" eol)
(if (eq (char-after) ?:)
(+ curcol (- first-col-column (current-column)))
c-basic-offset)))))
(defun c-lineup-ObjC-method-args-2 (langelem)
"Line up the colons that separate args.
The colon on the current line is aligned with the one on the previous
line.
Works with: objc-method-args-cont."
(save-excursion
(let* ((here (c-point 'boi))
(curcol (progn (goto-char here) (current-column)))
(eol (c-point 'eol))
(relpos (cdr langelem))
(prev-col-column (progn
(skip-chars-backward "^:" relpos)
(and (eq (char-before) ?:)
(- (current-column) 1)))))
(if (not prev-col-column)
c-basic-offset
(goto-char here)
(skip-chars-forward "^:" eol)
(if (eq (char-after) ?:)
(+ curcol (- prev-col-column (current-column)))
c-basic-offset)))))
(defun c-lineup-inexpr-block (langelem)
"Line up the block for constructs that use a block inside an expression,
e.g. anonymous classes in Java and lambda functions in Pike. The body
is aligned with the start of the header, e.g. with the \"new\" or
\"lambda\" keyword. Returns nil if the block isn't part of such a
construct.
Works with: inlambda, inexpr-statement, inexpr-class."
(save-excursion
(back-to-indentation)
(let ((res (or (c-looking-at-inexpr-block)
(if (c-safe (backward-up-list 1)
(eq (char-after) ?{))
(c-looking-at-inexpr-block)))))
(when res
(goto-char (cdr res))
(- (current-column)
(progn
(back-to-indentation)
(current-column)))))))
(defun c-lineup-whitesmith-in-block (langelem)
"Line up lines inside a block in whitesmith style.
It's done in a way that works both when the opening brace hangs and
when it doesn't. E.g:
something
{ something {
foo; <-> foo; <- c-lineup-whitesmith-in-block
} }
<--> c-basic-offset
In the first case the indentation is kept unchanged, in the
second `c-basic-offset' is added.
Works with: defun-close, defun-block-intro, block-close,
brace-list-close, brace-list-intro, statement-block-intro, inclass,
inextern-lang, innamespace."
(save-excursion
(goto-char (cdr langelem))
(back-to-indentation)
(if (eq (char-syntax (char-after)) ?\()
0
c-basic-offset)))
(defun c-lineup-dont-change (langelem)
"Do not change the indentation of the current line.
Works with: Any syntactic symbol."
(save-excursion
(back-to-indentation)
(vector (current-column))))
(defun c-snug-do-while (syntax pos)
"Dynamically calculate brace hanginess for do-while statements.
Using this function, `while' clauses that end a `do-while' block will
remain on the same line as the brace that closes that block.
See `c-hanging-braces-alist' for how to utilize this function as an
ACTION associated with `block-close' syntax."
(save-excursion
(let (langelem)
(if (and (eq syntax 'block-close)
(setq langelem (assq 'block-close c-syntactic-context))
(progn (goto-char (cdr langelem))
(if (eq (char-after) ?{)
(c-safe (c-forward-sexp -1)))
(looking-at "\\<do\\>[^_]")))
'(before)
'(before after)))))
(defun c-gnu-impose-minimum ()
"Imposes a minimum indentation for lines inside a top-level construct.
The variable `c-label-minimum-indentation' specifies the minimum
indentation amount."
(let ((non-top-levels '(defun-block-intro statement statement-cont
statement-block-intro statement-case-intro
statement-case-open substatement substatement-open
case-label label do-while-closure else-clause
))
(syntax c-syntactic-context)
langelem)
(while syntax
(setq langelem (car (car syntax))
syntax (cdr syntax))
(cond ((memq langelem '(cpp-macro comment-intro))
(setq syntax nil))
((memq langelem non-top-levels)
(save-excursion
(setq syntax nil)
(back-to-indentation)
(if (zerop (current-column))
(insert (make-string c-label-minimum-indentation 32)))
))
))))
(defun c-semi&comma-inside-parenlist ()
"Controls newline insertion after semicolons in parenthesis lists.
If a comma was inserted, no determination is made. If a semicolon was
inserted inside a parenthesis list, no newline is added otherwise a
newline is added. In either case, checking is stopped. This supports
exactly the old newline insertion behavior."
(if (not (eq last-command-char ?\ nil (if (condition-case nil
(save-excursion
(up-list -1)
(not (eq (char-after) ?\()))
(error t))
t
'stop)))
(defun c-semi&comma-no-newlines-before-nonblanks ()
"Controls newline insertion after semicolons.
If a comma was inserted, no determination is made. If a semicolon was
inserted, and the following line is not blank, no newline is inserted.
Otherwise, no determination is made."
(save-excursion
(if (and (= last-command-char ?\ (zerop (forward-line 1))
(not (looking-at "^[ \t]*$")))
'stop
nil)))
(defun c-semi&comma-no-newlines-for-oneline-inliners ()
"Controls newline insertion after semicolons for some one-line methods.
If a comma was inserted, no determination is made. Newlines are
suppressed in one-liners, if the line is an in-class inline function.
For other semicolon contexts, no determination is made."
(let ((syntax (c-guess-basic-syntax))
(bol (save-excursion
(if (c-safe (up-list -1) t)
(c-point 'bol)
-1))))
(if (and (eq last-command-char ?\ (eq (car (car syntax)) 'inclass)
(eq (car (car (cdr syntax))) 'topmost-intro)
(= (c-point 'bol) bol))
'stop
nil)))
(cc-provide 'cc-align)