iiiypuk
/
indent
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

use self

This commit is contained in:
Alexander Popov 2022-09-30 01:01:29 +03:00
parent 58035f08a7
commit 006c3d1501
Signed by: iiiypuk
GPG Key ID: D8C9B59A9F04A70C
10 changed files with 2941 additions and 2816 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1 +1,2 @@
indent
*.BAK

485
args.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: args.c,v 1.18 2014/05/20 01:25:23 guenther Exp $ */
/* $OpenBSD: args.c,v 1.18 2014/05/20 01:25:23 guenther Exp $ */
/*
* Copyright (c) 1980, 1993
@ -46,22 +46,22 @@
#include <err.h>
/* profile types */
#define PRO_SPECIAL 1 /* special case */
#define PRO_BOOL 2 /* boolean */
#define PRO_INT 3 /* integer */
#define PRO_FONT 4 /* troff font */
#define PRO_SPECIAL 1 /* special case */
#define PRO_BOOL 2 /* boolean */
#define PRO_INT 3 /* integer */
#define PRO_FONT 4 /* troff font */
/* profile specials for booleans */
#define ON 1 /* turn it on */
#define OFF 0 /* turn it off */
#define ON 1 /* turn it on */
#define OFF 0 /* turn it off */
/* profile specials for specials */
#define IGN 1 /* ignore it */
#define CLI 2 /* case label indent (float) */
#define STDIN 3 /* use stdin */
#define KEY 4 /* type (keyword) */
#define IGN 1 /* ignore it */
#define CLI 2 /* case label indent (float) */
#define STDIN 3 /* use stdin */
#define KEY 4 /* type (keyword) */
char *option_source = "?";
char *option_source = "?";
/*
* N.B.: because of the way the table here is scanned, options whose names are
@ -70,88 +70,220 @@ char *option_source = "?";
* default value is the one actually assigned.
*/
struct pro {
char *p_name; /* name, eg -bl, -cli */
int p_type; /* type (int, bool, special) */
int p_default; /* the default value (if int) */
int p_special; /* depends on type */
int *p_obj; /* the associated variable */
} pro[] = {
char *p_name; /* name, eg -bl, -cli */
int p_type; /* type (int, bool, special) */
int p_default; /* the default value (if int) */
int p_special; /* depends on type */
int *p_obj; /* the associated variable */
} pro[] = {
{ "T", PRO_SPECIAL, 0, KEY, 0 },
{"bacc", PRO_BOOL, false, ON,
&blanklines_around_conditional_compilation },
{"badp", PRO_BOOL, false, ON,
&blanklines_after_declarations_at_proctop },
{"bad", PRO_BOOL, false, ON, &blanklines_after_declarations },
{"bap", PRO_BOOL, false, ON, &blanklines_after_procs },
{"bbb", PRO_BOOL, false, ON, &blanklines_before_blockcomments },
{"bc", PRO_BOOL, true, OFF, &ps.leave_comma },
{"bl", PRO_BOOL, true, OFF, &btype_2 },
{"br", PRO_BOOL, true, ON, &btype_2 },
{"bs", PRO_BOOL, false, ON, &Bill_Shannon },
{"cdb", PRO_BOOL, true, ON, &comment_delimiter_on_blankline },
{"cd", PRO_INT, 0, 0, &ps.decl_com_ind },
{"ce", PRO_BOOL, true, ON, &cuddle_else },
{"ci", PRO_INT, 0, 0, &continuation_indent },
{"cli", PRO_SPECIAL, 0, CLI, 0 },
{"c", PRO_INT, 33, 0, &ps.com_ind },
{"di", PRO_INT, 16, 0, &ps.decl_indent },
{"dj", PRO_BOOL, false, ON, &ps.ljust_decl },
{"d", PRO_INT, 0, 0, &ps.unindent_displace },
{"eei", PRO_BOOL, false, ON, &extra_expression_indent },
{"ei", PRO_BOOL, true, ON, &ps.else_if },
{"fbc", PRO_FONT, 0, 0, (int *) &blkcomf },
{"fbx", PRO_FONT, 0, 0, (int *) &boxcomf },
{"fb", PRO_FONT, 0, 0, (int *) &bodyf },
{"fc1", PRO_BOOL, true, ON, &format_col1_comments },
{"fc", PRO_FONT, 0, 0, (int *) &scomf },
{"fk", PRO_FONT, 0, 0, (int *) &keywordf },
{"fs", PRO_FONT, 0, 0, (int *) &stringf },
{"ip", PRO_BOOL, true, ON, &ps.indent_parameters },
{"i", PRO_INT, 8, 0, &ps.ind_size },
{"lc", PRO_INT, 0, 0, &block_comment_max_col },
{"lp", PRO_BOOL, true, ON, &lineup_to_parens },
{"l", PRO_INT, 78, 0, &max_col },
{"nbacc", PRO_BOOL, false, OFF,
&blanklines_around_conditional_compilation },
{"nbadp", PRO_BOOL, false, OFF,
&blanklines_after_declarations_at_proctop },
{"nbad", PRO_BOOL, false, OFF, &blanklines_after_declarations },
{"nbap", PRO_BOOL, false, OFF, &blanklines_after_procs },
{"nbbb", PRO_BOOL, false, OFF, &blanklines_before_blockcomments },
{"nbc", PRO_BOOL, true, ON, &ps.leave_comma },
{"nbs", PRO_BOOL, false, OFF, &Bill_Shannon },
{"ncdb", PRO_BOOL, true, OFF, &comment_delimiter_on_blankline },
{"nce", PRO_BOOL, true, OFF, &cuddle_else },
{"ndj", PRO_BOOL, false, OFF, &ps.ljust_decl },
{"neei", PRO_BOOL, false, OFF, &extra_expression_indent },
{"nei", PRO_BOOL, true, OFF, &ps.else_if },
{"nfc1", PRO_BOOL, true, OFF, &format_col1_comments },
{"nip", PRO_BOOL, true, OFF, &ps.indent_parameters },
{"nlp", PRO_BOOL, true, OFF, &lineup_to_parens },
{"npcs", PRO_BOOL, false, OFF, &proc_calls_space },
{"npro", PRO_SPECIAL, 0, IGN, 0 },
{"npsl", PRO_BOOL, true, OFF, &procnames_start_line },
{"nps", PRO_BOOL, false, OFF, &pointer_as_binop },
{"nsc", PRO_BOOL, true, OFF, &star_comment_cont },
{"nsob", PRO_BOOL, false, OFF, &swallow_optional_blanklines },
{"nut", PRO_BOOL, true, OFF, &use_tabs},
{"nv", PRO_BOOL, false, OFF, &verbose },
{"pcs", PRO_BOOL, false, ON, &proc_calls_space },
{"psl", PRO_BOOL, true, ON, &procnames_start_line },
{"ps", PRO_BOOL, false, ON, &pointer_as_binop },
{"sc", PRO_BOOL, true, ON, &star_comment_cont },
{"sob", PRO_BOOL, false, ON, &swallow_optional_blanklines },
{"st", PRO_SPECIAL, 0, STDIN, 0 },
{"troff", PRO_BOOL, false, ON, &troff },
{"ut", PRO_BOOL, true, ON, &use_tabs},
{"v", PRO_BOOL, false, ON, &verbose },
{
"T", PRO_SPECIAL, 0, KEY, 0
},
{
"bacc", PRO_BOOL, false, ON,
&blanklines_around_conditional_compilation
},
{
"badp", PRO_BOOL, false, ON,
&blanklines_after_declarations_at_proctop
},
{
"bad", PRO_BOOL, false, ON, &blanklines_after_declarations
},
{
"bap", PRO_BOOL, false, ON, &blanklines_after_procs
},
{
"bbb", PRO_BOOL, false, ON, &blanklines_before_blockcomments
},
{
"bc", PRO_BOOL, true, OFF, &ps.leave_comma
},
{
"bl", PRO_BOOL, true, OFF, &btype_2
},
{
"br", PRO_BOOL, true, ON, &btype_2
},
{
"bs", PRO_BOOL, false, ON, &Bill_Shannon
},
{
"cdb", PRO_BOOL, true, ON, &comment_delimiter_on_blankline
},
{
"cd", PRO_INT, 0, 0, &ps.decl_com_ind
},
{
"ce", PRO_BOOL, true, ON, &cuddle_else
},
{
"ci", PRO_INT, 0, 0, &continuation_indent
},
{
"cli", PRO_SPECIAL, 0, CLI, 0
},
{
"c", PRO_INT, 33, 0, &ps.com_ind
},
{
"di", PRO_INT, 16, 0, &ps.decl_indent
},
{
"dj", PRO_BOOL, false, ON, &ps.ljust_decl
},
{
"d", PRO_INT, 0, 0, &ps.unindent_displace
},
{
"eei", PRO_BOOL, false, ON, &extra_expression_indent
},
{
"ei", PRO_BOOL, true, ON, &ps.else_if
},
{
"fbc", PRO_FONT, 0, 0, (int *) &blkcomf
},
{
"fbx", PRO_FONT, 0, 0, (int *) &boxcomf
},
{
"fb", PRO_FONT, 0, 0, (int *) &bodyf
},
{
"fc1", PRO_BOOL, true, ON, &format_col1_comments
},
{
"fc", PRO_FONT, 0, 0, (int *) &scomf
},
{
"fk", PRO_FONT, 0, 0, (int *) &keywordf
},
{
"fs", PRO_FONT, 0, 0, (int *) &stringf
},
{
"ip", PRO_BOOL, true, ON, &ps.indent_parameters
},
{
"i", PRO_INT, 8, 0, &ps.ind_size
},
{
"lc", PRO_INT, 0, 0, &block_comment_max_col
},
{
"lp", PRO_BOOL, true, ON, &lineup_to_parens
},
{
"l", PRO_INT, 78, 0, &max_col
},
{
"nbacc", PRO_BOOL, false, OFF,
&blanklines_around_conditional_compilation
},
{
"nbadp", PRO_BOOL, false, OFF,
&blanklines_after_declarations_at_proctop
},
{
"nbad", PRO_BOOL, false, OFF, &blanklines_after_declarations
},
{
"nbap", PRO_BOOL, false, OFF, &blanklines_after_procs
},
{
"nbbb", PRO_BOOL, false, OFF, &blanklines_before_blockcomments
},
{
"nbc", PRO_BOOL, true, ON, &ps.leave_comma
},
{
"nbs", PRO_BOOL, false, OFF, &Bill_Shannon
},
{
"ncdb", PRO_BOOL, true, OFF, &comment_delimiter_on_blankline
},
{
"nce", PRO_BOOL, true, OFF, &cuddle_else
},
{
"ndj", PRO_BOOL, false, OFF, &ps.ljust_decl
},
{
"neei", PRO_BOOL, false, OFF, &extra_expression_indent
},
{
"nei", PRO_BOOL, true, OFF, &ps.else_if
},
{
"nfc1", PRO_BOOL, true, OFF, &format_col1_comments
},
{
"nip", PRO_BOOL, true, OFF, &ps.indent_parameters
},
{
"nlp", PRO_BOOL, true, OFF, &lineup_to_parens
},
{
"npcs", PRO_BOOL, false, OFF, &proc_calls_space
},
{
"npro", PRO_SPECIAL, 0, IGN, 0
},
{
"npsl", PRO_BOOL, true, OFF, &procnames_start_line
},
{
"nps", PRO_BOOL, false, OFF, &pointer_as_binop
},
{
"nsc", PRO_BOOL, true, OFF, &star_comment_cont
},
{
"nsob", PRO_BOOL, false, OFF, &swallow_optional_blanklines
},
{
"nut", PRO_BOOL, true, OFF, &use_tabs
},
{
"nv", PRO_BOOL, false, OFF, &verbose
},
{
"pcs", PRO_BOOL, false, ON, &proc_calls_space
},
{
"psl", PRO_BOOL, true, ON, &procnames_start_line
},
{
"ps", PRO_BOOL, false, ON, &pointer_as_binop
},
{
"sc", PRO_BOOL, true, ON, &star_comment_cont
},
{
"sob", PRO_BOOL, false, ON, &swallow_optional_blanklines
},
{
"st", PRO_SPECIAL, 0, STDIN, 0
},
{
"troff", PRO_BOOL, false, ON, &troff
},
{
"ut", PRO_BOOL, true, ON, &use_tabs
},
{
"v", PRO_BOOL, false, ON, &verbose
},
/* whew! */
{ 0, 0, 0, 0, 0 }
{
0, 0, 0, 0, 0
}
};
void scan_profile(FILE *);
void set_option(char *);
void scan_profile(FILE *);
void set_option(char *);
/*
* set_profile reads $HOME/.indent.pro and ./.indent.pro and handles arguments
@ -160,64 +292,63 @@ void set_option(char *);
void
set_profile(void)
{
FILE *f;
char fname[BUFSIZ];
char *home;
static char prof[] = ".indent.pro";
FILE *f;
char fname[BUFSIZ];
char *home;
static char prof[] = ".indent.pro";
home = getenv("HOME");
if (home != NULL && *home != '\0') {
if (snprintf(fname, sizeof fname, "%s/%s", home, prof) >= sizeof fname) {
#if defined(__linux__)
printf("%s/%s", home, prof); // FIXIT
#else
if (snprintf(fname, sizeof fname, "%s/%s", home, prof) >= sizeof fname) {
#if defined(__linux__)
printf("%s/%s", home, prof);
//FIXIT
#else
warnc(ENAMETOOLONG, "%s/%s", home, prof);
#endif
return;
}
if ((f = fopen(option_source = fname, "r")) != NULL) {
scan_profile(f);
(void) fclose(f);
}
#endif
return;
}
if ((f = fopen(option_source = fname, "r")) != NULL) {
scan_profile(f);
(void) fclose(f);
}
}
if ((f = fopen(option_source = prof, "r")) != NULL) {
scan_profile(f);
(void) fclose(f);
scan_profile(f);
(void) fclose(f);
}
option_source = "Command line";
}
void
scan_profile(FILE *f)
scan_profile(FILE * f)
{
int i;
char *p;
char buf[BUFSIZ];
int i;
char *p;
char buf[BUFSIZ];
while (1) {
for (p = buf;
(i = getc(f)) != EOF && (*p = i) > ' ' && p + 1 - buf < BUFSIZ;
++p)
;
if (p != buf) {
*p = 0;
if (verbose)
printf("profile: %s\n", buf);
set_option(buf);
}
else if (i == EOF)
return;
for (p = buf;
(i = getc(f)) != EOF && (*p = i) > ' ' && p + 1 - buf < BUFSIZ;
++p);
if (p != buf) {
*p = 0;
if (verbose)
printf("profile: %s\n", buf);
set_option(buf);
} else if (i == EOF)
return;
}
}
char *param_start;
char *param_start;
int
eqin(char *s1, char *s2)
{
while (*s1) {
if (*s1++ != *s2++)
return (false);
if (*s1++ != *s2++)
return (false);
}
param_start = s2;
return (true);
@ -229,89 +360,89 @@ eqin(char *s1, char *s2)
void
set_defaults(void)
{
struct pro *p;
struct pro *p;
/*
* Because ps.case_indent is a float, we can't initialize it from the
* table:
*/
ps.case_indent = 0.0; /* -cli0.0 */
ps.case_indent = 0.0; /* -cli0.0 */
for (p = pro; p->p_name; p++)
if (p->p_type != PRO_SPECIAL && p->p_type != PRO_FONT)
*p->p_obj = p->p_default;
if (p->p_type != PRO_SPECIAL && p->p_type != PRO_FONT)
*p->p_obj = p->p_default;
}
void
set_option(char *arg)
{
struct pro *p;
struct pro *p;
arg++; /* ignore leading "-" */
arg++; /* ignore leading "-" */
for (p = pro; p->p_name; p++)
if (*p->p_name == *arg && eqin(p->p_name, arg))
goto found;
if (*p->p_name == *arg && eqin(p->p_name, arg))
goto found;
errx(1, "%s: unknown parameter \"%s\"", option_source, arg - 1);
found:
switch (p->p_type) {
case PRO_SPECIAL:
switch (p->p_special) {
switch (p->p_special) {
case IGN:
break;
case IGN:
break;
case CLI:
if (*param_start == 0)
goto need_param;
ps.case_indent = atof(param_start);
break;
case CLI:
if (*param_start == 0)
goto need_param;
ps.case_indent = atof(param_start);
break;
case STDIN:
if (input == 0)
input = stdin;
if (output == 0)
output = stdout;
break;
case STDIN:
if (input == 0)
input = stdin;
if (output == 0)
output = stdout;
break;
case KEY:
if (*param_start == 0)
goto need_param;
{
char *str;
if ((str = strdup(param_start)) == NULL)
err(1, NULL);
addkey(str, 4);
case KEY:
if (*param_start == 0)
goto need_param;
{
char *str;
if ((str = strdup(param_start)) == NULL)
err(1, NULL);
addkey(str, 4);
}
break;
default:
errx(1, "set_option: internal error: p_special %d", p->p_special);
}
break;
default:
errx(1, "set_option: internal error: p_special %d", p->p_special);
}
break;
case PRO_BOOL:
if (p->p_special == OFF)
*p->p_obj = false;
else
*p->p_obj = true;
break;
if (p->p_special == OFF)
*p->p_obj = false;
else
*p->p_obj = true;
break;
case PRO_INT:
if (!isdigit((unsigned char)*param_start)) {
if (!isdigit((unsigned char) *param_start)) {
need_param:
errx(1, "%s: ``%s'' requires a parameter", option_source, arg - 1);
}
*p->p_obj = atoi(param_start);
if (*p->p_name == 'i' && *p->p_obj <= 0)
errx(1, "%s: ``%s must be greater of zero''",
option_source, arg - 1);
break;
errx(1, "%s: ``%s'' requires a parameter", option_source, arg - 1);
}
*p->p_obj = atoi(param_start);
if (*p->p_name == 'i' && *p->p_obj <= 0)
errx(1, "%s: ``%s must be greater of zero''",
option_source, arg - 1);
break;
case PRO_FONT:
parsefont((struct fstate *) p->p_obj, param_start);
break;
parsefont((struct fstate *) p->p_obj, param_start);
break;
default:
errx(1, "set_option: internal error: p_type %d", p->p_type);
errx(1, "set_option: internal error: p_type %d", p->p_type);
}
}

2192
indent.c
View File

File diff suppressed because it is too large Load Diff

1
indent.txt Normal file
View File

@ -0,0 +1 @@
:indent -nut -i4 -br

2
indent_codes.h
View File

@ -1,4 +1,4 @@
/* $OpenBSD: indent_codes.h,v 1.5 2015/01/19 15:30:52 krw Exp $ */
/* $OpenBSD: indent_codes.h,v 1.5 2015/01/19 15:30:52 krw Exp $ */
/*
* Copyright (c) 1985 Sun Microsystems, Inc.
* Copyright (c) 1980, 1993

470
indent_globs.h
View File

@ -1,4 +1,4 @@
/* $OpenBSD: indent_globs.h,v 1.15 2021/01/26 18:21:25 deraadt Exp $ */
/* $OpenBSD: indent_globs.h,v 1.15 2021/01/26 18:21:25 deraadt Exp $ */
/*
* Copyright (c) 1985 Sun Microsystems, Inc.
* Copyright (c) 1980, 1993
@ -34,22 +34,22 @@
*/
#define BACKSLASH '\\'
#define bufsize 200 /* size of internal buffers */
#define sc_size 5000 /* size of save_com buffer */
#define label_offset 2 /* number of levels a label is placed to left
* of code */
#define bufsize 200 /* size of internal buffers */
#define sc_size 5000 /* size of save_com buffer */
#define label_offset 2 /* number of levels a label is placed to left
* of code */
#define tabsize 8 /* the size of a tab */
#define tabmask 0177770 /* mask used when figuring length of lines
* with tabs */
#define tabsize 8 /* the size of a tab */
#define tabmask 0177770 /* mask used when figuring length of lines
* with tabs */
#define false 0
#define true 1
extern FILE *input; /* the fid for the input file */
extern FILE *output; /* the output file */
extern FILE *input; /* the fid for the input file */
extern FILE *output; /* the output file */
#define CHECK_SIZE_CODE \
if (e_code >= l_code) { \
@ -96,248 +96,258 @@ extern FILE *output; /* the output file */
s_token = tokenbuf + 1; \
}
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 *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 *e_code; /* .. and end of stored code */
extern char *l_code; /* limit of code section */
extern char *codebuf; /* buffer for code section */
extern char *s_code; /* start ... */
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 *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 */
#define token s_token
extern char *tokenbuf; /* the last token scanned */
extern char *s_token;
extern char *e_token;
extern char *l_token;
extern char *tokenbuf; /* the last token scanned */
extern char *s_token;
extern char *e_token;
extern char *l_token;
extern char *in_buffer; /* input buffer */
extern char *in_buffer_limit; /* the end of the input 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 char *in_buffer; /* input buffer */
extern char *in_buffer_limit;/* the end of the input 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 char save_com[sc_size]; /* input text is saved here when looking for
* the brace after an if, while, etc */
extern char *sc_end; /* pointer into save_com buffer */
extern char save_com[sc_size]; /* input text is saved here when
* looking for the brace after an if,
* while, etc */
extern char *sc_end; /* pointer into save_com buffer */
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 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 blanklines_after_declarations;
extern int blanklines_before_blockcomments;
extern int blanklines_after_procs;
extern int blanklines_around_conditional_compilation;
extern int swallow_optional_blanklines;
extern int n_real_blanklines;
extern int prefix_blankline_requested;
extern int postfix_blankline_requested;
extern int break_comma; /* when true and not in parens, break after a
* comma */
extern int btype_2; /* when true, brace should be on same line as
* if, while, etc */
extern float case_ind; /* indentation level to be used for a "case
* n:" */
extern int code_lines; /* count of lines with code */
extern int had_eof; /* set to true when input is exhausted */
extern int line_no; /* the current line number. */
extern int max_col; /* the maximum allowable line length */
extern int verbose; /* when true, non-essential error messages are
* printed */
extern int cuddle_else; /* true if else should cuddle up to '}' */
extern int star_comment_cont; /* true iff comment continuation lines should
* have stars at the beginning of each line. */
extern int comment_delimiter_on_blankline;
extern int troff; /* true iff were generating troff input */
extern 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) */
extern int proc_calls_space; /* If true, procedure calls look like:
* foo(bar) rather than foo (bar) */
extern int format_col1_comments; /* If comments which start in column 1
* are to be magically reformatted
* (just like comments that begin in
* later columns) */
extern int inhibit_formatting; /* true if INDENT OFF is in effect */
extern int suppress_blanklines;/* set iff following blanklines should be
* suppressed */
extern int continuation_indent;/* set to the indentation between the edge of
* code and continuation lines */
extern int lineup_to_parens; /* if true, continued code within parens will
* be lined up to the open paren */
extern int Bill_Shannon; /* true iff a blank should always be inserted
* after sizeof */
extern int blanklines_after_declarations_at_proctop; /* This is vaguely
* similar to
* blanklines_after_decla
* rations 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 */
extern int block_comment_max_col;
extern 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 */
extern int use_tabs; /* set true to use tabs for spacing,
* false uses all spaces */
extern int pointer_as_binop;
extern int blanklines_after_declarations;
extern int blanklines_before_blockcomments;
extern int blanklines_after_procs;
extern int blanklines_around_conditional_compilation;
extern int swallow_optional_blanklines;
extern int n_real_blanklines;
extern int prefix_blankline_requested;
extern int postfix_blankline_requested;
extern int break_comma; /* when true and not in parens, break after a
* comma */
extern int btype_2; /* when true, brace should be on same line as
* if, while, etc */
extern float case_ind; /* indentation level to be used for a "case
* n:" */
extern int code_lines; /* count of lines with code */
extern int had_eof; /* set to true when input is exhausted */
extern int line_no; /* the current line number. */
extern int max_col; /* the maximum allowable line length */
extern int verbose; /* when true, non-essential error messages
* are printed */
extern int cuddle_else; /* true if else should cuddle up to '}' */
extern int star_comment_cont; /* true iff comment continuation
* lines should have stars at the
* beginning of each line. */
extern int comment_delimiter_on_blankline;
extern int troff; /* true iff were generating troff input */
extern 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) */
extern int proc_calls_space; /* If true, procedure calls look
* like: foo(bar) rather than foo
* (bar) */
extern int format_col1_comments; /* If comments which start in column
* 1 are to be magically reformatted
* (just like comments that begin in
* later columns) */
extern int inhibit_formatting; /* true if INDENT OFF is in effect */
extern int suppress_blanklines; /* set iff following blanklines
* should be suppressed */
extern int continuation_indent; /* set to the indentation between the
* edge of code and continuation
* lines */
extern int lineup_to_parens; /* if true, continued code within
* parens will be lined up to the
* open paren */
extern int Bill_Shannon; /* true iff a blank should always be inserted
* after sizeof */
extern int blanklines_after_declarations_at_proctop; /* This is vaguely
* similar to
* blanklines_after_decla
* rations 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 */
extern int block_comment_max_col;
extern 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 */
extern int use_tabs; /* set true to use tabs for spacing, false
* uses all spaces */
/* -troff font state information */
struct fstate {
char font[4];
char size;
int allcaps:1;
char font[4];
char size;
int allcaps:1;
};
extern struct fstate
keywordf, /* keyword font */
stringf, /* string font */
boxcomf, /* Box comment font */
blkcomf, /* Block comment font */
scomf, /* Same line comment font */
bodyf; /* major body font */
keywordf, /* keyword font */
stringf, /* string font */
boxcomf, /* Box comment font */
blkcomf, /* Block comment font */
scomf, /* Same line comment font */
bodyf; /* major body font */
#define STACKSIZE 150
extern struct parser_state {
int last_token;
struct fstate cfont; /* Current font */
int p_stack[STACKSIZE]; /* this is the parsers stack */
int il[STACKSIZE]; /* this stack stores indentation levels */
float cstk[STACKSIZE];/* used to store case stmt indentation levels */
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 rem */
int comment_delta,
n_comment_delta;
int cast_mask; /* indicates which close parens close off
* casts */
int sizeof_mask; /* indicates which close parens close off
* sizeof''s */
int block_init; /* true iff inside a block initialization */
int block_init_level; /* The level of brace nesting in an
* initialization */
int last_nl; /* this is true if the last thing scanned was
* a newline */
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 bl_line; /* set to 1 by dump_line if the line is blank */
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 com_ind; /* the column in which comments to the right
* of code should start */
int com_lines; /* the number of lines with comments, set by
* dump_line */
int dec_nest; /* current nesting level for structure or init */
int decl_com_ind; /* the column in which comments after
* declarations should be put */
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 to which ind_level should be set
* after the current line is printed */
int in_decl; /* set to true when we are in a declaration
* stmt. The processing of braces is then
* slightly different */
int in_stmt; /* set to 1 while in a stmt */
int ind_level; /* the current indentation level */
int ind_size; /* the size of one indentation level */
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 leave_comma; /* if true, never break declarations after
* commas */
int ljust_decl; /* true if declarations should be left
* justified */
int out_coms; /* the number of comments processed, set by
* pr_comment */
int out_lines; /* the number of lines written, set by
* dump_line */
int p_l_follow; /* used to remember how to indent following
* statement */
int paren_level; /* parenthesization level. used to indent
* within stmts */
short paren_indents[20]; /* column positions of each paren */
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 unindent_displace; /* comments not to the right of code
* will be placed this many
* indentation levels to the left of
* code */
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.) */
int else_if; /* True iff else if pairs should be handled
* specially */
int decl_indent; /* column to indent declared identifiers to */
int its_a_keyword;
int sizeof_keyword;
int dumped_decl_indent;
float case_indent; /* The distance to indent case labels from the
* switch statement */
int in_parameter_declaration;
int indent_parameters;
int tos; /* pointer to top of stack */
char procname[100]; /* The name of the current procedure */
int just_saw_decl;
} ps;
int last_token;
struct fstate cfont; /* Current font */
int p_stack[STACKSIZE]; /* this is the parsers stack */
int il[STACKSIZE]; /* this stack stores indentation
* levels */
float cstk[STACKSIZE]; /* used to store case stmt
* indentation levels */
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 rem */
int comment_delta, n_comment_delta;
int cast_mask; /* indicates which close parens close off
* casts */
int sizeof_mask;/* indicates which close parens close off
* sizeof''s */
int block_init; /* true iff inside a block initialization */
int block_init_level; /* The level of brace nesting in an
* initialization */
int last_nl; /* this is true if the last thing scanned was
* a newline */
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 bl_line; /* set to 1 by dump_line if the line is blank */
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 com_ind; /* the column in which comments to the right
* of code should start */
int com_lines; /* the number of lines with comments, set by
* dump_line */
int dec_nest; /* current nesting level for structure or
* init */
int decl_com_ind; /* the column in which comments after
* declarations should be put */
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 to which ind_level should be set
* after the current line is printed */
int in_decl; /* set to true when we are in a declaration
* stmt. The processing of braces is then
* slightly different */
int in_stmt; /* set to 1 while in a stmt */
int ind_level; /* the current indentation level */
int ind_size; /* the size of one indentation level */
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 leave_comma;/* if true, never break declarations after
* commas */
int ljust_decl; /* true if declarations should be left
* justified */
int out_coms; /* the number of comments processed, set by
* pr_comment */
int out_lines; /* the number of lines written, set by
* dump_line */
int p_l_follow; /* used to remember how to indent following
* statement */
int paren_level;/* parenthesization level. used to indent
* within stmts */
short paren_indents[20]; /* column positions of each paren */
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 unindent_displace; /* comments not to the right of code
* will be placed this many
* indentation levels to the left of
* code */
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.) */
int else_if; /* True iff else if pairs should be handled
* specially */
int decl_indent;/* column to indent declared identifiers to */
int its_a_keyword;
int sizeof_keyword;
int dumped_decl_indent;
float case_indent;/* The distance to indent case labels from
* the switch statement */
int in_parameter_declaration;
int indent_parameters;
int tos; /* pointer to top of stack */
char procname[100]; /* The name of the current procedure */
int just_saw_decl;
} ps;
extern int ifdef_level;
extern int rparen_count;
extern int ifdef_level;
extern int rparen_count;
extern struct parser_state state_stack[5];
extern struct parser_state match_state[5];
int compute_code_target(void);
int compute_label_target(void);
int count_spaces(int, char *);
void diag(int, const char *, ...) __attribute__((__format__ (printf, 2, 3)));
void dump_line(void);
int eqin(char *, char *);
void fill_buffer(void);
int pad_output(int, int);
void scan_profile(FILE *);
void set_defaults(void);
void set_option(char *);
void addkey(char *, int);
void set_profile(void);
char *chfont(struct fstate *, struct fstate *, char *);
void parsefont(struct fstate *, char *);
void writefdef(struct fstate *, int);
int lexi(void);
void reduce(void);
void parse(int);
void pr_comment(void);
void bakcopy(void);
int compute_code_target(void);
int compute_label_target(void);
int count_spaces(int, char *);
void diag(int, const char *,...) __attribute__((__format__(printf, 2, 3)));
void dump_line(void);
int eqin(char *, char *);
void fill_buffer(void);
int pad_output(int, int);
void scan_profile(FILE *);
void set_defaults(void);
void set_option(char *);
void addkey(char *, int);
void set_profile(void);
char *chfont(struct fstate *, struct fstate *, char *);
void parsefont(struct fstate *, char *);
void writefdef(struct fstate *, int);
int lexi(void);
void reduce(void);
void parse(int);
void pr_comment(void);
void bakcopy(void);

