indent.h

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

    int ljust_decl;          /* true if declarations should be left justified */
    int cast_space;          /* If true, casts look like: (char *) bar rather than (char *)bar */
    int cuddle_else;         /* true if else should cuddle up to '}' */
    int cuddle_do_while;     /* true if '}' should cuddle up to while in do loop */
    int comment_delimiter_on_blankline;
    int blank_after_sizeof; /* true iff a blank should always be inserted after sizeof */
    int break_function_decl_args;    /* true if declarations should have args on new lines */
    int break_function_decl_args_end; /* true if declarations should have
                                       * ")" after args on new lines */
    int leave_comma;         /* if true, never break declarations after commas */
    int break_before_boolean_operator;       /* True when we prefer to break a long line
                                              * before a '&&' or '||', instead of behind it.
                                              */
    int blanklines_before_blockcomments;
    int blanklines_after_declarations;
    int blanklines_after_procs;
    int blanklines_after_declarations_at_proctop;    /* This is vaguely  similar to blanklines_after_declarations except that
                                                      * it only applies to the first set of declarations in a procedure (just after
                                                      * the first '{') and it causes a blank line to be generated even
                                                      * if there are no declarations
                                                      */
    int blanklines_around_conditional_compilation;
    int comment_max_col;
    int max_col;             /* the maximum allowable line length */
    int ind_size; /* The size of one indentation level in spaces.  */
    int indent_parameters; /* Number of spaces to indent parameters.  */
    int decl_indent;         /* column to indent declared identifiers to */
    int unindent_displace;   /* comments not to the right of code will be
                              * placed this many indentation levels to the
                              * left of code */
    int else_endif_col; /* The column in which comments to the right of #else and #endif should start. */
    int case_indent;         /* The distance to indent case labels from the switch statement */
    int continuation_indent; /* set to the indentation between the edge of code and continuation lines in spaces */
    int decl_com_ind;        /* the column in which comments after declarations should be put */
    int case_brace_indent;   /* Indentation level to be used for a '{'
                              * directly following a case label. */
    int c_plus_plus; /* True if we're handling C++ code. */
    int com_ind;             /* the column in which comments to the right of code should start */
    int braces_on_struct_decl_line; /* when true, brace should be on same line as the struct declaration */
    int braces_on_func_def_line; /* when true, brace should be on same line as the function definition */
    int btype_2; /* when true, brace should be on same line as if, while, etc */
    int brace_indent; /* number of spaces to indent braces from the suround if, while, etc. in -bl
                       * (bype_2 == 0) code */
    int expect_output_file;  /* Means "-o" was specified. */
} user_options_ty;

extern user_options_ty settings;

/* True if there is an embedded comment on this code line */
extern int embedded_comment_on_line;

extern int else_or_endif;
extern int di_stack_alloc;
extern int *di_stack;

extern int else_or_endif; /* True if a #else or #endif has been encountered.  */

extern int     code_lines;          /* count of lines with code */

extern int     out_lines;           /* the number of lines written, set by
                                 * dump_line */
extern int     com_lines;           /* the number of lines with comments, set by
                                 * dump_line */


extern BOOLEAN had_eof;             /* set to true when input is exhausted */
extern int     line_no;             /* the current input line number. */



extern int use_stdinout; /* Nonzero if we should use standard input/output when files are not
                          * explicitly specified.  */

/* This structure contains information relating to the state of parsing the
 * code.  The difference is that the state is saved on #if and restored on
 * #else.  */

