;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\300\302!\210\300\303!\207" [require cc-defs cc-vars cc-engine] 2)
#@869 Line up declaration continuation lines zero or one indentation step.
For lines in the "header" of a definition, zero is used.  For other
lines, `c-basic-offset' is added to the indentation.  E.g.:

int
neg (int i)           <- c-lineup-topmost-intro-cont
{
    return -i;
}

struct
larch                 <- c-lineup-topmost-intro-cont
{
    double height;
}
    the_larch,        <- c-lineup-topmost-intro-cont
    another_larch;    <- c-lineup-topmost-intro-cont
<--> c-basic-offset

struct larch
the_larch,            <- c-lineup-topmost-intro-cont
    another_larch;    <- c-lineup-topmost-intro-cont

(This function is mainly provided to mimic the behavior of CC Mode
5.28 and earlier where this case wasn't handled consistently so that
these lines could be analyzed as either topmost-intro-cont or
statement-cont.)

Works with: topmost-intro-cont.

(fn LANGELEM)
(defalias 'c-lineup-topmost-intro-cont #[257 "\212\302 \210`
\211A:\203\211A\242\262
\202\211A\262
\206eV\203?\214\211\211A:\2030\211A\242\262
\2024\211A\262
\2068ed}\210\303 \210)`Sf\304>\205R\205M\305 ?\205R	)\207" [c-overloadable-operators-regexp c-basic-offset beginning-of-line c-backward-sws (125 44) c-after-special-operator-id] 4 (#$ . 177)])
#@712 Line up the continuation lines of a DEFUN macro in the Emacs C source.
These lines are indented `c-basic-offset' columns, usually from column 0.
Return nil when we're not in such a construct.

This function was formally for use in DEFUNs, which used to have knr
argument lists.  Now (2019-05) it just indents the argument list of the
DEFUN's function, which would otherwise go to column 0.

Here is an example:

DEFUN ("forward-char", Fforward_char, Sforward_char, 0, 1, "p",
       doc: /* Move point right N characters (left if N is negative).
On reaching end of buffer, stop and signal error.  */)
  (Lisp_Object n)             <- c-lineup-gnu-DEFUN-into-cont

Works with: topmost-intro-cont.

(fn LANGELEM)
(defalias 'c-lineup-gnu-DEFUN-intro-cont #[257 "\212\302\211\211A:\203\211A\242\262
\202\211A\262
b\210\303\304!\205	*\207" [case-fold-search c-basic-offset nil looking-at "\\<DEFUN\\>"] 3 (#$ . 1417)])
#@22 

(fn ARGLIST-START)
(defalias 'c-block-in-arglist-dwim #[257 "\304\236\206}\305\236\206}\306\236\206}\214\211\212
b\210\307\210`)}\210\211b\210\310\311\307\312#\203T\313u\210	\203:\214~\210\314 )\204N\3151I\316`\317\"b\210\3120\202K\210\307\203T\307u\210\202\"\320\311!)\206}\307
b\210\321\n!\210\322\224b\210\323 \210\324\325 !\262
\326\327\206w`\"\"\262
\207" [c-syntactic-context c-special-brace-lists c-syntactic-eol c-state-cache inexpr-class inexpr-statement inlambda nil c-syntactic-re-search-forward "{" t -1 c-looking-at-special-brace-list (error) scan-sexps 1 looking-at re-search-forward 0 c-forward-sws c-most-enclosing-brace c-parse-state c-looking-at-inexpr-block c-safe-position] 6 (#$ . 2344)])
#@679 Line up the current argument line under the first argument.

As a special case, if the indented line is inside a brace block
construct, the indentation is `c-basic-offset' only.  This is intended
as a "DWIM" measure in cases like macros that contains statement
blocks, e.g.:

A_VERY_LONG_MACRO_NAME ({
        some (code, with + long, lines * in[it]);
    });
<--> c-basic-offset

This is motivated partly because it's more in line with how code
blocks are handled, and partly since it approximates the behavior of
earlier CC Mode versions, which due to inaccurate analysis tended to
indent such cases this way.

Works with: arglist-cont-nonempty, arglist-close.

(fn LANGELEM)
(defalias 'c-lineup-arglist #[257 "\212`\303\211\243\243\242\262
!\203	\202F\211\243\243\242\262
b\210\n\203-\304 \203-\305 \210\306u\210\2020\306u\210`\307 \210`W\203A\211b\210\310\306w\210\311i!\262
\262
)\207" [c-syntactic-element c-basic-offset c-special-brace-lists c-block-in-arglist-dwim c-looking-at-special-brace-list c-forward-token-2 nil c-forward-sws " 	" vector] 5 (#$ . 3082)])
#@442 Line up a continued argument.

foo (xyz, aaa + bbb + ccc
          + ddd + eee + fff);    <- c-lineup-argcont

Only continuation lines like this are touched, nil is returned on lines
which are the start of an argument.

Within a gcc asm block, ":" is recognized as an argument separator,
but of course only between operand specifications, not in the expressions
for the operands.

Works with: arglist-cont, arglist-cont-nonempty.

(fn ELEM)
(defalias 'c-lineup-argcont #[257 "\212\301 \210\211@\302=\203.\211\243\243\242\262
\303 \211@=\204,\211@:\204%\211@b\210\211A\262
\202\266`\304n\203<\305 \210`Sf\262
\211\306=?\205m\212
b\210\307 )\211\205\\
\310=\206\\\212b\210\311\312!)?\205k\313
\205f\310!\210\314i!\262
\266\202)\207" [c-syntactic-element beginning-of-line arglist-cont-nonempty c-parse-state nil c-backward-sws 44 c-in-gcc-asm-p 58 looking-at "[ 	]*:" c-lineup-argcont-scan vector] 6 (#$ . 4169)])
#@30 