759
io.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: io.c,v 1.14 2015/09/27 17:00:46 guenther Exp $ */
/* $OpenBSD: io.c,v 1.14 2015/09/27 17:00:46 guenther Exp $ */
/*
* Copyright (c) 1985 Sun Microsystems, Inc.
@ -40,231 +40,228 @@
#include "indent_globs.h"
int comment_open;
static int paren_target;
int comment_open;
static int paren_target;
void
dump_line(void)
{ /* dump_line is the routine that actually
* effects the printing of the new source. It
* prints the label section, followed by the
* code section with the appropriate nesting
* level, followed by any comments */
int cur_col, target_col;
static int not_first_line;
{ /* dump_line is the routine that actually
* effects the printing of the new source. It
* prints the label section, followed by the
* code section with the appropriate nesting
* level, followed by any comments */
int cur_col, target_col;
static int not_first_line;
if (ps.procname[0]) {
if (troff) {
if (comment_open) {
comment_open = 0;
fprintf(output, ".*/\n");
if (troff) {
if (comment_open) {
comment_open = 0;
fprintf(output, ".*/\n");
}
fprintf(output, ".Pr \"%s\"\n", ps.procname);
}
fprintf(output, ".Pr \"%s\"\n", ps.procname);
}
ps.ind_level = 0;
ps.procname[0] = 0;
ps.ind_level = 0;
ps.procname[0] = 0;
}
if (s_code == e_code && s_lab == e_lab && s_com == e_com) {
if (suppress_blanklines > 0)
suppress_blanklines--;
else {
ps.bl_line = true;
n_real_blanklines++;
}
}
else if (!inhibit_formatting) {
suppress_blanklines = 0;
ps.bl_line = false;
if (prefix_blankline_requested && not_first_line) {
if (swallow_optional_blanklines) {
if (n_real_blanklines == 1)
n_real_blanklines = 0;
} else {
if (n_real_blanklines == 0)
n_real_blanklines = 1;
if (suppress_blanklines > 0)
suppress_blanklines--;
else {
ps.bl_line = true;
n_real_blanklines++;
}
}
while (--n_real_blanklines >= 0)
putc('\n', output);
n_real_blanklines = 0;
if (ps.ind_level == 0)
ps.ind_stmt = 0; /* this is a class A kludge. dont do
* additional statement indentation if we are
* at bracket level 0 */
if (e_lab != s_lab || e_code != s_code)
++code_lines; /* keep count of lines with code */
if (e_lab != s_lab) { /* print lab, if any */
if (comment_open) {
comment_open = 0;
fprintf(output, ".*/\n");
}
while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
e_lab--;
cur_col = pad_output(1, compute_label_target());
if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0
|| strncmp(s_lab, "#endif", 6) == 0)) {
char *s = s_lab;
if (e_lab[-1] == '\n')
e_lab--;
do
putc(*s++, output);
while (s < e_lab && 'a' <= *s && *s<='z');
while ((*s == ' ' || *s == '\t') && s < e_lab)
s++;
if (s < e_lab)
fprintf(output, s[0]=='/' && s[1]=='*' ? "\t%.*s" : "\t/* %.*s */",
(int)(e_lab - s), s);
}
else fprintf(output, "%.*s", (int)(e_lab - s_lab), s_lab);
cur_col = count_spaces(cur_col, s_lab);
}
else
cur_col = 1; /* there is no label section */
ps.pcase = false;
if (s_code != e_code) { /* print code section, if any */
char *p;
if (comment_open) {
comment_open = 0;
fprintf(output, ".*/\n");
}
target_col = compute_code_target();
{
int i;
for (i = 0; i < ps.p_l_follow; i++)
if (ps.paren_indents[i] >= 0)
ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
}
cur_col = pad_output(cur_col, target_col);
for (p = s_code; p < e_code; p++)
if (*p == (char) 0200)
fprintf(output, "%d", target_col * 7);
else
putc(*p, output);
cur_col = count_spaces(cur_col, s_code);
}
if (s_com != e_com) {
if (troff) {
int all_here = 0;
char *p;
if (e_com[-1] == '/' && e_com[-2] == '*')
e_com -= 2, all_here++;
while (e_com > s_com && e_com[-1] == ' ')
e_com--;
*e_com = 0;
p = s_com;
while (*p == ' ')
p++;
if (p[0] == '/' && p[1] == '*')
p += 2, all_here++;
else if (p[0] == '*')
p += p[1] == '/' ? 2 : 1;
while (*p == ' ')
p++;
if (*p == 0)
goto inhibit_newline;
if (comment_open < 2 && ps.box_com) {
comment_open = 0;
fprintf(output, ".*/\n");
}
if (comment_open == 0) {
if ('a' <= *p && *p <= 'z')
*p = *p + 'A' - 'a';
if (e_com - p < 50 && all_here == 2) {
char *follow = p;
fprintf(output, "\n.nr C! \\w\1");
while (follow < e_com) {
switch (*follow) {
case '\n':
putc(' ', output);
case 1:
break;
case '\\':
putc('\\', output);
default:
putc(*follow, output);
}
follow++;
} else if (!inhibit_formatting) {
suppress_blanklines = 0;
ps.bl_line = false;
if (prefix_blankline_requested && not_first_line) {
if (swallow_optional_blanklines) {
if (n_real_blanklines == 1)
n_real_blanklines = 0;
} else {
if (n_real_blanklines == 0)
n_real_blanklines = 1;
}
putc(1, output);
}
fprintf(output, "\n./* %dp %d %dp\n",
ps.com_col * 7,
(s_code != e_code || s_lab != e_lab) - ps.box_com,
target_col * 7);
}
comment_open = 1 + ps.box_com;
while (*p) {
if (*p == BACKSLASH)
putc(BACKSLASH, output);
putc(*p++, output);
}
} else { /* print comment, if any */
int target = ps.com_col;
char *com_st = s_com;
target += ps.comment_delta;
while (*com_st == '\t')
com_st++, target += 8; /* ? */
while (target <= 0)
if (*com_st == ' ')
target++, com_st++;
else if (*com_st == '\t')
target = ((target - 1) & ~7) + 9, com_st++;
else
target = 1;
if (cur_col > target) { /* if comment cant fit on this line,
* put it on next line */
while (--n_real_blanklines >= 0)
putc('\n', output);
cur_col = 1;
++ps.out_lines;
n_real_blanklines = 0;
if (ps.ind_level == 0)
ps.ind_stmt = 0; /* this is a class A kludge. dont do
* additional statement indentation if we are
* at bracket level 0 */
if (e_lab != s_lab || e_code != s_code)
++code_lines; /* keep count of lines with code */
if (e_lab != s_lab) { /* print lab, if any */
if (comment_open) {
comment_open = 0;
fprintf(output, ".*/\n");
}
while (e_lab > s_lab && (e_lab[-1] == ' ' || e_lab[-1] == '\t'))
e_lab--;
cur_col = pad_output(1, compute_label_target());
if (s_lab[0] == '#' && (strncmp(s_lab, "#else", 5) == 0
|| strncmp(s_lab, "#endif", 6) == 0)) {
char *s = s_lab;
if (e_lab[-1] == '\n')
e_lab--;
do
putc(*s++, output);
while (s < e_lab && 'a' <= *s && *s <= 'z');
while ((*s == ' ' || *s == '\t') && s < e_lab)
s++;
if (s < e_lab)
fprintf(output, s[0] == '/' && s[1] == '*' ? "\t%.*s" : "\t/* %.*s */",
(int) (e_lab - s), s);
} else
fprintf(output, "%.*s", (int) (e_lab - s_lab), s_lab);
cur_col = count_spaces(cur_col, s_lab);
} else
cur_col = 1; /* there is no label section */
ps.pcase = false;
if (s_code != e_code) { /* print code section, if any */
char *p;
if (comment_open) {
comment_open = 0;
fprintf(output, ".*/\n");
}
target_col = compute_code_target();
{
int i;
for (i = 0; i < ps.p_l_follow; i++)
if (ps.paren_indents[i] >= 0)
ps.paren_indents[i] = -(ps.paren_indents[i] + target_col);
}
cur_col = pad_output(cur_col, target_col);
for (p = s_code; p < e_code; p++)
if (*p == (char) 0200)
fprintf(output, "%d", target_col * 7);
else
putc(*p, output);
cur_col = count_spaces(cur_col, s_code);
}
while (e_com > com_st && isspace((unsigned char)e_com[-1]))
e_com--;
cur_col = pad_output(cur_col, target);
if (!ps.box_com) {
if (star_comment_cont && (com_st[1] != '*' || e_com <= com_st + 1)) {
if (com_st[1] == ' ' && com_st[0] == ' ' && e_com > com_st + 1)
com_st[1] = '*';
else
fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output);
if (s_com != e_com) {
if (troff) {
int all_here = 0;
char *p;
if (e_com[-1] == '/' && e_com[-2] == '*')
e_com -= 2, all_here++;
while (e_com > s_com && e_com[-1] == ' ')
e_com--;
*e_com = 0;
p = s_com;
while (*p == ' ')
p++;
if (p[0] == '/' && p[1] == '*')
p += 2, all_here++;
else if (p[0] == '*')
p += p[1] == '/' ? 2 : 1;
while (*p == ' ')
p++;
if (*p == 0)
goto inhibit_newline;
if (comment_open < 2 && ps.box_com) {
comment_open = 0;
fprintf(output, ".*/\n");
}
if (comment_open == 0) {
if ('a' <= *p && *p <= 'z')
*p = *p + 'A' - 'a';
if (e_com - p < 50 && all_here == 2) {
char *follow = p;
fprintf(output, "\n.nr C! \\w\1");
while (follow < e_com) {
switch (*follow) {
case '\n':
putc(' ', output);
case 1:
break;
case '\\':
putc('\\', output);
default:
putc(*follow, output);
}
follow++;
}
putc(1, output);
}
fprintf(output, "\n./* %dp %d %dp\n",
ps.com_col * 7,
(s_code != e_code || s_lab != e_lab) - ps.box_com,
target_col * 7);
}
comment_open = 1 + ps.box_com;
while (*p) {
if (*p == BACKSLASH)
putc(BACKSLASH, output);
putc(*p++, output);
}
} else { /* print comment, if any */
int target = ps.com_col;
char *com_st = s_com;
target += ps.comment_delta;
while (*com_st == '\t')
com_st++, target += 8; /* ? */
while (target <= 0)
if (*com_st == ' ')
target++, com_st++;
else if (*com_st == '\t')
target = ((target - 1) & ~7) + 9, com_st++;
else
target = 1;
if (cur_col > target) { /* if comment cant fit on this line,
* put it on next line */
putc('\n', output);
cur_col = 1;
++ps.out_lines;
}
while (e_com > com_st && isspace((unsigned char) e_com[-1]))
e_com--;
cur_col = pad_output(cur_col, target);
if (!ps.box_com) {
if (star_comment_cont && (com_st[1] != '*' || e_com <= com_st + 1)) {
if (com_st[1] == ' ' && com_st[0] == ' ' && e_com > com_st + 1)
com_st[1] = '*';
else
fwrite(" * ", com_st[0] == '\t' ? 2 : com_st[0] == '*' ? 1 : 3, 1, output);
}
}
fwrite(com_st, e_com - com_st, 1, output);
ps.comment_delta = ps.n_comment_delta;
cur_col = count_spaces(cur_col, com_st);
++ps.com_lines; /* count lines with comments */
}
}
fwrite(com_st, e_com - com_st, 1, output);
ps.comment_delta = ps.n_comment_delta;
cur_col = count_spaces(cur_col, com_st);
++ps.com_lines; /* count lines with comments */
}
}
if (ps.use_ff)
putc('\014', output);
else
putc('\n', output);
if (ps.use_ff)
putc('\014', output);
else
putc('\n', output);
inhibit_newline:
++ps.out_lines;
if (ps.just_saw_decl == 1 && blanklines_after_declarations) {
prefix_blankline_requested = 1;
ps.just_saw_decl = 0;
++ps.out_lines;
if (ps.just_saw_decl == 1 && blanklines_after_declarations) {
prefix_blankline_requested = 1;
ps.just_saw_decl = 0;
} else
prefix_blankline_requested = postfix_blankline_requested;
postfix_blankline_requested = 0;
}
else
prefix_blankline_requested = postfix_blankline_requested;
postfix_blankline_requested = 0;
}
ps.decl_on_line = ps.in_decl; /* if we are in the middle of a
* declaration, remember that fact for
* proper comment indentation */
ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be
* indented if we have not
* completed this stmt and if
* we are not in the middle of
* a declaration */
ps.decl_on_line = ps.in_decl; /* if we are in the middle of a
* declaration, remember that fact
* for proper comment indentation */
ps.ind_stmt = ps.in_stmt & ~ps.in_decl; /* next line should be
* indented if we have not
* completed this stmt and if
* we are not in the middle
* of a declaration */
ps.use_ff = false;
ps.dumped_decl_indent = 0;
*(e_lab = s_lab) = '\0'; /* reset buffers */
@ -280,27 +277,26 @@ inhibit_newline:
int
compute_code_target(void)
{
int target_col;
int target_col;
target_col = ps.ind_size * ps.ind_level + 1;
if (ps.paren_level)
if (!lineup_to_parens)
target_col += continuation_indent * ps.paren_level;
else {
int w;
int t = paren_target;
if (!lineup_to_parens)
target_col += continuation_indent * ps.paren_level;
else {
int w;
int t = paren_target;
if ((w = count_spaces(t, s_code) - max_col) > 0
&& count_spaces(target_col, s_code) <= max_col) {
t -= w + 1;
if (t > target_col)
target_col = t;
if ((w = count_spaces(t, s_code) - max_col) > 0
&& count_spaces(target_col, s_code) <= max_col) {
t -= w + 1;
if (t > target_col)
target_col = t;
} else
target_col = t;
}
else
target_col = t;
}
else if (ps.ind_stmt)
target_col += continuation_indent;
target_col += continuation_indent;
return target_col;
}
@ -331,89 +327,89 @@ compute_label_target(void)
*/
void
fill_buffer(void)
{ /* this routine reads stuff from the input */
char *p, *buf2;
int i;
FILE *f = input;
{ /* this routine reads stuff from the input */
char *p, *buf2;
int i;
FILE *f = input;
if (bp_save != 0) { /* there is a partly filled input buffer left */
buf_ptr = bp_save; /* dont read anything, just switch buffers */
buf_end = be_save;
bp_save = be_save = 0;
if (buf_ptr < buf_end)
return; /* only return if there is really something in
* this buffer */
if (bp_save != 0) { /* there is a partly filled input buffer left */
buf_ptr = bp_save; /* dont read anything, just switch buffers */
buf_end = be_save;
bp_save = be_save = 0;
if (buf_ptr < buf_end)
return; /* only return if there is really something
* in this buffer */
}
for (p = in_buffer;;) {
if (p >= in_buffer_limit) {
int size = (in_buffer_limit - in_buffer) * 2 + 10;
int offset = p - in_buffer;
buf2 = realloc(in_buffer, size);
if (buf2 == NULL)
errx(1, "input line too long");
in_buffer = buf2;
p = in_buffer + offset;
in_buffer_limit = in_buffer + size - 2;
}
if ((i = getc(f)) == EOF) {
*p++ = ' ';
*p++ = '\n';
had_eof = true;
break;
}
*p++ = i;
if (i == '\n')
break;
if (p >= in_buffer_limit) {
int size = (in_buffer_limit - in_buffer) * 2 + 10;
int offset = p - in_buffer;
buf2 = realloc(in_buffer, size);
if (buf2 == NULL)
errx(1, "input line too long");
in_buffer = buf2;
p = in_buffer + offset;
in_buffer_limit = in_buffer + size - 2;
}
if ((i = getc(f)) == EOF) {
*p++ = ' ';
*p++ = '\n';
had_eof = true;
break;
}
*p++ = i;
if (i == '\n')
break;
}
buf_ptr = in_buffer;
buf_end = p;
if (p - 3 >= in_buffer && p[-2] == '/' && p[-3] == '*') {
if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
fill_buffer(); /* flush indent error message */
else {
int com = 0;
if (in_buffer[3] == 'I' && strncmp(in_buffer, "/**INDENT**", 11) == 0)
fill_buffer(); /* flush indent error message */
else {
int com = 0;
p = in_buffer;
while (*p == ' ' || *p == '\t')
p++;
if (*p == '/' && p[1] == '*') {
p += 2;
while (*p == ' ' || *p == '\t')
p++;
if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
&& p[4] == 'N' && p[5] == 'T') {
p += 6;
p = in_buffer;
while (*p == ' ' || *p == '\t')
p++;
if (*p == '*')
com = 1;
else if (*p == 'O') {
if (*++p == 'N')
p++, com = 1;
else if (*p == 'F' && *++p == 'F')
p++, com = 2;
}
while (*p == ' ' || *p == '\t')
p++;
if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
if (s_com != e_com || s_lab != e_lab || s_code != e_code)
dump_line();
if (!(inhibit_formatting = com - 1)) {
n_real_blanklines = 0;
postfix_blankline_requested = 0;
prefix_blankline_requested = 0;
suppress_blanklines = 1;
}
p++;
if (*p == '/' && p[1] == '*') {
p += 2;
while (*p == ' ' || *p == '\t')
p++;
if (p[0] == 'I' && p[1] == 'N' && p[2] == 'D' && p[3] == 'E'
&& p[4] == 'N' && p[5] == 'T') {
p += 6;
while (*p == ' ' || *p == '\t')
p++;
if (*p == '*')
com = 1;
else if (*p == 'O') {
if (*++p == 'N')
p++, com = 1;
else if (*p == 'F' && *++p == 'F')
p++, com = 2;
}
while (*p == ' ' || *p == '\t')
p++;
if (p[0] == '*' && p[1] == '/' && p[2] == '\n' && com) {
if (s_com != e_com || s_lab != e_lab || s_code != e_code)
dump_line();
if (!(inhibit_formatting = com - 1)) {
n_real_blanklines = 0;
postfix_blankline_requested = 0;
prefix_blankline_requested = 0;
suppress_blanklines = 1;
}
}
}
}
}
}
}
}
if (inhibit_formatting) {
p = in_buffer;
do
putc(*p, output);
while (*p++ != '\n');
p = in_buffer;
do
putc(*p, output);
while (*p++ != '\n');
}
return;
}
@ -449,23 +445,23 @@ fill_buffer(void)
int
pad_output(int current, int target)
{
int curr; /* internal column pointer */
int tcur;
int curr; /* internal column pointer */
int tcur;
if (troff)
fprintf(output, "\\h'|%dp'", (target - 1) * 7);
fprintf(output, "\\h'|%dp'", (target - 1) * 7);
else {
if (current >= target)
return (current); /* line is already long enough */
curr = current;
if (use_tabs) {
while ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target) {
putc('\t', output);
curr = tcur;
if (current >= target)
return (current); /* line is already long enough */
curr = current;
if (use_tabs) {
while ((tcur = ((curr - 1) & tabmask) + tabsize + 1) <= target) {
putc('\t', output);
curr = tcur;
}
}
}
while (curr++ < target)
putc(' ', output); /* pad with final blanks */
while (curr++ < target)
putc(' ', output); /* pad with final blanks */
}
return (target);
}
@ -493,127 +489,124 @@ pad_output(int current, int target)
int
count_spaces(int current, char *buffer)
{
char *buf; /* used to look thru buffer */
int cur; /* current character counter */
char *buf; /* used to look thru buffer */
int cur; /* current character counter */
cur = current;
for (buf = buffer; *buf != '\0'; ++buf) {
switch (*buf) {
switch (*buf) {
case '\n':
case 014: /* form feed */
cur = 1;
break;
case '\n':
case 014: /* form feed */
cur = 1;
break;
case '\t':
cur = ((cur - 1) & tabmask) + tabsize + 1;
break;
case '\t':
cur = ((cur - 1) & tabmask) + tabsize + 1;
break;
case 010: /* backspace */
--cur;
break;
case 010: /* backspace */
--cur;
break;
default:
++cur;
break;
} /* end of switch */
} /* end of for loop */
default:
++cur;
break;
} /* end of switch */
} /* end of for loop */
return (cur);
}
int found_err;
int found_err;
void
diag(int level, const char *msg, ...)
diag(int level, const char *msg,...)
{
va_list ap;
va_list ap;
va_start(ap, msg);
if (level)
found_err = 1;
found_err = 1;
if (output == stdout) {
fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
vfprintf(stdout, msg, ap);
fprintf(stdout, " */\n");
}
else {
fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
vfprintf(stderr, msg, ap);
fprintf(stderr, "\n");
fprintf(stdout, "/**INDENT** %s@%d: ", level == 0 ? "Warning" : "Error", line_no);
vfprintf(stdout, msg, ap);
fprintf(stdout, " */\n");
} else {
fprintf(stderr, "%s@%d: ", level == 0 ? "Warning" : "Error", line_no);
vfprintf(stderr, msg, ap);
fprintf(stderr, "\n");
}
va_end(ap);
}
void
writefdef(struct fstate *f, int nm)
writefdef(struct fstate * f, int nm)
{
fprintf(output, ".ds f%c %s\n.nr s%c %d\n",
nm, f->font, nm, f->size);
nm, f->font, nm, f->size);
}
char *
chfont(struct fstate *of, struct fstate *nf, char *s)
char *
chfont(struct fstate * of, struct fstate * nf, char *s)
{
if (of->font[0] != nf->font[0]
|| of->font[1] != nf->font[1]) {
*s++ = '\\';
*s++ = 'f';
if (nf->font[1]) {
*s++ = '(';
*s++ = nf->font[0];
*s++ = nf->font[1];
}
else
*s++ = nf->font[0];
*s++ = '\\';
*s++ = 'f';
if (nf->font[1]) {
*s++ = '(';
*s++ = nf->font[0];
*s++ = nf->font[1];
} else
*s++ = nf->font[0];
}
if (nf->size != of->size) {
*s++ = '\\';
*s++ = 's';
if (nf->size < of->size) {
*s++ = '-';
*s++ = '0' + of->size - nf->size;
}
else {
*s++ = '+';
*s++ = '0' + nf->size - of->size;
}
*s++ = '\\';
*s++ = 's';
if (nf->size < of->size) {
*s++ = '-';
*s++ = '0' + of->size - nf->size;
} else {
*s++ = '+';
*s++ = '0' + nf->size - of->size;
}
}
return s;
}
void
parsefont(struct fstate *f, char *s0)
parsefont(struct fstate * f, char *s0)
{
char *s = s0;
int sizedelta = 0;
char *s = s0;
int sizedelta = 0;
bzero(f, sizeof *f);
while (*s) {
if (isdigit((unsigned char)*s))
f->size = f->size * 10 + *s - '0';
else if (isupper((unsigned char)*s))
if (f->font[0])
f->font[1] = *s;
if (isdigit((unsigned char) *s))
f->size = f->size * 10 + *s - '0';
else if (isupper((unsigned char) *s))
if (f->font[0])
f->font[1] = *s;
else
f->font[0] = *s;
else if (*s == 'c')
f->allcaps = 1;
else if (*s == '+')
sizedelta++;
else if (*s == '-')
sizedelta--;
else
f->font[0] = *s;
else if (*s == 'c')
f->allcaps = 1;
else if (*s == '+')
sizedelta++;
else if (*s == '-')
sizedelta--;
else
errx(1, "bad font specification: %s", s0);
s++;
errx(1, "bad font specification: %s", s0);
s++;
}
if (f->font[0] == 0)
f->font[0] = 'R';
f->font[0] = 'R';
if (bodyf.size == 0)
bodyf.size = 11;
bodyf.size = 11;
if (f->size == 0)
f->size = bodyf.size + sizedelta;
f->size = bodyf.size + sizedelta;
else if (sizedelta > 0)
f->size += bodyf.size;
f->size += bodyf.size;
else
f->size = bodyf.size - f->size;
f->size = bodyf.size - f->size;
}

837
lexi.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: lexi.c,v 1.20 2016/06/06 06:43:03 tobiasu Exp $ */
/* $OpenBSD: lexi.c,v 1.20 2016/06/06 06:43:03 tobiasu Exp $ */
/*
* Copyright (c) 1980, 1993
@ -50,49 +50,49 @@
#define opchar 3
struct templ {
char *rwd;
int rwcode;
char *rwd;
int rwcode;
};
struct templ specialsinit[] = {
{ "switch", 1 },
{ "case", 2 },
{ "break", 0 },
{ "struct", 3 },
{ "union", 3 },
{ "enum", 3 },
{ "default", 2 },
{ "int", 4 },
{ "char", 4 },
{ "float", 4 },
{ "double", 4 },
{ "long", 4 },
{ "short", 4 },
{ "typedef", 4 },
{ "unsigned", 4 },
{ "register", 4 },
{ "static", 4 },
{ "global", 4 },
{ "extern", 4 },
{ "void", 4 },
{ "goto", 0 },
{ "return", 0 },
{ "if", 5 },
{ "while", 5 },
{ "for", 5 },
{ "else", 6 },
{ "do", 6 },
{ "sizeof", 7 },
struct templ specialsinit[] = {
{"switch", 1},
{"case", 2},
{"break", 0},
{"struct", 3},
{"union", 3},
{"enum", 3},
{"default", 2},
{"int", 4},
{"char", 4},
{"float", 4},
{"double", 4},
{"long", 4},
{"short", 4},
{"typedef", 4},
{"unsigned", 4},
{"register", 4},
{"static", 4},
{"global", 4},
{"extern", 4},
{"void", 4},
{"goto", 0},
{"return", 0},
{"if", 5},
{"while", 5},
{"for", 5},
{"else", 6},
{"do", 6},
{"sizeof", 7},
};
struct templ *specials = specialsinit;
int nspecials = sizeof(specialsinit) / sizeof(specialsinit[0]);
int maxspecials;
struct templ *specials = specialsinit;
int nspecials = sizeof(specialsinit) / sizeof(specialsinit[0]);
int maxspecials;
char chartype[128] =
{ /* this is used to facilitate the decision of
* what type (alphanumeric, operator) each
* character is */
char chartype[128] =
{ /* this is used to facilitate the decision of
* what type (alphanumeric, operator) each
* character is */
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0,
@ -117,448 +117,442 @@ char chartype[128] =
int
lexi(void)
{
int unary_delim; /* this is set to 1 if the current token
* forces a following operator to be unary */
static int last_code; /* the last token type returned */
static int l_struct; /* set to 1 if the last token was 'struct' */
int code; /* internal code to be returned */
char qchar; /* the delimiter character for a string */
int i;
int unary_delim;/* this is set to 1 if the current token
* forces a following operator to be unary */
static int last_code; /* the last token type returned */
static int l_struct; /* set to 1 if the last token was 'struct' */
int code; /* internal code to be returned */
char qchar; /* the delimiter character for a string */
int i;
e_token = s_token; /* point to start of place to save token */
e_token = s_token; /* point to start of place to save token */
unary_delim = false;
ps.col_1 = ps.last_nl; /* tell world that this token started in
* column 1 iff the last thing scanned was nl */
ps.col_1 = ps.last_nl; /* tell world that this token started in
* column 1 iff the last thing scanned was nl */
ps.last_nl = false;
while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
ps.col_1 = false; /* leading blanks imply token is not in column
* 1 */
if (++buf_ptr >= buf_end)
fill_buffer();
while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
ps.col_1 = false; /* leading blanks imply token is not in
* column 1 */
if (++buf_ptr >= buf_end)
fill_buffer();
}
/* Scan an alphanumeric token */
if (chartype[(int)*buf_ptr] == alphanum ||
(buf_ptr[0] == '.' && isdigit((unsigned char)buf_ptr[1]))) {
/*
* we have a character or number
*/
char *j; /* used for searching thru list of
* reserved words */
if (isdigit((unsigned char)*buf_ptr) ||
(buf_ptr[0] == '.' && isdigit((unsigned char)buf_ptr[1]))) {
int seendot = 0,
seenexp = 0,
seensfx = 0;
if (*buf_ptr == '0' &&
(buf_ptr[1] == 'x' || buf_ptr[1] == 'X')) {
*e_token++ = *buf_ptr++;
*e_token++ = *buf_ptr++;
while (isxdigit(*buf_ptr)) {
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
}
}
else
while (1) {
if (*buf_ptr == '.') {
if (seendot)
if (chartype[(int) *buf_ptr] == alphanum ||
(buf_ptr[0] == '.' && isdigit((unsigned char) buf_ptr[1]))) {
/*
* we have a character or number
*/
char *j; /* used for searching thru list of reserved
* words */
if (isdigit((unsigned char) *buf_ptr) ||
(buf_ptr[0] == '.' && isdigit((unsigned char) buf_ptr[1]))) {
int seendot = 0, seenexp = 0, seensfx = 0;
if (*buf_ptr == '0' &&
(buf_ptr[1] == 'x' || buf_ptr[1] == 'X')) {
*e_token++ = *buf_ptr++;
*e_token++ = *buf_ptr++;
while (isxdigit(*buf_ptr)) {
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
}
} else
while (1) {
if (*buf_ptr == '.') {
if (seendot)
break;
else
seendot++;
}
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
if (!isdigit((unsigned char) *buf_ptr) && *buf_ptr != '.') {
if ((*buf_ptr != 'E' && *buf_ptr != 'e') || seenexp)
break;
else {
seenexp++;
seendot++;
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
if (*buf_ptr == '+' || *buf_ptr == '-')
*e_token++ = *buf_ptr++;
}
}
}
while (1) {
if (!(seensfx & 1) &&
(*buf_ptr == 'U' || *buf_ptr == 'u')) {
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
seensfx |= 1;
continue;
}
if (!(seensfx & 2) &&
(*buf_ptr == 'L' || *buf_ptr == 'l')) {
CHECK_SIZE_TOKEN;
if (buf_ptr[1] == buf_ptr[0])
*e_token++ = *buf_ptr++;
*e_token++ = *buf_ptr++;
seensfx |= 2;
continue;
}
break;
else
seendot++;
}
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
if (!isdigit((unsigned char)*buf_ptr) && *buf_ptr != '.') {
if ((*buf_ptr != 'E' && *buf_ptr != 'e') || seenexp)
break;
else {
seenexp++;
seendot++;
if (!(seensfx & 1) &&
(*buf_ptr == 'F' || *buf_ptr == 'f')) {
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
if (*buf_ptr == '+' || *buf_ptr == '-')
*e_token++ = *buf_ptr++;
seensfx |= 1;
}
}
}
while (1) {
if (!(seensfx & 1) &&
(*buf_ptr == 'U' || *buf_ptr == 'u')) {
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
seensfx |= 1;
continue;
}
if (!(seensfx & 2) &&
(*buf_ptr == 'L' || *buf_ptr == 'l')) {
CHECK_SIZE_TOKEN;
if (buf_ptr[1] == buf_ptr[0])
} else
while (chartype[(int) *buf_ptr] == alphanum) { /* copy it over */
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
*e_token++ = *buf_ptr++;
seensfx |= 2;
continue;
if (buf_ptr >= buf_end)
fill_buffer();
}
*e_token++ = '\0';
while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
if (++buf_ptr >= buf_end)
fill_buffer();
}
break;
ps.its_a_keyword = false;
ps.sizeof_keyword = false;
if (l_struct) { /* if last token was 'struct', then this
* token should be treated as a declaration */
l_struct = false;
last_code = ident;
ps.last_u_d = true;
return (decl);
}
if (!(seensfx & 1) &&
(*buf_ptr == 'F' || *buf_ptr == 'f')) {
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
seensfx |= 1;
}
}
else
while (chartype[(int)*buf_ptr] == alphanum) { /* copy it over */
CHECK_SIZE_TOKEN;
*e_token++ = *buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer();
}
*e_token++ = '\0';
while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
if (++buf_ptr >= buf_end)
fill_buffer();
}
ps.its_a_keyword = false;
ps.sizeof_keyword = false;
if (l_struct) { /* if last token was 'struct', then this token
* should be treated as a declaration */
l_struct = false;
last_code = ident;
ps.last_u_d = true;
return (decl);
}
ps.last_u_d = false; /* Operator after identifier is binary */
last_code = ident; /* Remember that this is the code we will
* return */
/*
* This loop will check if the token is a keyword.
*/
for (i = 0; i < nspecials; i++) {
char *p = s_token; /* point at scanned token */
j = specials[i].rwd;
if (*j++ != *p++ || *j++ != *p++)
continue; /* This test depends on the fact that
* identifiers are always at least 1 character
* long (ie. the first two bytes of the
* identifier are always meaningful) */
if (p[-1] == 0)
break; /* If its a one-character identifier */
while (*p++ == *j)
if (*j++ == 0)
goto found_keyword; /* I wish that C had a multi-level
* break... */
}
if (i < nspecials) { /* we have a keyword */
found_keyword:
ps.its_a_keyword = true;
ps.last_u_d = true;
switch (specials[i].rwcode) {
case 1: /* it is a switch */
return (swstmt);
case 2: /* a case or default */
return (casestmt);
case 3: /* a "struct" */
if (ps.p_l_follow)
break; /* inside parens: cast */
l_struct = true;
ps.last_u_d = false; /* Operator after identifier is binary */
last_code = ident; /* Remember that this is the code we will
* return */
/*
* Next time around, we will want to know that we have had a
* 'struct'
* This loop will check if the token is a keyword.
*/
case 4: /* one of the declaration keywords */
if (ps.p_l_follow) {
ps.cast_mask |= 1 << ps.p_l_follow;
break; /* inside parens: cast */
for (i = 0; i < nspecials; i++) {
char *p = s_token; /* point at scanned token */
j = specials[i].rwd;
if (*j++ != *p++ || *j++ != *p++)
continue; /* This test depends on the fact that
* identifiers are always at least 1
* character long (ie. the first two bytes of
* the identifier are always meaningful) */
if (p[-1] == 0)
break; /* If its a one-character identifier */
while (*p++ == *j)
if (*j++ == 0)
goto found_keyword; /* I wish that C had a multi-level
* break... */
}
last_code = decl;
return (decl);
if (i < nspecials) { /* we have a keyword */
found_keyword:
ps.its_a_keyword = true;
ps.last_u_d = true;
switch (specials[i].rwcode) {
case 1: /* it is a switch */
return (swstmt);
case 2: /* a case or default */
return (casestmt);
case 5: /* if, while, for */
return (sp_paren);
case 3: /* a "struct" */
if (ps.p_l_follow)
break; /* inside parens: cast */
l_struct = true;
case 6: /* do, else */
return (sp_nparen);
/*
* Next time around, we will want to know that we have had a
* 'struct'
*/
case 4: /* one of the declaration keywords */
if (ps.p_l_follow) {
ps.cast_mask |= 1 << ps.p_l_follow;
break; /* inside parens: cast */
}
last_code = decl;
return (decl);
case 7:
ps.sizeof_keyword = true;
default: /* all others are treated like any other
* identifier */
return (ident);
} /* end of switch */
} /* end of if (found_it) */
if (*buf_ptr == '(' && ps.tos <= 1 && ps.ind_level == 0) {
char *tp = buf_ptr;
while (tp < buf_end)
if (*tp++ == ')' && (*tp == ';' || *tp == ','))
goto not_proc;
strncpy(ps.procname, token, sizeof ps.procname);
// strlcpy(ps.procname, token, sizeof ps.procname);
ps.in_parameter_declaration = 1;
rparen_count = 1;
case 5: /* if, while, for */
return (sp_paren);
case 6: /* do, else */
return (sp_nparen);
case 7:
ps.sizeof_keyword = true;
default: /* all others are treated like any other
* identifier */
return (ident);
} /* end of switch */
} /* end of if (found_it) */
if (*buf_ptr == '(' && ps.tos <= 1 && ps.ind_level == 0) {
char *tp = buf_ptr;
while (tp < buf_end)
if (*tp++ == ')' && (*tp == ';' || *tp == ','))
goto not_proc;
strncpy(ps.procname, token, sizeof ps.procname);
//strlcpy(ps.procname, token, sizeof ps.procname);
ps.in_parameter_declaration = 1;
rparen_count = 1;
not_proc:;
}
/*
* The following hack attempts to guess whether or not the current
* token is in fact a declaration keyword -- one that has been
* typedefd
*/
if (((*buf_ptr == '*' && buf_ptr[1] != '=') ||
isalpha((unsigned char)*buf_ptr) || *buf_ptr == '_')
&& !ps.p_l_follow
}
/*
* The following hack attempts to guess whether or not the current
* token is in fact a declaration keyword -- one that has been
* typedefd
*/
if (((*buf_ptr == '*' && buf_ptr[1] != '=') ||
isalpha((unsigned char) *buf_ptr) || *buf_ptr == '_')
&& !ps.p_l_follow
&& !ps.block_init
&& (ps.last_token == rparen || ps.last_token == semicolon ||
ps.last_token == decl ||
ps.last_token == lbrace || ps.last_token == rbrace)) {
ps.its_a_keyword = true;
ps.last_u_d = true;
last_code = decl;
return decl;
}
if (last_code == decl) /* if this is a declared variable, then
* following sign is unary */
ps.last_u_d = true; /* will make "int a -1" work */
last_code = ident;
return (ident); /* the ident is not in the list */
} /* end of procesing for alpanum character */
&& (ps.last_token == rparen || ps.last_token == semicolon ||
ps.last_token == decl ||
ps.last_token == lbrace || ps.last_token == rbrace)) {
ps.its_a_keyword = true;
ps.last_u_d = true;
last_code = decl;
return decl;
}
if (last_code == decl) /* if this is a declared variable, then
* following sign is unary */
ps.last_u_d = true; /* will make "int a -1" work */
last_code = ident;
return (ident); /* the ident is not in the list */
} /* end of procesing for alpanum character */
/* Scan a non-alphanumeric token */
*e_token++ = *buf_ptr; /* if it is only a one-character token, it is
* moved here */
* moved here */
*e_token = '\0';
if (++buf_ptr >= buf_end)
fill_buffer();
fill_buffer();
switch (*token) {
case '\n':
unary_delim = ps.last_u_d;
ps.last_nl = true; /* remember that we just had a newline */
code = (had_eof ? 0 : newline);
unary_delim = ps.last_u_d;
ps.last_nl = true; /* remember that we just had a newline */
code = (had_eof ? 0 : newline);
/*
* if data has been exausted, the newline is a dummy, and we should
* return code to stop
*/
break;
/*
* if data has been exausted, the newline is a dummy, and we should
* return code to stop
*/
break;
case '\'': /* start of quoted character */
case '"': /* start of string */
qchar = *token;
if (troff) {
e_token[-1] = '`';
if (qchar == '"')
*e_token++ = '`';
e_token = chfont(&bodyf, &stringf, e_token);
}
do { /* copy the string */
while (1) { /* move one character or [/<char>]<char> */
if (*buf_ptr == '\n') {
printf("%d: Unterminated literal\n", line_no);
goto stop_lit;
case '\'': /* start of quoted character */
case '"': /* start of string */
qchar = *token;
if (troff) {
e_token[-1] = '`';
if (qchar == '"')
*e_token++ = '`';
e_token = chfont(&bodyf, &stringf, e_token);
}
CHECK_SIZE_TOKEN; /* Only have to do this once in this loop,
* since CHECK_SIZE guarantees that there
* are at least 5 entries left */
*e_token = *buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer();
if (*e_token == BACKSLASH) { /* if escape, copy extra char */
if (*buf_ptr == '\n') /* check for escaped newline */
++line_no;
if (troff) {
*++e_token = BACKSLASH;
if (*buf_ptr == BACKSLASH)
*++e_token = BACKSLASH;
}
*++e_token = *buf_ptr++;
++e_token; /* we must increment this again because we
* copied two chars */
if (buf_ptr >= buf_end)
fill_buffer();
do { /* copy the string */
while (1) { /* move one character or [/<char>]<char> */
if (*buf_ptr == '\n') {
printf("%d: Unterminated literal\n", line_no);
goto stop_lit;
}
CHECK_SIZE_TOKEN; /* Only have to do this once in this
* loop, since CHECK_SIZE guarantees
* that there are at least 5 entries
* left */
*e_token = *buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer();
if (*e_token == BACKSLASH) { /* if escape, copy extra char */
if (*buf_ptr == '\n') /* check for escaped newline */
++line_no;
if (troff) {
*++e_token = BACKSLASH;
if (*buf_ptr == BACKSLASH)
*++e_token = BACKSLASH;
}
*++e_token = *buf_ptr++;
++e_token; /* we must increment this again because we
* copied two chars */
if (buf_ptr >= buf_end)
fill_buffer();
} else
break; /* we copied one character */
} /* end of while (1) */
} while (*e_token++ != qchar);
if (troff) {
e_token = chfont(&stringf, &bodyf, e_token - 1);
if (qchar == '"')
*e_token++ = '\'';
}
else
break; /* we copied one character */
} /* end of while (1) */
} while (*e_token++ != qchar);
if (troff) {
e_token = chfont(&stringf, &bodyf, e_token - 1);
if (qchar == '"')
*e_token++ = '\'';
}
stop_lit:
code = ident;
break;
code = ident;
break;
case ('('):
case ('['):
unary_delim = true;
code = lparen;
break;
unary_delim = true;
code = lparen;
break;
case (')'):
case (']'):
code = rparen;
break;
code = rparen;
break;
case '#':
unary_delim = ps.last_u_d;
code = preesc;
break;
unary_delim = ps.last_u_d;
code = preesc;
break;
case '?':
unary_delim = true;
code = question;
break;
unary_delim = true;
code = question;
break;
case (':'):
code = colon;
unary_delim = true;
break;
code = colon;
unary_delim = true;
break;
case (';'):
unary_delim = true;
code = semicolon;
break;
unary_delim = true;
code = semicolon;
break;
case ('{'):
unary_delim = true;
unary_delim = true;
/*
* if (ps.in_or_st) ps.block_init = 1;
*/
/* ? code = ps.block_init ? lparen : lbrace; */
code = lbrace;
break;
/*
* if (ps.in_or_st) ps.block_init = 1;
*/
/* ? code = ps.block_init ? lparen : lbrace; */
code = lbrace;
break;
case ('}'):
unary_delim = true;
/* ? code = ps.block_init ? rparen : rbrace; */
code = rbrace;
break;
unary_delim = true;
/* ? code = ps.block_init ? rparen : rbrace; */
code = rbrace;
break;
case 014: /* a form feed */
unary_delim = ps.last_u_d;
ps.last_nl = true; /* remember this so we can set 'ps.col_1'
* right */
code = form_feed;
break;
case 014: /* a form feed */
unary_delim = ps.last_u_d;
ps.last_nl = true; /* remember this so we can set 'ps.col_1'
* right */
code = form_feed;
break;
case (','):
unary_delim = true;
code = comma;
break;
unary_delim = true;
code = comma;
break;
case '.':
unary_delim = false;
code = period;
break;
unary_delim = false;
code = period;
break;
case '-':
case '+': /* check for -, +, --, ++ */
code = (ps.last_u_d ? unary_op : binary_op);
unary_delim = true;
case '+': /* check for -, +, --, ++ */
code = (ps.last_u_d ? unary_op : binary_op);
unary_delim = true;
if (*buf_ptr == token[0]) {
/* check for doubled character */
*e_token++ = *buf_ptr++;
/* buffer overflow will be checked at end of loop */
if (last_code == ident || last_code == rparen) {
code = (ps.last_u_d ? unary_op : postop);
/* check for following ++ or -- */
unary_delim = false;
if (*buf_ptr == token[0]) {
/* check for doubled character */
*e_token++ = *buf_ptr++;
/* buffer overflow will be checked at end of loop */
if (last_code == ident || last_code == rparen) {
code = (ps.last_u_d ? unary_op : postop);
/* check for following ++ or -- */
unary_delim = false;
}
} else if (*buf_ptr == '=')
/* check for operator += */
*e_token++ = *buf_ptr++;
else if (*buf_ptr == '>') {
/* check for operator -> */
*e_token++ = *buf_ptr++;
if (!pointer_as_binop) {
unary_delim = false;
code = unary_op;
ps.want_blank = false;
}
}
}
else if (*buf_ptr == '=')
/* check for operator += */
*e_token++ = *buf_ptr++;
else if (*buf_ptr == '>') {
/* check for operator -> */
*e_token++ = *buf_ptr++;
if (!pointer_as_binop) {
unary_delim = false;
code = unary_op;
ps.want_blank = false;
}
}
break; /* buffer overflow will be checked at end of
* switch */
break; /* buffer overflow will be checked at end of
* switch */
case '=':
if (ps.in_or_st)
ps.block_init = 1;
if (ps.in_or_st)
ps.block_init = 1;
#ifdef undef
if (chartype[*buf_ptr] == opchar) { /* we have two char assignment */
e_token[-1] = *buf_ptr++;
if ((e_token[-1] == '<' || e_token[-1] == '>') && e_token[-1] == *buf_ptr)
*e_token++ = *buf_ptr++;
*e_token++ = '='; /* Flip =+ to += */
*e_token = 0;
}
if (chartype[*buf_ptr] == opchar) { /* we have two char
* assignment */
e_token[-1] = *buf_ptr++;
if ((e_token[-1] == '<' || e_token[-1] == '>') && e_token[-1] == *buf_ptr)
*e_token++ = *buf_ptr++;
*e_token++ = '='; /* Flip =+ to += */
*e_token = 0;
}
#else
if (*buf_ptr == '=') {/* == */
*e_token++ = '='; /* Flip =+ to += */
buf_ptr++;
*e_token = 0;
}
if (*buf_ptr == '=') { /* == */
*e_token++ = '='; /* Flip =+ to += */
buf_ptr++;
*e_token = 0;
}
#endif
code = binary_op;
unary_delim = true;
break;
/* can drop thru!!! */
code = binary_op;
unary_delim = true;
break;
/* can drop thru!!! */
case '>':
case '<':
case '!': /* ops like <, <<, <=, !=, etc */
if (*buf_ptr == '>' || *buf_ptr == '<' || *buf_ptr == '=') {
*e_token++ = *buf_ptr;
if (++buf_ptr >= buf_end)
fill_buffer();
}
if (*buf_ptr == '=')
*e_token++ = *buf_ptr++;
code = (ps.last_u_d ? unary_op : binary_op);
unary_delim = true;
break;
case '!': /* ops like <, <<, <=, !=, etc */
if (*buf_ptr == '>' || *buf_ptr == '<' || *buf_ptr == '=') {
*e_token++ = *buf_ptr;
if (++buf_ptr >= buf_end)
fill_buffer();
}
if (*buf_ptr == '=')
*e_token++ = *buf_ptr++;
code = (ps.last_u_d ? unary_op : binary_op);
unary_delim = true;
break;
default:
if (token[0] == '/' && *buf_ptr == '*') {
/* it is start of comment */
*e_token++ = '*';
if (token[0] == '/' && *buf_ptr == '*') {
/* it is start of comment */
*e_token++ = '*';
if (++buf_ptr >= buf_end)
fill_buffer();
if (++buf_ptr >= buf_end)
fill_buffer();
code = comment;
unary_delim = ps.last_u_d;
break;
}
while (*(e_token - 1) == *buf_ptr || *buf_ptr == '=') {
/*
* handle ||, &&, etc, and also things as in int *****i
*/
*e_token++ = *buf_ptr;
if (++buf_ptr >= buf_end)
fill_buffer();
}
code = (ps.last_u_d ? unary_op : binary_op);
unary_delim = true;
code = comment;
unary_delim = ps.last_u_d;
break;
}
while (*(e_token - 1) == *buf_ptr || *buf_ptr == '=') {
/*
* handle ||, &&, etc, and also things as in int *****i
*/
*e_token++ = *buf_ptr;
if (++buf_ptr >= buf_end)
fill_buffer();
}
code = (ps.last_u_d ? unary_op : binary_op);
unary_delim = true;
} /* end of switch */
} /* end of switch */
if (code != newline) {
l_struct = false;
last_code = code;
l_struct = false;
last_code = code;
}
if (buf_ptr >= buf_end) /* check for input buffer empty */
fill_buffer();
if (buf_ptr >= buf_end) /* check for input buffer empty */
fill_buffer();
ps.last_u_d = unary_delim;
*e_token = '\0'; /* null terminate the token */
*e_token = '\0'; /* null terminate the token */
return (code);
}
@ -568,36 +562,35 @@ stop_lit:
void
addkey(char *key, int val)
{
struct templ *p;
int i;
struct templ *p;
int i;
for (i = 0; i < nspecials; i++) {
p = &specials[i];
if (p->rwd[0] == key[0] && strcmp(p->rwd, key) == 0)
return;
p = &specials[i];
if (p->rwd[0] == key[0] && strcmp(p->rwd, key) == 0)
return;
}
if (specials == specialsinit) {
/*
* Whoa. Must reallocate special table.
*/
nspecials = sizeof (specialsinit) / sizeof (specialsinit[0]);
maxspecials = nspecials + (nspecials >> 2);
specials = calloc(maxspecials, sizeof specials[0]);
if (specials == NULL)
err(1, NULL);
memcpy(specials, specialsinit, sizeof specialsinit);
/*
* Whoa. Must reallocate special table.
*/
nspecials = sizeof(specialsinit) / sizeof(specialsinit[0]);
maxspecials = nspecials + (nspecials >> 2);
specials = calloc(maxspecials, sizeof specials[0]);
if (specials == NULL)
err(1, NULL);
memcpy(specials, specialsinit, sizeof specialsinit);
} else if (nspecials >= maxspecials) {
int newspecials = maxspecials + (maxspecials >> 2);
struct templ *specials2;
int newspecials = maxspecials + (maxspecials >> 2);
struct templ *specials2;
specials2 = reallocarray(specials, newspecials, sizeof(specials[0]));
if (specials2 == NULL)
err(1, NULL);
specials = specials2;
maxspecials = newspecials;
specials2 = reallocarray(specials, newspecials, sizeof(specials[0]));
if (specials2 == NULL)
err(1, NULL);
specials = specials2;
maxspecials = newspecials;
}
p = &specials[nspecials];
p->rwd = key;
p->rwcode = val;

389
parse.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: parse.c,v 1.9 2009/10/27 23:59:39 deraadt Exp $ */
/* $OpenBSD: parse.c,v 1.9 2009/10/27 23:59:39 deraadt Exp $ */
/*
* Copyright (c) 1980, 1993
@ -36,164 +36,162 @@
#include "indent_globs.h"
#include "indent_codes.h"
void reduce(void);
void reduce(void);
void
parse(int tk) /* the code for the construct scanned */
{
int i;
parse(int tk)
{ /* the code for the construct scanned */
int i;
#ifdef debug
printf("%2d - %s\n", tk, token);
#endif
while (ps.p_stack[ps.tos] == ifhead && tk != elselit) {
/* true if we have an if without an else */
ps.p_stack[ps.tos] = stmt; /* apply the if(..) stmt ::= stmt
* reduction */
reduce(); /* see if this allows any reduction */
/* true if we have an if without an else */
ps.p_stack[ps.tos] = stmt; /* apply the if(..) stmt ::= stmt
* reduction */
reduce(); /* see if this allows any reduction */
}
switch (tk) { /* go on and figure out what to do with the
* input */
switch (tk) { /* go on and figure out what to do with the
* input */
case decl: /* scanned a declaration word */
ps.search_brace = btype_2;
/* indicate that following brace should be on same line */
if (ps.p_stack[ps.tos] != decl) { /* only put one declaration
* onto stack */
break_comma = true; /* while in declaration, newline should be
* forced after comma */
ps.p_stack[++ps.tos] = decl;
ps.il[ps.tos] = ps.i_l_follow;
if (ps.ljust_decl) {/* only do if we want left justified
* declarations */
ps.ind_level = 0;
for (i = ps.tos - 1; i > 0; --i)
if (ps.p_stack[i] == decl)
++ps.ind_level; /* indentation is number of
* declaration levels deep we are */
ps.i_l_follow = ps.ind_level;
}
}
break;
case ifstmt: /* scanned if (...) */
if (ps.p_stack[ps.tos] == elsehead && ps.else_if) /* "else if ..." */
ps.i_l_follow = ps.il[ps.tos];
case dolit: /* 'do' */
case forstmt: /* for (...) */
ps.p_stack[++ps.tos] = tk;
ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
++ps.i_l_follow; /* subsequent statements should be indented 1 */
ps.search_brace = btype_2;
break;
case lbrace: /* scanned { */
break_comma = false; /* don't break comma in an initial list */
if (ps.p_stack[ps.tos] == stmt || ps.p_stack[ps.tos] == decl
|| ps.p_stack[ps.tos] == stmtl)
++ps.i_l_follow; /* it is a random, isolated stmt group or a
* declaration */
else {
if (s_code == e_code) {
/*
* only do this if there is nothing on the line
*/
--ps.ind_level;
/*
* it is a group as part of a while, for, etc.
*/
if (ps.p_stack[ps.tos] == swstmt && ps.case_indent >= 1)
--ps.ind_level;
/*
* for a switch, brace should be two levels out from the code
*/
}
}
ps.p_stack[++ps.tos] = lbrace;
ps.il[ps.tos] = ps.ind_level;
ps.p_stack[++ps.tos] = stmt;
/* allow null stmt between braces */
ps.il[ps.tos] = ps.i_l_follow;
break;
case whilestmt: /* scanned while (...) */
if (ps.p_stack[ps.tos] == dohead) {
/* it is matched with do stmt */
ps.ind_level = ps.i_l_follow = ps.il[ps.tos];
ps.p_stack[++ps.tos] = whilestmt;
ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
}
else { /* it is a while loop */
ps.p_stack[++ps.tos] = whilestmt;
ps.il[ps.tos] = ps.i_l_follow;
++ps.i_l_follow;
case decl: /* scanned a declaration word */
ps.search_brace = btype_2;
}
/* indicate that following brace should be on same line */
if (ps.p_stack[ps.tos] != decl) { /* only put one declaration
* onto stack */
break_comma = true; /* while in declaration, newline should be
* forced after comma */
ps.p_stack[++ps.tos] = decl;
ps.il[ps.tos] = ps.i_l_follow;
break;
if (ps.ljust_decl) {/* only do if we want left justified
* declarations */
ps.ind_level = 0;
for (i = ps.tos - 1; i > 0; --i)
if (ps.p_stack[i] == decl)
++ps.ind_level; /* indentation is number of
* declaration levels deep we are */
ps.i_l_follow = ps.ind_level;
}
}
break;
case elselit: /* scanned an else */
case ifstmt: /* scanned if (...) */
if (ps.p_stack[ps.tos] == elsehead && ps.else_if) /* "else if ..." */
ps.i_l_follow = ps.il[ps.tos];
case dolit: /* 'do' */
case forstmt: /* for (...) */
ps.p_stack[++ps.tos] = tk;
ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
++ps.i_l_follow; /* subsequent statements should be indented 1 */
ps.search_brace = btype_2;
break;
if (ps.p_stack[ps.tos] != ifhead)
diag(1, "Unmatched 'else'");
else {
ps.ind_level = ps.il[ps.tos]; /* indentation for else should
* be same as for if */
ps.i_l_follow = ps.ind_level + 1; /* everything following should
* be in 1 level */
ps.p_stack[ps.tos] = elsehead;
/* remember if with else */
ps.search_brace = btype_2 | ps.else_if;
}
break;
case lbrace: /* scanned { */
break_comma = false; /* don't break comma in an initial list */
if (ps.p_stack[ps.tos] == stmt || ps.p_stack[ps.tos] == decl
|| ps.p_stack[ps.tos] == stmtl)
++ps.i_l_follow; /* it is a random, isolated stmt group or a
* declaration */
else {
if (s_code == e_code) {
/*
* only do this if there is nothing on the line
*/
--ps.ind_level;
/*
* it is a group as part of a while, for, etc.
*/
if (ps.p_stack[ps.tos] == swstmt && ps.case_indent >= 1)
--ps.ind_level;
/*
* for a switch, brace should be two levels out from the code
*/
}
}
case rbrace: /* scanned a } */
/* stack should have <lbrace> <stmt> or <lbrace> <stmtl> */
if (ps.p_stack[ps.tos - 1] == lbrace) {
ps.ind_level = ps.i_l_follow = ps.il[--ps.tos];
ps.p_stack[ps.tos] = stmt;
}
else
diag(1, "Stmt nesting error.");
break;
ps.p_stack[++ps.tos] = lbrace;
ps.il[ps.tos] = ps.ind_level;
ps.p_stack[++ps.tos] = stmt;
/* allow null stmt between braces */
ps.il[ps.tos] = ps.i_l_follow;
break;
case swstmt: /* had switch (...) */
ps.p_stack[++ps.tos] = swstmt;
ps.cstk[ps.tos] = case_ind;
/* save current case indent level */
ps.il[ps.tos] = ps.i_l_follow;
case_ind = ps.i_l_follow + ps.case_indent; /* cases should be one
* level down from
* switch */
ps.i_l_follow += ps.case_indent + 1; /* statements should be two
* levels in */
ps.search_brace = btype_2;
break;
case whilestmt: /* scanned while (...) */
if (ps.p_stack[ps.tos] == dohead) {
/* it is matched with do stmt */
ps.ind_level = ps.i_l_follow = ps.il[ps.tos];
ps.p_stack[++ps.tos] = whilestmt;
ps.il[ps.tos] = ps.ind_level = ps.i_l_follow;
} else { /* it is a while loop */
ps.p_stack[++ps.tos] = whilestmt;
ps.il[ps.tos] = ps.i_l_follow;
++ps.i_l_follow;
ps.search_brace = btype_2;
}
case semicolon: /* this indicates a simple stmt */
break_comma = false; /* turn off flag to break after commas in a
* declaration */
ps.p_stack[++ps.tos] = stmt;
ps.il[ps.tos] = ps.ind_level;
break;
break;
default: /* this is an error */
diag(1, "Unknown code to parser");
return;
case elselit: /* scanned an else */
if (ps.p_stack[ps.tos] != ifhead)
diag(1, "Unmatched 'else'");
else {
ps.ind_level = ps.il[ps.tos]; /* indentation for else
* should be same as for if */
ps.i_l_follow = ps.ind_level + 1; /* everything following
* should be in 1 level */
ps.p_stack[ps.tos] = elsehead;
/* remember if with else */
ps.search_brace = btype_2 | ps.else_if;
}
break;
case rbrace: /* scanned a } */
/* stack should have <lbrace> <stmt> or <lbrace> <stmtl> */
if (ps.p_stack[ps.tos - 1] == lbrace) {
ps.ind_level = ps.i_l_follow = ps.il[--ps.tos];
ps.p_stack[ps.tos] = stmt;
} else
diag(1, "Stmt nesting error.");
break;
case swstmt: /* had switch (...) */
ps.p_stack[++ps.tos] = swstmt;
ps.cstk[ps.tos] = case_ind;
/* save current case indent level */
ps.il[ps.tos] = ps.i_l_follow;
case_ind = ps.i_l_follow + ps.case_indent; /* cases should be one
* level down from
* switch */
ps.i_l_follow += ps.case_indent + 1; /* statements should be two
* levels in */
ps.search_brace = btype_2;
break;
case semicolon: /* this indicates a simple stmt */
break_comma = false; /* turn off flag to break after commas in a
* declaration */
ps.p_stack[++ps.tos] = stmt;
ps.il[ps.tos] = ps.ind_level;
break;
default: /* this is an error */
diag(1, "Unknown code to parser");
return;
} /* end of switch */
} /* end of switch */
reduce(); /* see if any reduction can be done */
reduce(); /* see if any reduction can be done */
#ifdef debug
for (i = 1; i <= ps.tos; ++i)
printf("(%d %d)", ps.p_stack[i], ps.il[i]);
printf("(%d %d)", ps.p_stack[i], ps.il[i]);
printf("\n");
#endif
@ -243,80 +241,79 @@ void
reduce(void)
{
int i;
int i;
for (;;) { /* keep looping until there is nothing left to
* reduce */
for (;;) { /* keep looping until there is nothing left
* to reduce */
switch (ps.p_stack[ps.tos]) {
case stmt:
switch (ps.p_stack[ps.tos - 1]) {
switch (ps.p_stack[ps.tos]) {
case stmt:
case stmtl:
/* stmtl stmt or stmt stmt */
ps.p_stack[--ps.tos] = stmtl;
break;
switch (ps.p_stack[ps.tos - 1]) {
case dolit: /* <do> <stmt> */
ps.p_stack[--ps.tos] = dohead;
ps.i_l_follow = ps.il[ps.tos];
break;
case stmt:
case stmtl:
/* stmtl stmt or stmt stmt */
ps.p_stack[--ps.tos] = stmtl;
break;
case ifstmt:
/* <if> <stmt> */
ps.p_stack[--ps.tos] = ifhead;
for (i = ps.tos - 1;
(
ps.p_stack[i] != stmt
&&
ps.p_stack[i] != stmtl
&&
ps.p_stack[i] != lbrace
);
--i);
ps.i_l_follow = ps.il[i];
/*
* for the time being, we will assume that there is no else on
* this if, and set the indentation level accordingly. If an
* else is scanned, it will be fixed up later
*/
break;
case dolit: /* <do> <stmt> */
ps.p_stack[--ps.tos] = dohead;
ps.i_l_follow = ps.il[ps.tos];
break;
case swstmt:
/* <switch> <stmt> */
case_ind = ps.cstk[ps.tos - 1];
case ifstmt:
/* <if> <stmt> */
ps.p_stack[--ps.tos] = ifhead;
for (i = ps.tos - 1;
(
ps.p_stack[i] != stmt
&&
ps.p_stack[i] != stmtl
&&
ps.p_stack[i] != lbrace
);
--i);
ps.i_l_follow = ps.il[i];
/*
* for the time being, we will assume that there is no else on
* this if, and set the indentation level accordingly. If an
* else is scanned, it will be fixed up later
*/
break;
case decl: /* finish of a declaration */
case elsehead:
/* <<if> <stmt> else> <stmt> */
case forstmt:
/* <for> <stmt> */
case whilestmt:
/* <while> <stmt> */
ps.p_stack[--ps.tos] = stmt;
ps.i_l_follow = ps.il[ps.tos];
break;
case swstmt:
/* <switch> <stmt> */
case_ind = ps.cstk[ps.tos - 1];
default: /* <anything else> <stmt> */
return;
case decl: /* finish of a declaration */
case elsehead:
/* <<if> <stmt> else> <stmt> */
case forstmt:
/* <for> <stmt> */
case whilestmt:
/* <while> <stmt> */
ps.p_stack[--ps.tos] = stmt;
ps.i_l_follow = ps.il[ps.tos];
break;
} /* end of section for <stmt> on top of stack */
break;
default: /* <anything else> <stmt> */
return;
} /* end of section for <stmt> on top of stack */
break;
case whilestmt: /* while (...) on top */
if (ps.p_stack[ps.tos - 1] == dohead) {
/* it is termination of a do while */
ps.p_stack[--ps.tos] = stmt;
break;
} else
return;
default: /* anything else on top */
return;
case whilestmt: /* while (...) on top */
if (ps.p_stack[ps.tos - 1] == dohead) {
/* it is termination of a do while */
ps.p_stack[--ps.tos] = stmt;
break;
}
else
return;
default: /* anything else on top */
return;
}
}
}

621
pr_comment.c
View File

@ -1,4 +1,4 @@
/* $OpenBSD: pr_comment.c,v 1.7 2009/10/27 23:59:39 deraadt Exp $ */
/* $OpenBSD: pr_comment.c,v 1.7 2009/10/27 23:59:39 deraadt Exp $ */
/*
* Copyright (c) 1980, 1993
@ -71,345 +71,340 @@
void
pr_comment(void)
{
int now_col; /* column we are in now */
int adj_max_col; /* Adjusted max_col for when we decide to
* spill comments over the right margin */
char *last_bl; /* points to the last blank in the output
* buffer */
char *t_ptr; /* used for moving string */
int unix_comment; /* tri-state variable used to decide if it is
* a unix-style comment. 0 means only blanks
* since / *, 1 means regular style comment, 2
* means unix style comment */
int break_delim = comment_delimiter_on_blankline;
int l_just_saw_decl = ps.just_saw_decl;
int now_col; /* column we are in now */
int adj_max_col;/* Adjusted max_col for when we decide to
* spill comments over the right margin */
char *last_bl; /* points to the last blank in the output
* buffer */
char *t_ptr; /* used for moving string */
int unix_comment; /* tri-state variable used to decide
* if it is a unix-style comment. 0
* means only blanks since / *, 1
* means regular style comment, 2
* means unix style comment */
int break_delim = comment_delimiter_on_blankline;
int l_just_saw_decl = ps.just_saw_decl;
/*
* int ps.last_nl = 0; true iff the last significant thing
* we've seen is a newline
*/
int one_liner = 1; /* true iff this comment is a one-liner */
int one_liner = 1; /* true iff this comment is a
* one-liner */
adj_max_col = max_col;
ps.just_saw_decl = 0;
last_bl = 0; /* no blanks found so far */
ps.box_com = false; /* at first, assume that we are not in
* a boxed comment or some other
* comment that should not be touched */
++ps.out_coms; /* keep track of number of comments */
unix_comment = 1; /* set flag to let us figure out if there is a
* unix-style comment ** DISABLED: use 0 to
* reenable this hack! */
last_bl = 0; /* no blanks found so far */
ps.box_com = false; /* at first, assume that we are not in a
* boxed comment or some other comment that
* should not be touched */
++ps.out_coms; /* keep track of number of comments */
unix_comment = 1; /* set flag to let us figure out if there is
* a unix-style comment ** DISABLED: use 0 to
* reenable this hack! */
/* Figure where to align and how to treat the comment */
if (ps.col_1 && !format_col1_comments) { /* if comment starts in column
* 1 it should not be touched */
ps.box_com = true;
ps.com_col = 1;
}
else {
if (*buf_ptr == '-' || *buf_ptr == '*' || *buf_ptr == '\n') {
ps.box_com = true; /* a comment with a '-', '*' or newline
* immediately after the / * is assumed to be
* a boxed comment */
break_delim = 0;
}
if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
/* klg: check only if this line is blank */
/*
* If this (*and previous lines are*) blank, don't put comment way
* out at left
*/
ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
adj_max_col = block_comment_max_col;
if (ps.com_col <= 1)
ps.com_col = 1 + !format_col1_comments;
}
else {
int target_col;
break_delim = 0;
if (s_code != e_code)
target_col = count_spaces(compute_code_target(), s_code);
else {
target_col = 1;
if (s_lab != e_lab)
target_col = count_spaces(compute_label_target(), s_lab);
if (ps.col_1 && !format_col1_comments) { /* if comment starts in
* column 1 it should not be
* touched */
ps.box_com = true;
ps.com_col = 1;
} else {
if (*buf_ptr == '-' || *buf_ptr == '*' || *buf_ptr == '\n') {
ps.box_com = true; /* a comment with a '-', '*' or newline
* immediately after the / * is assumed to be
* a boxed comment */
break_delim = 0;
}
if ( /* ps.bl_line && */ (s_lab == e_lab) && (s_code == e_code)) {
/* klg: check only if this line is blank */
/*
* If this (*and previous lines are*) blank, don't put comment way
* out at left
*/
ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
adj_max_col = block_comment_max_col;
if (ps.com_col <= 1)
ps.com_col = 1 + !format_col1_comments;
} else {
int target_col;
break_delim = 0;
if (s_code != e_code)
target_col = count_spaces(compute_code_target(), s_code);
else {
target_col = 1;
if (s_lab != e_lab)
target_col = count_spaces(compute_label_target(), s_lab);
}
ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind;
if (ps.com_col < target_col)
ps.com_col = ((target_col + 7) & ~7) + 1;
if (ps.com_col + 24 > adj_max_col)
adj_max_col = ps.com_col + 24;
}
ps.com_col = ps.decl_on_line || ps.ind_level == 0 ? ps.decl_com_ind : ps.com_ind;
if (ps.com_col < target_col)
ps.com_col = ((target_col + 7) & ~7) + 1;
if (ps.com_col + 24 > adj_max_col)
adj_max_col = ps.com_col + 24;
}
}
if (ps.box_com) {
buf_ptr[-2] = 0;
ps.n_comment_delta = 1 - count_spaces(1, in_buffer);
buf_ptr[-2] = '/';
}
else {
ps.n_comment_delta = 0;
while (*buf_ptr == ' ' || *buf_ptr == '\t')
buf_ptr++;
buf_ptr[-2] = 0;
ps.n_comment_delta = 1 - count_spaces(1, in_buffer);
buf_ptr[-2] = '/';
} else {
ps.n_comment_delta = 0;
while (*buf_ptr == ' ' || *buf_ptr == '\t')
buf_ptr++;
}
ps.comment_delta = 0;
*e_com++ = '/'; /* put '/ *' into buffer */
*e_com++ = '/'; /* put '/ *' into buffer */
*e_com++ = '*';
if (*buf_ptr != ' ' && !ps.box_com)
*e_com++ = ' ';
*e_com++ = ' ';
*e_com = '\0';
if (troff) {
now_col = 1;
adj_max_col = 80;
}
else
now_col = count_spaces(ps.com_col, s_com); /* figure what column we
* would be in if we
* printed the comment
* now */
now_col = 1;
adj_max_col = 80;
} else
now_col = count_spaces(ps.com_col, s_com); /* figure what column we
* would be in if we
* printed the comment
* now */
/* Start to copy the comment */
while (1) { /* this loop will go until the comment is
* copied */
if (*buf_ptr > 040 && *buf_ptr != '*')
ps.last_nl = 0;
CHECK_SIZE_COM;
switch (*buf_ptr) { /* this checks for various spcl cases */
case 014: /* check for a form feed */
if (!ps.box_com) { /* in a text comment, break the line here */
ps.use_ff = true;
/* fix so dump_line uses a form feed */
dump_line();
last_bl = 0;
*e_com++ = ' ';
*e_com++ = '*';
*e_com++ = ' ';
while (*++buf_ptr == ' ' || *buf_ptr == '\t');
}
else {
if (++buf_ptr >= buf_end)
fill_buffer();
*e_com++ = 014;
}
break;
while (1) { /* this loop will go until the comment is
* copied */
if (*buf_ptr > 040 && *buf_ptr != '*')
ps.last_nl = 0;
CHECK_SIZE_COM;
switch (*buf_ptr) { /* this checks for various spcl cases */
case 014: /* check for a form feed */
if (!ps.box_com) { /* in a text comment, break the line here */
ps.use_ff = true;
/* fix so dump_line uses a form feed */
dump_line();
last_bl = 0;
*e_com++ = ' ';
*e_com++ = '*';
*e_com++ = ' ';
while (*++buf_ptr == ' ' || *buf_ptr == '\t');
} else {
if (++buf_ptr >= buf_end)
fill_buffer();
*e_com++ = 014;
}
break;
case '\n':
if (had_eof) { /* check for unexpected eof */
printf("Unterminated comment\n");
*e_com = '\0';
dump_line();
return;
}
one_liner = 0;
if (ps.box_com || ps.last_nl) { /* if this is a boxed comment,
* we don't ignore the newline
case '\n':
if (had_eof) { /* check for unexpected eof */
printf("Unterminated comment\n");
*e_com = '\0';
dump_line();
return;
}
one_liner = 0;
if (ps.box_com || ps.last_nl) { /* if this is a boxed
* comment, we don't ignore
* the newline */
if (s_com == e_com) {
*e_com++ = ' ';
*e_com++ = ' ';
}
*e_com = '\0';
if (!ps.box_com && e_com - s_com > 3) {
if (break_delim == 1 && s_com[0] == '/'
&& s_com[1] == '*' && s_com[2] == ' ') {
char *t = e_com;
break_delim = 2;
e_com = s_com + 2;
*e_com = 0;
if (blanklines_before_blockcomments)
prefix_blankline_requested = 1;
dump_line();
e_com = t;
s_com[0] = s_com[1] = s_com[2] = ' ';
}
dump_line();
CHECK_SIZE_COM;
*e_com++ = ' ';
*e_com++ = ' ';
}
dump_line();
now_col = ps.com_col;
} else {
ps.last_nl = 1;
if (unix_comment != 1) { /* we not are in unix_style
* comment */
if (unix_comment == 0 && s_code == e_code) {
/*
* if it is a UNIX-style comment, ignore the
* requirement that previous line be blank for
* unindention
*/
if (s_com == e_com) {
*e_com++ = ' ';
*e_com++ = ' ';
}
*e_com = '\0';
if (!ps.box_com && e_com - s_com > 3) {
if (break_delim == 1 && s_com[0] == '/'
&& s_com[1] == '*' && s_com[2] == ' ') {
char *t = e_com;
break_delim = 2;
e_com = s_com + 2;
*e_com = 0;
if (blanklines_before_blockcomments)
prefix_blankline_requested = 1;
dump_line();
e_com = t;
s_com[0] = s_com[1] = s_com[2] = ' ';
ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
if (ps.com_col <= 1)
ps.com_col = 2;
}
unix_comment = 2; /* permanently remember that we are
* in this type of comment */
dump_line();
++line_no;
now_col = ps.com_col;
*e_com++ = ' ';
/*
* fix so that the star at the start of the line will line
* up
*/
do /* flush leading white space */
if (++buf_ptr >= buf_end)
fill_buffer();
while (*buf_ptr == ' ' || *buf_ptr == '\t');
break;
}
if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
last_bl = e_com - 1;
/*
* if there was a space at the end of the last line, remember
* where it was
*/
else { /* otherwise, insert one */
last_bl = e_com;
CHECK_SIZE_COM;
*e_com++ = ' ';
++now_col;
}
}
dump_line();
CHECK_SIZE_COM;
*e_com++ = ' ';
*e_com++ = ' ';
}
dump_line();
now_col = ps.com_col;
}
else {
ps.last_nl = 1;
if (unix_comment != 1) { /* we not are in unix_style
* comment */
if (unix_comment == 0 && s_code == e_code) {
/*
* if it is a UNIX-style comment, ignore the
* requirement that previous line be blank for
* unindention
*/
ps.com_col = (ps.ind_level - ps.unindent_displace) * ps.ind_size + 1;
if (ps.com_col <= 1)
ps.com_col = 2;
}
unix_comment = 2; /* permanently remember that we are in
* this type of comment */
dump_line();
++line_no;
now_col = ps.com_col;
*e_com++ = ' ';
/*
* fix so that the star at the start of the line will line
* up
*/
do /* flush leading white space */
if (++buf_ptr >= buf_end)
++line_no; /* keep track of input line number */
if (!ps.box_com) {
int nstar = 1;
do { /* flush any blanks and/or tabs at start of
* next line */
if (++buf_ptr >= buf_end)
fill_buffer();
if (*buf_ptr == '*' && --nstar >= 0) {
if (++buf_ptr >= buf_end)
fill_buffer();
if (*buf_ptr == '/')
goto end_of_comment;
}
} while (*buf_ptr == ' ' || *buf_ptr == '\t');
} else if (++buf_ptr >= buf_end)
fill_buffer();
while (*buf_ptr == ' ' || *buf_ptr == '\t');
break; /* end of case for newline */
case '*': /* must check for possibility of being at end
* of comment */
if (++buf_ptr >= buf_end) /* get to next char after * */
fill_buffer();
if (unix_comment == 0) /* set flag to show we are not in
* unix-style comment */
unix_comment = 1;
if (*buf_ptr == '/') { /* it is the end!!! */
end_of_comment:
if (++buf_ptr >= buf_end)
fill_buffer();
if (*(e_com - 1) != ' ' && !ps.box_com) { /* insure blank before
* end */
*e_com++ = ' ';
++now_col;
}
if (break_delim == 1 && !one_liner && s_com[0] == '/'
&& s_com[1] == '*' && s_com[2] == ' ') {
char *t = e_com;
break_delim = 2;
e_com = s_com + 2;
*e_com = 0;
if (blanklines_before_blockcomments)
prefix_blankline_requested = 1;
dump_line();
e_com = t;
s_com[0] = s_com[1] = s_com[2] = ' ';
}
if (break_delim == 2 && e_com > s_com + 3
/* now_col > adj_max_col - 2 && !ps.box_com */ ) {
*e_com = '\0';
dump_line();
now_col = ps.com_col;
}
CHECK_SIZE_COM;
*e_com++ = '*';
*e_com++ = '/';
*e_com = '\0';
ps.just_saw_decl = l_just_saw_decl;
return;
} else { /* handle isolated '*' */
*e_com++ = '*';
++now_col;
}
break;
default: /* we have a random char */
if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t')
unix_comment = 1; /* we are not in unix-style comment */
*e_com = *buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer();
if (*e_com == '\t') /* keep track of column */
now_col = ((now_col - 1) & tabmask) + tabsize + 1;
else if (*e_com == '\b') /* this is a backspace */
--now_col;
else
++now_col;
if (*e_com == ' ' || *e_com == '\t')
last_bl = e_com;
/* remember we saw a blank */
++e_com;
if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') {
/*
* the comment is too long, it must be broken up
*/
if (break_delim == 1 && s_com[0] == '/'
&& s_com[1] == '*' && s_com[2] == ' ') {
char *t = e_com;
break_delim = 2;
e_com = s_com + 2;
*e_com = 0;
if (blanklines_before_blockcomments)
prefix_blankline_requested = 1;
dump_line();
e_com = t;
s_com[0] = s_com[1] = s_com[2] = ' ';
}
if (last_bl == 0) { /* we have seen no blanks */
last_bl = e_com; /* fake it */
*e_com++ = ' ';
}
*e_com = '\0'; /* print what we have */
*last_bl = '\0';
while (last_bl > s_com && last_bl[-1] < 040)
*--last_bl = 0;
e_com = last_bl;
dump_line();
*e_com++ = ' '; /* add blanks for continuation */
*e_com++ = ' ';
*e_com++ = ' ';
t_ptr = last_bl + 1;
last_bl = 0;
if (t_ptr >= e_com) {
while (*t_ptr == ' ' || *t_ptr == '\t')
t_ptr++;
while (*t_ptr != '\0') { /* move unprinted part of
* comment down in buffer */
if (*t_ptr == ' ' || *t_ptr == '\t')
last_bl = e_com;
*e_com++ = *t_ptr++;
}
}
*e_com = '\0';
now_col = count_spaces(ps.com_col, s_com); /* recompute current
* position */
}
break;
}
if (*(e_com - 1) == ' ' || *(e_com - 1) == '\t')
last_bl = e_com - 1;
/*
* if there was a space at the end of the last line, remember
* where it was
*/
else { /* otherwise, insert one */
last_bl = e_com;
CHECK_SIZE_COM;
*e_com++ = ' ';
++now_col;
}
}
++line_no; /* keep track of input line number */
if (!ps.box_com) {
int nstar = 1;
do { /* flush any blanks and/or tabs at start of
* next line */
if (++buf_ptr >= buf_end)
fill_buffer();
if (*buf_ptr == '*' && --nstar >= 0) {
if (++buf_ptr >= buf_end)
fill_buffer();
if (*buf_ptr == '/')
goto end_of_comment;
}
} while (*buf_ptr == ' ' || *buf_ptr == '\t');
}
else if (++buf_ptr >= buf_end)
fill_buffer();
break; /* end of case for newline */
case '*': /* must check for possibility of being at end
* of comment */
if (++buf_ptr >= buf_end) /* get to next char after * */
fill_buffer();
if (unix_comment == 0) /* set flag to show we are not in
* unix-style comment */
unix_comment = 1;
if (*buf_ptr == '/') { /* it is the end!!! */
end_of_comment:
if (++buf_ptr >= buf_end)
fill_buffer();
if (*(e_com - 1) != ' ' && !ps.box_com) { /* insure blank before
* end */
*e_com++ = ' ';
++now_col;
}
if (break_delim == 1 && !one_liner && s_com[0] == '/'
&& s_com[1] == '*' && s_com[2] == ' ') {
char *t = e_com;
break_delim = 2;
e_com = s_com + 2;
*e_com = 0;
if (blanklines_before_blockcomments)
prefix_blankline_requested = 1;
dump_line();
e_com = t;
s_com[0] = s_com[1] = s_com[2] = ' ';
}
if (break_delim == 2 && e_com > s_com + 3
/* now_col > adj_max_col - 2 && !ps.box_com */ ) {
*e_com = '\0';
dump_line();
now_col = ps.com_col;
}
CHECK_SIZE_COM;
*e_com++ = '*';
*e_com++ = '/';
*e_com = '\0';
ps.just_saw_decl = l_just_saw_decl;
return;
}
else { /* handle isolated '*' */
*e_com++ = '*';
++now_col;
}
break;
default: /* we have a random char */
if (unix_comment == 0 && *buf_ptr != ' ' && *buf_ptr != '\t')
unix_comment = 1; /* we are not in unix-style comment */
*e_com = *buf_ptr++;
if (buf_ptr >= buf_end)
fill_buffer();
if (*e_com == '\t') /* keep track of column */
now_col = ((now_col - 1) & tabmask) + tabsize + 1;
else if (*e_com == '\b') /* this is a backspace */
--now_col;
else
++now_col;
if (*e_com == ' ' || *e_com == '\t')
last_bl = e_com;
/* remember we saw a blank */
++e_com;
if (now_col > adj_max_col && !ps.box_com && unix_comment == 1 && e_com[-1] > ' ') {
/*
* the comment is too long, it must be broken up
*/
if (break_delim == 1 && s_com[0] == '/'
&& s_com[1] == '*' && s_com[2] == ' ') {
char *t = e_com;
break_delim = 2;
e_com = s_com + 2;
*e_com = 0;
if (blanklines_before_blockcomments)
prefix_blankline_requested = 1;
dump_line();
e_com = t;
s_com[0] = s_com[1] = s_com[2] = ' ';
}
if (last_bl == 0) { /* we have seen no blanks */
last_bl = e_com; /* fake it */
*e_com++ = ' ';
}
*e_com = '\0'; /* print what we have */
*last_bl = '\0';
while (last_bl > s_com && last_bl[-1] < 040)
*--last_bl = 0;
e_com = last_bl;
dump_line();
*e_com++ = ' '; /* add blanks for continuation */
*e_com++ = ' ';
*e_com++ = ' ';
t_ptr = last_bl + 1;
last_bl = 0;
if (t_ptr >= e_com) {
while (*t_ptr == ' ' || *t_ptr == '\t')
t_ptr++;
while (*t_ptr != '\0') { /* move unprinted part of
* comment down in buffer */
if (*t_ptr == ' ' || *t_ptr == '\t')
last_bl = e_com;
*e_com++ = *t_ptr++;
}
}
*e_com = '\0';
now_col = count_spaces(ps.com_col, s_com); /* recompute current
* position */
}
break;
}
}
}