indent.1

indent为linux下代码自动格式化工具

the \fIleft\fR, or unindented.  For example, \`-d2\' places comments
two spaces to the left of code.  By default, comments are aligned with
code, unless they begin in the first column, in which case they are left
there by default --- to get them aligned with the code, specify \`-fc1\'.

Comments to the right of code will appear by default in column 33.
This may be changed with one of three options.  \`-c\' will specify
the column for comments following code, \`-cd\' specifies the
column for comments following declarations, and \`-cp\' specifies
the column for comments following preprocessor directives \fB#else\fR
and \fB#endif\fR.

If the code to the left of the comment exceeds the beginning column,
the comment column will be extended to the next tabstop column past
the end of the code, or in the case of preprocessor directives, to one
space past the end of the directive.  This extension lasts only for
the output of that particular comment.

The \`-cdb\' option places the comment delimiters on blank lines.
Thus, a single line comment like \fB/* Loving hug */\fR can be
transformed into:

.in +5
.nf
.na
/*
   Loving hug
 */
.in -5
.ad
.fi

Stars can be placed at the beginning of multi-line comments with the
\`-sc\' option.  Thus, the single-line comment above can be
transformed (with \`-cdb -sc\') into:

.in +5
.nf
.na
/*
 * Loving hug
 */
.in -5
.ad
.fi

.SH "STATEMENTS"

The \`-br\' or \`-bl\' option specifies how to format braces.

The \`-br\' option formats statement braces like this:

.in +5
.nf
.na
if (x > 0) {
  x--;
}
.in -5
.ad
.fi

The \`-bl\' option formats them like this:

.in +5
.nf
.na
if (x > 0)
  {
    x--;
  }
.in -5
.ad
.fi

If you use the \`-bl\' option, you may also want to specify the
\`-bli\' option.  This option specifies the number of spaces by
which braces are indented.  \`-bli2\', the default, gives the
result shown above.  \`-bli0\' results in the following:

.in +5
.nf
.na
if (x > 0)
{
  x--;
}
.in -5
.ad
.fi

If you are using the \`-br\' option, you probably want to also use
the \`-ce\' option.  This causes the \fBelse\fR in an if-then-else
construct to cuddle up to the immediately preceding \`}\'.  For
example, with \`-br -ce\' you get the following:

.in +5
.nf
.na
if (x > 0) {
  x--;
} else {
  fprintf (stderr, "...something wrong?\\n");
}
.in -5
.ad
.fi

With \`-br -nce\' that code would appear as

.in +5
.nf
.na
if (x > 0) {
  x--;
}
else {
  fprintf (stderr, "...something wrong?\\n");
}
.in -5
.ad
.fi

This causes the \fBwhile\fR in a do-while
loop to cuddle up to the immediately preceding \`}\'.  For
example, with \`-cdw\' you get the following:

.in +5
.nf
.na
do {
  x--;
} while (x);
.in -5
.ad
.fi

With \`-ncdw\' that code would appear as

.in +5
.nf
.na
do {
  x--;
}
while (x);
.in -5
.ad
.fi

The \`-cli\' option specifies the number of spaces that case labels
should be indented to the right of the containing \fBswitch\fR
statement.

The default gives code like:

.in +5
.nf
.na
switch (i)
  {
  case 0:
    break;
  case 1:
    {
      ++i;
    }
  default:
    break;
  }
.in -5
.ad
.fi

Using the \`-cli2\' that would become:

.in +5
.nf
.na
switch (i)
  {
    case 0:
      break;
    case 1:
      {
        ++i;
      }
    default:
      break;
  }
.in -5
.ad
.fi

The indentation of the braces below a case statement can be
controlled with the \`-cbi\fIn\fR\' option.  For example,
using \`-cli2 -cbi0\' results in:

.in +5
.nf
.na
switch (i)
  {
    case 0:
      break;
    case 1:
    {
      ++i;
    }
    default:
      break;
  }
.in -5
.ad
.fi

If a semicolon is on the same line as a \fBfor\fR or \fBwhile\fR
statement, the \`-ss\' option will cause a space to be placed before
the semicolon.  This emphasizes the semicolon, making it clear that the
body of the \fBfor\fR or \fBwhile\fR statement is an empty statement.
\`-nss\' disables this feature.

The \`-pcs\' option causes a space to be placed between the name of
the procedure being called and the \`(\' (for example, \fBputs\ ("Hi");\fR.  The \`-npcs\' option would give \fBputs("Hi");\fR).


If the \`-cs\' option is specified, \fBindent\fR puts a space after
a cast operator.

The \`-bs\' option ensures that there is a space between the
keyword \fBsizeof\fR and its argument.  In some versions, this is
known as the \`Bill_Shannon\' option.

The \`-saf\' option forces a space between an \fBfor\fR
and the following parenthesis.  This is the default.

The \`-sai\' option forces a space between an \fBif\fR
and the following parenthesis.  This is the default.

The \`-saw\' option forces a space between an \fBwhile\fR
and the following parenthesis.  This is the default.

The \`-prs\' option causes all parentheses to be seperated with
a space from the what is between them.  For example, using \`-prs\'
results in code like:

.in +5
.nf
.na
  while ( ( e_code - s_code ) < ( dec_ind - 1 ) )
    {
      set_buf_break ( bb_dec_ind );
      *e_code++ = \' \';
    }
.in -5
.ad
.fi

.SH "DECLARATIONS"

By default \fBindent\fR will line up identifiers, in the column
specified by the \`-di\' option.  For example, \`-di16\' makes
things look like:

.in +5
.nf
.na
int             foo;
char           *bar;
.in -5
.ad
.fi

Using a small value (such as one or two) for the \`-di\' option can
be used to cause the identifiers to be placed in the first available
position; for example:

.in +5
.nf
.na
int foo;
char *bar;
.in -5
.ad
.fi

The value given to the \`-di\' option will still affect variables
which are put on separate lines from their types, for example
\`-di2\' will lead to:

.in +5
.nf
.na
int
  foo;
.in -5
.ad
.fi

If the \`-bc\' option is specified, a newline is forced after each
comma in a declaration.  For example,

.in +5
.nf
.na
int a,
  b,
  c;
.in -5
.ad
.fi

With the \`-nbc\' option this would look like

.in +5
.nf
.na
int a, b, c;
.in -5
.ad
.fi

The \`-bfda\' option causes a newline to be forced after the comma
separating the arguments of a function declaration.  The arguments will
appear at one indention level deeper than the function declaration.  This 
is particularly helpful for functions with long argument lists. 
The option \`-bfde\' causes a newline to be forced before the closing 
bracket of the function declaration. For both options the \'n\' setting is the default:
-nbdfa and -nbdfe.


For 
example,

.in +5
.nf
.na
void foo (int arg1, char arg2, int *arg3, long arg4, char arg5);
.in -5
.ad
.fi
With the \`-bfda\' option this would look like

.in +5
.nf
.na
void foo (
    int arg1,
    char arg2,
    int *arg3,
    long arg4,
    char arg5);
.in -5
.ad
.fi

With, in addition, the \`-bfde\' option this would look like

.in +5
.nf
.na
void foo (
    int arg1,
    char arg2,
    int *arg3,
    long arg4,
    char arg5
    );
.in -5
.ad
.fi

The \`-psl\' option causes the type of a procedure being defined to
be placed on the line before the name of the procedure.  This style is
required for the \fBetags\fR program to work correctly, as well as some
of the \fBc-mode\fR functions of Emacs.

You must use the \`-T\'
option to tell \fBindent\fR the name of all the typenames in your
program that are defined by \fBtypedef\fR.  \`-T\' can be specified
more than once, and all names specified are used.  For example, if your
program contains

.in +5
.nf
.na
typedef unsigned long CODE_ADDR;
typedef enum {red, blue, green} COLOR;
.in -5
.ad
.fi

you would use the options \`-T CODE_ADDR -T COLOR\'.

The \`-brs\' or \`-bls\' option specifies how to format braces
in struct declarations.  The \`-brs\' option formats braces like
this:

.in +5
.nf
.na
struct foo {
  int x;
};
.in -5
.ad
.fi

The \`-bls\' option formats them like this:

.in +5
.nf
.na
struct foo
{
  int x;
};
.in -5
.ad
.fi

.SH "INDENTATION"

One issue in the formatting of code is how far each line should be
indented from the left margin.  When the beginning of a statement such
as \fBif\fR or \fBfor\fR is encountered, the indentation level is
increased by the value specified by the \`-i\' option.  For example,
use \`-i8\' to specify an eight character indentation for each
level.  When a statement is broken across two lines, the second line is
indented by a number of additional spaces specified by the \`-ci\'
option.  \`-ci\' defaults to 0.  However, if the \`-lp\' option is
specified, and a line has a left parenthesis which is not closed on that
line, then continuation lines will be lined up to start at the character
position just after the left parenthesis.  This processing also applies
to \`[\' and applies to \`{\' when it occurs in initialization
lists.  For example, a piece of continued code might look like this with