(fn &optional OTHER-MATCH)
(defalias 'c-lineup-argcont-scan #[256 "\300\301\302\"\303U\205$\304f\211\305=\204\211=\203\304u\210\306 \202\"\307!\262
\207" [c-backward-token-2 1 t 0 nil 44 c-forward-sws c-lineup-argcont-scan] 4 (#$ . 5102)])
#@211 Line up a line to 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.

(fn LANGELEM)
(defalias 'c-lineup-arglist-intro-after-paren #[257 "\212\300 \210\301\302!\210\303u\210\304\305 w\210l\203\304\303x\210\306i!)\207" [beginning-of-line backward-up-list 1 nil " 	" line-end-position vector] 3 (#$ . 5359)])
#@654 Line up a line under the enclosing open paren.
Normally used to line up a closing paren in the same column as its
corresponding open paren, but can also be used with arglist-cont and
arglist-cont-nonempty to line up all lines inside a parenthesis under
the open paren.

As a special case, if a brace block construct starts at the same line
as the open parenthesis of the argument list, the indentation is
`c-basic-offset' only.  See `c-lineup-arglist' for further discussion
of this "DWIM" measure.

Works with: Almost all symbols, but are typically most useful on
arglist-close, brace-list-close, arglist-cont and arglist-cont-nonempty.

(fn LANGELEM)
(defalias 'c-lineup-arglist-close-under-paren #[257 "\212\211\211@\262
\303>\203\211\243\243\242\262
b\210\2021\304 \210\3051'\306`\307\310#0\202)\210\311\211\2030\211b\210\210\212\312`!)\203=	\202T\311\n\203O\313 \211\262\203O\211@@b\210\314i!\262
)\207" [c-syntactic-element c-basic-offset c-special-brace-lists (arglist-cont-nonempty arglist-close) beginning-of-line (error) scan-lists -1 1 nil c-block-in-arglist-dwim c-looking-at-special-brace-list vector] 5 (#$ . 5800)])
#@897 Line up lines starting with an infix operator under the open paren.
Return nil on lines that don't start with an operator, to leave those
cases to other line-up functions.  Example:

if (  x < 10
   || at_limit (x,       <- c-lineup-arglist-operators
                list)    <- c-lineup-arglist-operators returns nil
   )

Since this function doesn't do anything for lines without an infix
operator you typically want to use it together with some other line-up
settings, e.g. as follows (the arglist-close setting is just a
suggestion to get a consistent style):

(c-set-offset \='arglist-cont \='(c-lineup-arglist-operators 0))
(c-set-offset \='arglist-cont-nonempty \='(c-lineup-arglist-operators
                                        c-lineup-arglist))
(c-set-offset \='arglist-close \='(c-lineup-arglist-close-under-paren))

Works with: arglist-cont, arglist-cont-nonempty.

(fn LANGELEM)
(defalias 'c-lineup-arglist-operators #[257 "\212\300 \210\301\302!\205
\303
!)\207" [back-to-indentation looking-at "[-+|&*%<>=]\\|\\(/[^/*]\\)" c-lineup-arglist-close-under-paren] 3 (#$ . 6950)])
#@613 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

As a special case, if a brace block construct starts at the same line
as the open parenthesis of the argument list, the indentation is
`c-basic-offset' instead of the open paren column.  See
`c-lineup-arglist' for further discussion of this "DWIM" measure.

Works with: All *-close symbols.

(fn LANGELEM)
(defalias 'c-lineup-close-paren #[257 "\212\211\211@\262
\304>\203\211\243\243\242\262
b\210\2021\305 \210\3061'\307`\310\311#0\202)\210\312\211\2030\211b\210\210\312\211	\203P\313 \211\262\203P
@@\211\262b\210\314 \210\312u\210\202V`\262
\312u\210\315\n!\203b\266\316\202v\317`!\203n\266\202\202v\211b\210\320i!\266\202)\207" [c-syntactic-element c-special-brace-lists c-syntactic-eol c-basic-offset (arglist-cont-nonempty arglist-close) beginning-of-line (error) scan-lists -1 1 nil c-looking-at-special-brace-list c-forward-token-2 looking-at 0 c-block-in-arglist-dwim vector] 5 (#$ . 8052)])
#@87 Line up C++ stream operators under each other.

Works with: stream-op.

(fn LANGELEM)
(defalias 'c-lineup-streamop #[257 "\212\211\211A:\203\211A\242\262
\202\211A\262
b\210\300\301\302 \303#\210\304\224b\210\305i!)\207" [re-search-forward "<<\\|>>" line-end-position move 0 vector] 5 (#$ . 9284)])
#@672 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.

(fn LANGELEM)
(defalias 'c-lineup-multi-inher #[257 "\212\301 \210\302 `\303f\211A:\203\211A\242\262
\202\211A\262
\2034\211A:\203.\211A\242\262
\2022\211A\262
b\210\304 \210`Sf\305=\203E\306u\210\304 \210\307\310\311#\210\312!\203k`\206WdW\203{\214e\206bd}\210\313 \210)\202{\211\314=\203w\306u\210\202{\315w\210`W\205\204\316i!\266\203)\207" [c-syntactic-eol back-to-indentation line-end-position nil c-backward-sws 58 -1 c-syntactic-re-search-forward ":" move looking-at c-forward-sws 44 " 	" vector] 8 (#$ . 9594)])
#@457 Line up Java implements and extends declarations.
If class names follow 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.

(fn LANGELEM)
(defalias 'c-lineup-java-inher #[257 "\212\211\211A:\203\211A\242\262
\202\211A\262
b\210\301\302!\210\303\304!\203$\202*\305 \210\306i!)\207" [c-basic-offset forward-word-strictly 1 looking-at "[ 	]*$" c-forward-sws vector] 3 (#$ . 10802)])
#@609 Line up Java throws declarations.
If exception names follow 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.

(fn LANGELEM)
(defalias 'c-lineup-java-throws #[257 "\212\301 S\30226
\211A:\203\211A\242\262
\202\211A\262
b\210\303\304\305#\306U\2055\307\310!\203\311\302\305\"\210\2020\211\203Z\303\304\312\313 #\306U\203M\314i!\266\202\202]\315 \210\314i\\!\266\202\202]\266\202)\207" [c-basic-offset line-beginning-position done c-forward-token-2 1 t 0 looking-at "throws\\>[^_]" throw nil line-end-position vector back-to-indentation] 7 (#$ . 11514)])
#@492 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.

(fn LANGELEM)
(defalias 'c-indent-one-line-block #[257 "\212\301 \302 \210\303fz\304=\205,\3051\306`\307\"b\210\3100\202\"\210\303\202,\205,`
X\205,\262
)\207" [c-basic-offset line-end-position back-to-indentation nil 40 (error) scan-sexps 1 t] 5 (#$ . 12574)])
#@582 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.

(fn LANGELEM)
(defalias 'c-indent-multi-line-block #[257 "\212\301 \302 \210\303fz\304=\205)\3051\306`\307\"b\210\3100\202\210\303\203(`
V\205)\262
)\207" [c-basic-offset line-end-position back-to-indentation nil 40 (error) scan-sexps 1 t] 5 (#$ . 13328)])
#@1077 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.

(fn LANGELEM)
(defalias 'c-lineup-C-comments #[257 "\212`\302 \210\303!\203\304\225`Z\202\304\212\211A:\203#\211A\242\262
\202'\211A\262
Tb\210\305\304!\203B\303\306\305\304!!!\203B\304\225\304\224Z\202C\304)\212\211A:\203T\211A\242\262
\202X\211A\262
b\210\303	!\210\307\225\206n\212\304\225b\210\310\311x\210`)`ZS)]\211\312V\203\207
\304U\203\207\313i!\266\203\202\226
\314y\210\302 \210`\211A:\203\235\211A\242\262
\202\241\211A\262
V\203\253\303\315!\204\207\211A:\203\272\211A\242\262
\202\276\211A\262
`Y\203

\304U\203\331\303	!\210\304\225b\210\313i!\266\203\202\226
\211V\203\375\211A:\203\356\211A\242\262
\202\362\211A\262
b\210\313iT!\266\203\202\226
\211A:\203\f
\211A\242\262
\202
\211A\262

\\Tb\210\313iZ!\266\203\202\226
\303!\203-
\304\224\304\225=\203\221
b\210\302 \210\303\316\317Q!\203T
\211A:\203K
\211A\242\262
\202O
\211A\262
b\210\202\221
\314y\304U\203a
\303\320!\204T
\302 \210`\211A:\203t
\211A\242\262
\202x
\211A\262
W\203\221
\211A:\203\213
\211A\242\262
\202\217
\211A\262
b\210\313i!\266\203)\207" [c-current-comment-prefix comment-start-skip back-to-indentation looking-at 0 match-string regexp-quote 1 " 	" nil 10 vector -1 "[ 	]*$" "\\(" "\\)\\*/" "^[ 	]*$"] 8 (#$ . 14168)])
#@212 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.

(fn LANGELEM)
(defalias 'c-lineup-comment #[257 "\212\301 \210i\212\302 \205\211iU)\203\303
!\2020n\204%\242\2060\2020\243\2060\242\2060\304\262
)\207" [c-comment-only-line-offset back-to-indentation c-backward-single-comment vector -1000] 4 (#$ . 16491)])
#@372 Line up a comment in the "K&R region" with the declaration.
That is the region between the function or class header and the
beginning of the block.  E.g.:

int main()
/* This is the main function. */  <- c-lineup-knr-region-comment
{
  return 0;
}

Return nil if called in any other situation, to be useful in list
expressions.

Works with: comment-intro.

(fn LANGELEM)
(defalias 'c-lineup-knr-region-comment #[257 "\301\236\204\302\236\204\303\236\204\304\236\205#\212\305 \210\306 \210\307i!)\207" [c-syntactic-context topmost-intro-cont func-decl-cont knr-argdecl-intro lambda-intro-cont beginning-of-line c-beginning-of-statement-1 vector] 3 (#$ . 16966)])
#@393 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.

(fn LANGELEM)
(defalias 'c-lineup-runin-statements #[257 "\211\211A:\203\211A\242\262
\202\211A\262
f\300=\205U\212\211\211A:\203)\211A\242\262
\202-\211A\262
\203E\211\211A:\203?\211A\242\262
\202C\211A\262
b\210\301u\210\302\303w\210l?\205T\304i!)\207" [123 1 " 	" nil vector] 3 (#$ . 17646)])
#@367 Line up the current line after the assignment operator on the first
line in the statement.  If there isn't any, return nil to allow
stacking with other line-up functions.  If the current line contains
an assignment operator too, try to align it with the first one.

Works with: topmost-intro-cont, statement-cont, arglist-cont,
arglist-cont-nonempty.

(fn LANGELEM)
(defalias 'c-lineup-assignments #[257 "\302\211\211\211@\262
\303=\203c\212\214\211\243\243\242\262
\262\211A:\203'\211A\242\262
\202+\211A\262
}\210\3041;\305\306\307#0\202=\210\302\211\262\203JT\262\202_\211A:\203Y\211A\242\262
\202]\211A\262
\262*\202\234\211A:\203r\211A\242\262
\202v\211A\262
\262\310 \262\212\311 \210\312	\313 \314\211\211%\203\233\307\224\206\222\315\225\212\316 \210`)Z\262
)\212b\210\312	\313 ^\314\211\211%\203\271\307\224\206\264\315\225b\210\202\275\314\202\331\212`\313 \206\305dW\203\327\214e\313 \206\321d}\210\317 \210)l)?\205\355\211\204\350\320\302w\210\315\262
\321iZ!)\207" [c-syntactic-element c-assignment-op-regexp nil arglist-cont-nonempty (error) scan-lists -1 1 line-beginning-position beginning-of-line c-syntactic-re-search-forward line-end-position t 0 back-to-indentation c-forward-sws " 	" vector] 10 (#$ . 18338)])
#@355 Like `c-lineup-assignments' but indent with `c-basic-offset' if no
assignment operator was found on the first line.  I.e. this function
is the same as specifying a list (c-lineup-assignments +).  It's
provided for compatibility with old configurations.

