/* Copyright (c) 1999 Carlo Wood. All rights reserved.
* Copyright (c) 1994 Joseph Arceneaux. All rights reserved.
* Copyright (c) 1992 Free Software Foundation, Inc. All rights reserved.
*
* Copyright (c) 1985 Sun Microsystems, Inc. Copyright (c) 1980 The Regents
* of the University of California. Copyright (c) 1976 Board of Trustees of
* the University of Illinois. All rights reserved.
*
* Redistribution and use in source and binary forms are permitted
* provided that
* the above copyright notice and this paragraph are duplicated in all such
* forms and that any documentation, advertising materials, and other
* materials related to such distribution and use acknowledge that the
* software was developed by the University of California, Berkeley, the
* University of Illinois, Urbana, and Sun Microsystems, Inc. The name of
* either University or Sun Microsystems may not be used to endorse or
* promote products derived from this software without specific prior written
* permission. THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES
* OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
*
* 2002-11-10 Cristalle Azundris Sabon <cristalle@azundris.com>
* Added --preprocessor-indentation (ppi) if set, will indent nested
* preprocessor-statements with n spaces per level. overrides -lps.
*/
#ifndef INDENT_INDENT_H
#define INDENT_INDENT_H
#include "sys.h"
RCSTAG_H (indent, "$Id: indent.h,v 1.37 2002/11/10 21:02:48 david Exp $");
#include <config.h>
#include <libgettext.h>
#ifdef ENABLE_NLS
#define _(X) gettext(X)
#else
#define _(X) X
#endif
#include "lexi.h"
#include "io.h"
/* Values that `indent' can return for exit status.
*
* `total_success' means no errors or warnings were found during a successful
* invocation of the program.
*
* `invocation_error' is returned if an invocation problem (like an incorrect
* option) prevents any formatting to occur.
*
* `indent_error' is returned if errors occur during formatting which
* do not prevent completion of the formatting, but which appear to be
* manifested by incorrect code (i.e, code which wouldn't compile).
*
* `indent_punt' is returned if formatting of a file is halted because of
* an error with the file which prevents completion of formatting. If more
* than one input file was specified, indent continues to the next file.
*
* `indent_fatal' is returned if a serious internal problem occurs and
* the entire indent process is terminated, even if all specified files
* have not been processed. */
typedef enum exit_values
{
total_success = 0,
invocation_error = 1,
indent_error = 2,
indent_punt = 3,
indent_fatal = 4,
system_error = 5
} exit_values_ty;
typedef unsigned char BOOLEAN;
#define false 0
#define true 1
#define DEFAULT_RIGHT_MARGIN 78
#define DEFAULT_RIGHT_COMMENT_MARGIN 78
/* Name of input file. */
extern char *in_name;
extern char *in_prog; /* pointer to the null-terminated input
program */
/* Point to the position in the input program which we are currently looking
at. */
extern char *in_prog_pos;
/* Point to the start of the current line. */
extern char *cur_line;
/* Size of the input program, not including the ' \n\0' we add at the end */
extern unsigned long in_prog_size;
extern char *labbuf; /* buffer for label */
extern char *s_lab; /* start ... */
extern char *e_lab; /* .. and end of stored label */
extern char *l_lab; /* limit of label buffer */
extern char *codebuf; /* buffer for code section */
extern char *s_code; /* start ... */
extern char *s_code_corresponds_to; /* If set, start of corresponding
code in token buffer... */
extern char *e_code; /* .. and end of stored code */
extern char *l_code; /* limit of code section */
extern char *combuf; /* buffer for comments */
extern char *s_com; /* start ... */
extern char *e_com; /* ... and end of stored comments */
extern char *l_com; /* limit of comment buffer */
extern char *buf_ptr; /* ptr to next character to be taken from
in_buffer */
extern char *buf_end; /* ptr to first after last char in in_buffer */
extern int break_line; /* Whether or not we should break the line. */
/* pointer to the token that lexi() has just found */
extern char *token;
/* points to the first char after the end of token */
extern char *token_end;
extern int squest;
extern file_buffer_ty *current_input;
/* Used to keep track of buffers. */
typedef struct buf
{
char *ptr; /* points to the start of the buffer */
char *end; /* points to the character beyond the last
one (e.g. is equal to ptr if the buffer is
empty). */
int size; /* how many chars are currently allocated. */
int len; /* how many chars we're actually using. */
int start_column; /* corresponding column of first character
in the buffer. */
int column; /* Column we were in when we switched buffers. */
} buf_ty;
/* Buffer in which to save a comment which occurs between an if(), while(),
* etc., and the statement following it. Note: the fact that we point into
* this buffer, and that we might realloc() it (via the need_chars macro) is
* a bad thing (since when the buffer is realloc'd its address might change,
* making any pointers into it point to garbage), but since the filling of
* the buffer (hence the need_chars) and the using of the buffer (where
* buf_ptr points into it) occur at different times, we can get away with it
* (it would not be trivial to fix). */
extern buf_ty save_com;
extern char *bp_save; /* saved value of buf_ptr when taking input
from save_com */
extern char *be_save; /* similarly saved value of buf_end */
extern int pointer_as_binop;
extern int n_real_blanklines;
extern int prefix_blankline_requested;
extern codes_ty prefix_blankline_requested_code; /* The code that caused
the blank line to be
requested */
extern int postfix_blankline_requested;
extern codes_ty postfix_blankline_requested_code; /* The code that caused
* the blank line to be
* requested */
extern int break_comma; /* when true and not in parens, break after a
* comma */
/*
* This structure stores all the user options that come from (e.g.)
* command line flags.
*/
typedef struct user_options_st
{
int verbose; /* when true, non-essential error messages are printed */
int use_tabs; /* does indent convert tabs to spaces or not */
int tabsize; /* The number of columns a tab character generates. */
int use_stdout; /* Where does output go. */
int space_sp_semicolon; /* If true, a space is inserted between if, while, or for, and a semicolon
* for example while (*p++ == ' ') ; */
int swallow_optional_blanklines;
int star_comment_cont; /* true if comment continuation lines should have stars at the beginning of each line. */
int struct_brace_indent; /* Indentation level to be used for a '{' directly following a struct, union or enum */
int space_after_while; /* Put a space after `while' */
int space_after_if; /* Put a space after `if' */
int space_after_for; /* Put a space after `for' */
int procnames_start_line; /* if true, the names of procedures being defined get placed in column 1 (ie. a
* newline is placed between the type of the procedure and its name) */
int parentheses_space; /* If true, parentheses will look like: ( foo ) rather than (foo) */
int preserve_mtime; /* True when the modification time of the files should be preserved. */
int paren_indent; /* set to the indentation per open parens */
int proc_calls_space; /* If true, procedure calls look like: foo (bar) rather than foo(bar) */
int leave_preproc_space; /* if true, leave the spaces between '#' and preprocessor commands. */
int force_preproc_width; /* if this is >0, this becomes the preproc indent-level */
int lineup_to_parens; /* if true, continued code within parens will be lined up to the open paren */
int honour_newlines; /* True when positions at which we read a newline in the input file, should get
* a high priority to break long lines at. */
int format_comments; /* If any comments are to be reformatted */
int format_col1_comments; /* If comments which start in column 1 are to be magically reformatted */
int extra_expression_indent; /* True if continuation lines from the expression part of "if(e)",
* "while(e)", "for(e;e;e)" should be indented an extra tab stop so that
* they don't conflict with the code that follows */
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 */
|