typedef struct parser_state
{
    struct parser_state * next;
    codes_ty              last_token;

    /* This is the parsers stack, and the current allocated size.  */
    codes_ty            * p_stack;
    int                   p_stack_size;

    /* This stack stores indentation levels 
     * Currently allocated size is stored in p_stack_size.  */

    int                 * il;

    /* If the last token was an ident and is a reserved word,
     * remember the type. */

    rwcodes_ty            last_rw;

    /* also, remember its depth in parentheses */

    int                   last_rw_depth;

    /* Used to store case stmt indentation levels.  */
    /* Currently allocated size is stored in p_stack_size.  */
    int                  *cstk;

    /* Pointer to the top of stack of the p_stack, il and cstk arrays. */
    int                   tos;

    int                   box_com; /* set to true when we are in a
                                    * "boxed" comment. In that case, the
                                    * first non-blank char should be
                                    * lined up with the / in the comment
                                    * closing delimiter */

    int                   cast_mask; /* indicates which close parens close off
                                      * casts */
    /* A bit for each paren level, set if the open paren was in a context which
       indicates that this pair of parentheses is not a cast.  */
    int                   noncast_mask;

    int                   sizeof_mask; /* indicates which close parens close off
                                        * sizeof''s */
    int                   block_init;  /* set to 1 if inside a block initialization
                                        * set to 2 if inside an enum declaration */
    int block_init_level;         /* The level of brace nesting in an
                                   * initialization (0 in an enum decl) */
    int last_nl;                  /* this is true if the last thing scanned was
                                   * a newline */
    int last_saw_nl;              /* this is true if the last non white space
                                   * scanned was a newline */
    int saw_double_colon;         /* set when we see a ::, reset at first semi-
                                   * colon or left brace */
    int broken_at_non_nl;         /* true when a line was broken at a place
                                   * where there was no newline in the input file */
    int in_or_st;                 /* Will be true iff there has been a
                                   * declarator (e.g. int or char) and no left
                                   * paren since the last semicolon. When true,
                                   * a '{' is starting a structure definition
                                   * or an initialization list */
    int col_1;                    /* set to true if the last token started in
                                   * column 1 */
    int com_col;                  /* this is the column in which the current
                                   * coment should start */
    int dec_nest;                 /* current nesting level for structure or
                                   * init */
    int decl_on_line;             /* set to true if this line of code has part
                                   * of a declaration on it */
    int i_l_follow;               /* the level in spaces to which ind_level
                                   * should be set after the current line is
                                   * printed */
    BOOLEAN in_decl;              /* set to true when we are in a declaration
                                   * statement.  The processing of braces is then
                                   * slightly different */
    int in_stmt;                  /* set to 1 while in a stmt */
    int in_parameter_declaration;
    int ind_level;                /* the current indentation level in spaces */
    int ind_stmt;                 /* set to 1 if next line should have an extra
                                   * indentation level because we are in the
                                   * middle of a stmt */
    int last_u_d;                 /* set to true after scanning a token which
                                   * forces a following operator to be unary */
    int p_l_follow;               /* used to remember how to indent following
                                   * statement */
    int paren_level;              /* parenthesization level. used to indent
                                   * within stmts */
    int paren_depth;              /* Depth of paren nesting anywhere. */
    
    /* Column positions of paren at each level.  If positive, it contains just
     * the number of characters of code on the line up to and including the
     * right parenthesis character.  If negative, it contains the opposite of
     * the actual level of indentation in characters (that is, the indentation
     * of the line has been added to the number of characters and the sign has
     * been reversed to indicate that this has been done).  */
    short *paren_indents;         /* column positions of each paren */
    int paren_indents_size;       /* Currently allocated size.  */

    int pcase;                    /* set to 1 if the current line label is a
                                   * case.  It is printed differently from a
                                   * regular label */
    int search_brace;             /* set to true by parse when it is necessary
                                   * to buffer up all info up to the start of a
                                   * stmt after an if, while, etc */
    int use_ff;                   /* set to one if the current line should be
                                   * terminated with a form feed */
    int want_blank;               /* set to true when the following token
                                   * should be prefixed by a blank. (Said
                                   * prefixing is ignored in some cases.) */
    bb_code_ty can_break;         /* set when a break is ok before the following
                                   * token (is automatically implied by
                                   * `want_blank'. */
    int its_a_keyword;
    int sizeof_keyword;
    char *procname;               /* The name of the current procedure */
    char *procname_end;           /* One char past the last one in procname */
    char *classname;              /* The name of the current C++ class */
    char *classname_end;          /* One char past the last one in classname */
    int just_saw_decl;
    int matching_brace_on_same_line;      /* Set to a value >= 0 if the the
                                             current '}' has a matching '{'
                                             on the same input line */
} parser_state_ty;

/* All manipulations of the parser state occur at the top of stack (tos). A
 * stack is kept for conditional compilation (unrelated to the p_stack, il, &
 * cstk stacks)--it is implemented as a linked list via the next field. */

extern parser_state_ty *parser_state_tos;

extern int output_line_length (void);

#endif /* INDENT_INDENT_H */