Works with: topmost-intro-cont, statement-cont, arglist-cont,
arglist-cont-nonempty.

(fn LANGELEM)
(defalias 'c-lineup-math #[257 "\301
!\206\207" [c-basic-offset c-lineup-assignments] 3 (#$ . 19616)])
#@421 Line up true and false branches of a ternary operator (i.e. `?:').
More precisely, if the line starts with a colon which is a part of
a said operator, align it with corresponding question mark; otherwise
return nil.  For example:

    return arg % 2 == 0 ? arg / 2
                        : (3 * arg + 1);    <- c-lineup-ternary-bodies

Works with: arglist-cont, arglist-cont-nonempty and statement-cont.

(fn LANGELEM)
(defalias 'c-lineup-ternary-bodies #[257 "\212\300 \210\301f\302=\205\206`Tf\302=?\205\206\211\211A:\203#\211A\242\262
\202'\211A\262
\303\3042\204\305\306\307#\205\203o?\205\203\310u\210\301f\311=\203W\211S\211\262\312U\203,\313\304\314i!\"\210\202,`Sf\302=\204g`Sf\311=\203|`=\203u\313\304\301\"\210\202,`Sb\210\202,\211T\262
\202,0\266\202)\207" [back-to-indentation nil 58 1 done c-syntactic-skip-backward "^?:" t -1 63 0 throw vector] 7 (#$ . 20083)])
#@577 Line up "cascaded calls" under each other.
If the line begins with "->" or "." and the preceding line ends
with one or more function calls preceded by the same token, then the
arrow is lined up with the first of those tokens.  E.g.:

result = proc->add(17)->add(18)
             ->add(19) +           <- c-lineup-cascaded-calls
  offset;                          <- c-lineup-cascaded-calls (inactive)

In any other situation nil is returned to allow use in list
expressions.

Works with: topmost-intro-cont, statement-cont, arglist-cont,
arglist-cont-nonempty.

(fn LANGELEM)
(defalias 'c-lineup-cascaded-calls #[257 "\211\211@\262
\301=\205\211\243\243\242\262
\302\303 !=??\205\231\212\304 \210\305\306!\205*\307\310\311!!
\211A:\2039\211A\242\262
\202=\211A\262
\312\205\226\305!\205\226\313\314\315#\311U\205\226\312f\316=\205\226\313\317\315#\311U\205\226\305!\205\226i\262
\313\314\315#\311U\203\223\312f\316=\203\223\313\317\315#\311U\203\223\305!\203\223i\262
\202l\320
!\266\203)\207" [c-syntactic-element arglist-cont-nonempty c-most-enclosing-brace c-parse-state back-to-indentation looking-at "->\\|\\." regexp-quote match-string 0 nil c-backward-token-2 1 t 40 2 vector] 8 (#$ . 20986)])
#@432 Line up a continued string under the one it continues.
A continued string in this sense is where a string literal follows
directly after another one.  E.g.:

result = prefix + "A message "
                  "string.";      <- c-lineup-string-cont

In other situations, returns nil, to allow stacking with other
line-up functions.

Works with: topmost-intro-cont, statement-cont, arglist-cont,
arglist-cont-nonempty.

(fn LANGELEM)
(defalias 'c-lineup-string-cont #[257 "\212\300 \210\301\302!\205H\303f\303\304 \210`Sf=\203<\3051'\306`\307\"b\210\3100\202+\210\202<\203<`\211\262\212\300 \210`)U\203
\211\205F\211b\210\311i!\266\202)\207" [back-to-indentation looking-at "\\s\"" nil c-backward-sws (error) scan-sexps -1 t vector] 6 (#$ . 22220)])
#@230 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.

(fn LANGELEM)
(defalias 'c-lineup-template-args #[257 "\212\300 \210\301\302!\210\303f\304=\205\305\302\303\306 #\307U\205\310i!)\207" [beginning-of-line backward-up-list 1 nil 60 c-forward-token-2 line-end-position 0 vector] 5 (#$ . 22984)])
#@406 Line up selector args as Emacs Lisp 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 line up the current
line with it.

Works with: objc-method-call-cont.

(fn LANGELEM)
(defalias 'c-lineup-ObjC-method-call #[257 "\212\212\301 \210`
\211A:\203\211A\242\262
\202\211A\262
\206eV\203@\214\211\211A:\2031\211A\242\262
\2025\211A\262
\2069ed}\210\302 \210)`Sf\303=\203M[\202N\304)
\211A:\203^\211A\242\262
\202b\211A\262
\211b\210i\305u\210\306`\307\"b\210\310\305w\210l\203}\211\\\202~i\211ZZ\266\204)\207" [c-basic-offset back-to-indentation c-backward-sws 58 0 nil scan-sexps 1 " 	"] 7 (#$ . 23453)])
#@313 Line up selector args as Project Builder / XCode: colons of first
selector portions on successive lines are aligned.  If no decision can
be made return NIL, so that other lineup methods can be tried.  This is
typically chained with `c-lineup-ObjC-method-call'.

Works with: objc-method-call-cont.

(fn LANGELEM)
(defalias 'c-lineup-ObjC-method-call-colons #[257 "\212\3032\241\304 \210\305\306\307 \310#\203`\212\304 \210`)Z\202 \311\303\312\"\212\304 \210`\211A:\2034\211A\242\262
\2028\211A\262
\206<eV\203_\214
\211A:\203P\211A\242\262
\202T\211A\262
\206Xed}\210\313 \210)`Sf\314=\203k\202l\315)\316!\312u\210\317`\320\"b\210\305\306\307 \310#\203\213\321i$\202\214	\211\nY\203\232\211\\\266\204\202\240\311\303\312\"\266\2040)\207" [c-objc-method-parameter-offset c-objc-method-arg-unfinished-offset c-objc-method-arg-min-delta-to-bracket no-idea back-to-indentation search-forward ":" line-end-position move throw nil c-backward-sws 58 0 c-langelem-col scan-sexps 2 -] 9 (#$ . 24315)])
#@188 Line up the colons that separate args in a method declaration.
The colon on the current line is aligned with the one on the first
line.

Works with: objc-method-args-cont.

(fn LANGELEM)
(defalias 'c-lineup-ObjC-method-args #[257 "\212\212\301 \210`)\211b\210i\302 \211A:\203\211A\242\262
\202 \211A\262
\211b\210\303w\210\304f\305=\205/i\211\2049\266\205\202Tb\210\303w\210\304f\305=\203Q
iZ\\\266\205\202T\266\205)\207" [c-basic-offset back-to-indentation line-end-position "^:" nil 58] 9 (#$ . 25338)])
#@191 Line up the colons that separate args in a method declaration.
The colon on the current line is aligned with the one on the previous
line.

Works with: objc-method-args-cont.

(fn LANGELEM)
(defalias 'c-lineup-ObjC-method-args-2 #[257 "\212\212\301 \210`)\211b\210i\302 \211A:\203\211A\242\262
\202 \211A\262
\303
x\210`Sf\304=\205.iS\211\2048\266\205\202Sb\210\303w\210\305f\304=\203P
iZ\\\266\205\202S\266\205)\207" [c-basic-offset back-to-indentation line-end-position "^:" 58 nil] 9 (#$ . 25866)])
#@354 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.

(fn LANGELEM)
(defalias 'c-lineup-inexpr-block #[257 "\212\300 \210\301 \302
!\303\304\"\"\206.\211\205.\211b\210\305f\306=\205.\302`\"\262
\303\304\"\"\211\2059\211Ab\210\307i!\266\203)\207" [back-to-indentation c-parse-state c-most-enclosing-brace c-looking-at-inexpr-block c-safe-position nil 123 vector] 7 (#$ . 26389)])
#@668 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, inline-close, block-close,
brace-list-close, brace-list-intro, statement-block-intro,
arglist-intro, arglist-cont-nonempty, arglist-close, and all in*
symbols, e.g. inclass and inextern-lang.

(fn LANGELEM)
(defalias 'c-lineup-whitesmith-in-block #[257 "\212\301 \210\3021\303`\304\305#0\202\210\306\211\205\211b\210\307\262
\205(`\212\310 \210`)U?\205-)\207" [c-basic-offset beginning-of-line (error) scan-lists -1 1 nil t back-to-indentation] 5 (#$ . 27071)])
#@1159 Compensate for Whitesmith style indentation of blocks.
Due to the way CC Mode calculates anchor positions for normal lines
inside blocks, this function is necessary for those lines to get
correct Whitesmith style indentation.  Consider the following
examples:

                    int foo()
                        {
int foo()                   {
    {                       a;
    a;                      }
    x;       <->        x;        <- c-lineup-after-whitesmith-blocks

The fact that the line with "x" is preceded by a Whitesmith style
indented block in one case and not the other should not affect its
indentation.  But since CC Mode in cases like this uses the
indentation of the preceding statement as anchor position, the "x"
would in the rightmost case be indented too much if the offset for
`statement' was set simply to zero.

This lineup function corrects for this situation by detecting if the
anchor position is at an open paren character.  In that case, it
instead indents relative to the surrounding block just like
`c-lineup-whitesmith-in-block'.

Works with: brace-list-entry, brace-entry-open, statement,
arglist-cont.

(fn LANGELEM)
(defalias 'c-lineup-after-whitesmith-blocks #[257 "\212\211\211A:\203\211A\242\262
\202\211A\262
b\210\301\302!\205U\3031)\304`\305\306#0\202+\210\307\211\2053\211b\210\310\262
\203R`\311 \210\211`U\203H\312i!\202M\312i\\!\262
\202U\312\313!)\207" [c-basic-offset looking-at "\\s(" (error) scan-lists -1 1 nil t back-to-indentation vector 0] 5 (#$ . 28010)])
#@826 Lineup the second entry of a brace block under the first, when the first
line is also contained in an arglist or an enclosing brace ON THAT LINE.

I.e. handle something like the following:

    set_line (line_t {point_t{0.4, 0.2},
                      point_t{0.2, 0.5},       <---- brace-list-intro
                      .....});
             ^ enclosing parenthesis.

The middle line of that example will have a syntactic context
with three syntactic symbols, arglist-cont-nonempty, brace-list-intro, and
brace-list-entry.

This function is intended for use in a list.  If the construct
being analyzed isn't like the preceding, the function returns nil.
Otherwise it returns the function `c-lineup-arglist-intro-after-paren', which
the caller then uses to perform indentation.

Works with brace-list-intro.

(fn LANGELEM)
(defalias 'c-lineup-2nd-brace-entry-in-arglist #[257 "\301\236\205Y\302\236\205Y\303\236\204X\212\302\236\211A:\203$\211A\242\262
\202(\211A\262
b\210\304\305\306\212\302\236\211A:\203?\211A\242\262
\202C\211A\262
b\210\307 \210`)#\310=\205T\306f\311=)\205Y\312\207" [c-syntactic-context brace-list-intro brace-list-entry arglist-cont-nonempty c-backward-token-2 1 nil beginning-of-line 0 123 c-lineup-arglist-intro-after-paren] 6 (#$ . 29547)])
#@925 Line up the second entry of a class (etc.) initializer c-basic-offset
characters in from the identifier when:
(i) The type is a class, struct, union, etc. (but not an enum);
(ii) There is a brace block in the type declaration, specifying it; and
(iii) The first element of the initializer is on the same line as its opening
brace.

I.e. we have a construct like this:

    struct STR {
        int i; float f;
    } str_1 = {1, 1.7},
        str_2 = {2,
             3.1                   <---- brace-list-intro
        };
        <-->                       <---- c-basic-offset

Note that the syntactic context of the brace-list-intro line also has a
syntactic element with the symbol brace-list-entry.

This function is intended for use in a list.  If the above structure isn't
present, this function returns nil, allowing a different offset specification
to indent the line.

Works with: brace-list-intro.

(fn LANGELEM)
(defalias 'c-lineup-class-decl-init-+ #[257 "\302\236\205_\303\236\205_\212\303\236\211A:\203\211A\242\262
\202\"\211A\262
b\210\304 \210`)\212\302\236\211A:\203;\211A\242\262
\202?\211A\262
b\210\305 \205\\\306
\307\310\211\211%?\205\\`
=\205\\\311i	\\!)\262
\207" [c-syntactic-context c-basic-offset brace-list-intro brace-list-entry back-to-indentation c-forward-class-decl c-do-declarators t nil vector] 8 (#$ . 30839)])
#@1001 Line up the second entry of a class (etc.) initializer after its opening
brace when:
(i) The type is a class, struct, union, etc. (but not an enum);
(ii) There is a brace block in the type declaration, specifying it; and
(iii) The first element of the initializer is on the same line as its opening
brace.

I.e. we have a construct like this:

    struct STR {
        int i; float f;
    } str_1 = {1, 1.7},
        str_2 = {2,
                 3.1                   <---- brace-list-intro
        };

Note that the syntactic context of the brace-list-intro line also has a
syntactic element with the symbol brace-list-entry.  Also note that this
function works by returning the symbol `c-lineup-arglist-intro-after-paren',
which the caller then uses to perform the indentation.

This function is intended for use in a list.  If the above structure isn't
present, this function returns nil, allowing a different offset specification
to indent the line.

Works with: brace-list-intro.

(fn LANGELEM)
(defalias 'c-lineup-class-decl-init-after-brace #[257 "\301\236\205[\302\236\205[\212\302\236\211A:\203\211A\242\262
\202\"\211A\262
b\210\303 \210`)\212\301\236\211A:\203;\211A\242\262
\202?\211A\262
b\210\304 \205X\305
\306\307\211\211%?\205X`
=\205X\310)\262
\207" [c-syntactic-context brace-list-intro brace-list-entry back-to-indentation c-forward-class-decl c-do-declarators t nil c-lineup-arglist-intro-after-paren] 8 (#$ . 32210)])
#@2015 Line up macro continuation lines according to the indentation of
the construct preceding the macro.  E.g.:

v beg of preceding constr      v beg of preceding constr
                             int dribble() {
const char msg[] =             if (!running)
  "Some text.";	         error("Not running!");

#define X(A, B)  \           #define X(A, B)    \
do {             \    <->      do {             \    <- c-lineup-cpp-define
  printf (A, B); \               printf (A, B); \
} while (0)                    } while (0)

If `c-syntactic-indentation-in-macros' is non-nil, the function
returns the relative indentation to the macro start line to allow
accumulation with other offsets.  E.g. in the following cases,
cpp-define-intro is combined with the statement-block-intro that comes
from the `do {' that hangs on the `#define' line:

                             int dribble() {
const char msg[] =             if (!running)
  "Some text.";	         error("Not running!");

#define X(A, B) do { \       #define X(A, B) do { \
  printf (A, B);     \  <->      printf (A, B);   \  <- c-lineup-cpp-define
  this->refs++;      \           this->refs++;    \
} while (0)             <->    } while (0)           <- c-lineup-cpp-define

The relative indentation returned by `c-lineup-cpp-define' is zero and
two, respectively, in these two examples.  They are then added to the
two column indentation that statement-block-intro gives in both cases
here.

If the relative indentation is zero, then nil is returned instead.
That is useful in a list expression to specify the default indentation
on the top level.

If `c-syntactic-indentation-in-macros' is nil then this function keeps
the current indentation, except for empty lines (ignoring the ending
backslash) where it takes the indentation from the closest preceding
nonempty line in the macro.  If there's no such line in the macro then
the indentation is taken from the construct preceding it, as described
above.

Works with: cpp-define-intro.

(fn LANGELEM)
(defalias 'c-lineup-cpp-define #[257 "\305\203#\212\306 \210\307\310\311\312 \"!\212\313 \210i)Z\262
\211\314U?\205!\211)\207\212\212	9\203E\212\315 \316\211\316\317\320\"\216\306 \205>`,\262
)\202F	b\210\321 \210`)\321 \210`
V\203c\322\323!\203c\324y\314U\204P`
X\203u\307\310\325\312 \"!\262\202y\326 \262
\314U?\205\203\327!\262
)\207" [c-syntactic-indentation-in-macros c-macro-start buffer-undo-list inhibit-read-only inhibit-modification-hooks nil c-beginning-of-macro c-get-syntactic-indentation delete (cpp-macro) c-guess-basic-syntax back-to-indentation 0 buffer-modified-p t make-closure #[0 "\300?\205\301\302!\207" [V0 restore-buffer-modified-p nil] 2] beginning-of-line looking-at "[ 	]*\\\\?$" -1 (cpp-macro) current-indentation vector] 7 (#$ . 33672)])
#@616 Line up a gcc asm register under one on a previous line.

    asm ("foo %1, %0\n"
         "bar %0, %1"
         : "=r" (w),
           "=r" (x)
         :  "0" (y),
            "1" (z));

The "x" line is aligned to the text after the ":" on the "w" line, and
similarly "z" under "y".

This is done only in an "asm" or "__asm__" block, and only to
those lines mentioned.  Anywhere else nil is returned.  The usual
arrangement is to have this routine as an extra feature at the start
of arglist line-ups, e.g.

    (c-lineup-gcc-asm-reg c-lineup-arglist)

Works with: arglist-cont, arglist-cont-nonempty.

(fn ELEM)
(defalias 'c-lineup-gcc-asm-reg #[257 "`\302\212\303 \210\205L@\304=\203 	\211\243\243\242\262
\305\306 !=\205L\307\310A\311#\205L\312\224\211\262\205L
b\210\303 \210\313\314!?\205L
b\210\315 \205L\316
b\210i!)\207" [c-opt-asm-stmt-key c-syntactic-element nil beginning-of-line arglist-cont-nonempty c-most-enclosing-brace c-parse-state re-search-backward "^[ 	]*:[ 	]*\\(.\\)?" t 1 looking-at "^[ 	]*:" c-in-gcc-asm-p vector] 7 (#$ . 36482)])
#@284 Line up the current line directly under the anchor position in LANGELEM.

This is like 0, except it supersedes any indentation already calculated for
previous syntactic elements in the syntactic context.

Works with: Any syntactic symbol which has an anchor position.

(fn LANGELEM)
(defalias 'c-lineup-under-anchor #[257 "\212\211\211A:\203\211A\242\262
\202\211A\262
b\210\300i!)\207" [vector] 3 (#$ . 37559)])
#@102 Do not change the indentation of the current line.

Works with: Any syntactic symbol.

(fn LANGELEM)
(defalias 'c-lineup-dont-change #[257 "\212\300 \210\301i!)\207" [back-to-indentation vector] 3 (#$ . 37983)])
#@252 If the current line starts at column 0, return [0].  Otherwise return nil.

This can be used for comments (in conjunction with, say,
`c-lineup-comment'), to keep comments already at column 0
anchored there, but reindent other comments.

(fn LANGELEM)
(defalias 'c-lineup-respect-col-0 #[257 "\212\300 \210i\301=\205\302)\207" [back-to-indentation 0 [0]] 3 (#$ . 38202)])
#@326 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.

(fn SYNTAX POS)
(defalias 'c-snug-do-while #[514 "\212\301\302=\203F\302\236\211\262\203F\211\211A:\203 \211A\242\262
\202$\211A\262
b\210\301f\303=\203<\3041;\305`\306\"b0\210\202<\210\307\310!\203F\311\202G\312\262
)\207" [c-syntactic-context nil block-close 123 (error) scan-sexps -1 looking-at "\\<do\\>[^_]" (before) (before after)] 6 (#$ . 38582)])
#@186 Determine the brace hanginess for an AWK defun-close.
If the action/function being closed is a one-liner, keep it so.  Otherwise put
the closing brace on its own line.

(fn SYNTAX POS)
(defalias 'c-snug-1line-defun-close #[514 "\212\211b\210\300 \301\302!\210`V\203\303\202\304)\207" [line-beginning-position up-list -1 (before after) (after)] 5 (#$ . 39265)])
#@146 Imposes a minimum indentation for lines inside code blocks.
The variable `c-label-minimum-indentation' specifies the minimum
indentation amount.
(defalias 'c-gnu-impose-minimum #[0 "\303\236\206	\304\236?\205;	\305\203%@\236\211\262\204%A\262\202\266\202\205;\212\306 \210i\nW)\205;\307\n\310 Z!\207" [c-syntactic-context c-inside-block-syms c-label-minimum-indentation cpp-macro comment-intro nil back-to-indentation c-shift-line-indentation current-indentation] 5 (#$ . 39637)])
#@321 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.
(defalias 'c-semi&comma-inside-parenlist #[0 "\301=\205#\3021\212\303\304!\210\305f)\306=?0\202\210\202 \203\"\307\207\310\207" [last-command-event 59 (error) up-list -1 nil 40 t stop] 2 (#$ . 40142)])
#@225 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.
(defalias 'c-semi&comma-no-newlines-before-nonblanks #[0 "\212\301U\205\302y\303U\205n\205\304\305!?\205\306)\207" [last-command-event 59 1 0 looking-at "^[ 	]*$" stop] 2 (#$ . 40679)])
#@263 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.
(defalias 'c-semi&comma-no-newlines-for-oneline-inliners #[0 "\301 \212\3021\303\304!\210\3050\202\210\202\203\306 \202\304)\307=\205=
@@\310=\205=
A@@\311=\205=\306 
U\205=\312\207" [last-command-event c-guess-basic-syntax (error) up-list -1 t line-beginning-position 59 inclass topmost-intro stop] 4 (#$ . 41105)])
(provide 'cc-align)