Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-24 03:33:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

* src/output.c (output): Topological sort of the functions, in

Browse Source 
order to get rid of the `static' prototypes.
No longer use `register'.
* src/output.h: New file.
Propagate its inclusion in files explicitly prototyping functions
from output.c.
This commit is contained in:
Akim Demaille
2000-10-02 07:50:14 +00:00
parent d5796688b1
commit 6c89f1c138
6 changed files with 440 additions and 435 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
ChangeLog
View File

@@ -1,3 +1,12 @@
2000-10-02 Akim Demaille <akim@epita.fr>
* src/output.c (output): Topological sort of the functions, in
order to get rid of the `static' prototypes.
No longer use `register'.
* src/output.h: New file.
Propagate its inclusion in files explicitly prototyping functions
from output.c.
2000-09-21 Akim Demaille <akim@epita.fr> 2000-09-21 Akim Demaille <akim@epita.fr>
* src/atgeneral.m4: Update from Autoconf. * src/atgeneral.m4: Update from Autoconf.

2
src/Makefile.am
View File

@@ -21,7 +21,7 @@ EXTRA_bison_SOURCES = vmsgetargs.c
noinst_HEADERS = alloc.h closure.h complain.h \ noinst_HEADERS = alloc.h closure.h complain.h \
derives.h \ derives.h \
files.h getargs.h gram.h lex.h \ files.h getargs.h gram.h lex.h \
state.h \ output.h state.h \
symtab.h system.h types.h symtab.h system.h types.h
data_DATA = bison.simple bison.hairy data_DATA = bison.simple bison.hairy

3
src/main.c
View File

@@ -25,6 +25,7 @@
#include "files.h" #include "files.h"
#include "complain.h" #include "complain.h"
#include "derives.h" #include "derives.h"
#include "output.h"
#if 0 /* XXX currently unused. */ #if 0 /* XXX currently unused. */
/* Nonzero means failure has been detected; don't write a parser file. */ /* Nonzero means failure has been detected; don't write a parser file. */
@@ -35,7 +36,6 @@ static int failure;
char *program_name; char *program_name;
extern char *printable_version PARAMS ((int)); extern char *printable_version PARAMS ((int));
extern void berror PARAMS ((const char *));
extern void openfiles PARAMS ((void)); extern void openfiles PARAMS ((void));
extern void reader PARAMS ((void)); extern void reader PARAMS ((void));
@@ -48,7 +48,6 @@ extern void initialize_conflicts PARAMS ((void));
extern void finalize_conflicts PARAMS ((void)); extern void finalize_conflicts PARAMS ((void));
extern void verbose PARAMS ((void)); extern void verbose PARAMS ((void));
extern void terse PARAMS ((void)); extern void terse PARAMS ((void));
extern void output PARAMS ((void));
/* VMS complained about using `int'. */ /* VMS complained about using `int'. */

726
src/output.c
View File

@@ -19,29 +19,17 @@
02111-1307, USA. */ 02111-1307, USA. */
/* functions to output parsing data to various files. Entries are: /* The parser tables consist of these tables.
output_headers ()
Output constant strings to the beginning of certain files.
output_trailers()
Output constant strings to the ends of certain files.
output ()
Output the parsing tables and the parser code to ftable.
The parser tables consist of these tables.
Starred ones needed only for the semantic parser. Starred ones needed only for the semantic parser.
Double starred are output only if switches are set. Double starred are output only if switches are set.
yytranslate = vector mapping yylex's token numbers into bison's token numbers. yytranslate = vector mapping yylex's token numbers into bison's token
numbers.
** yytname = vector of string-names indexed by bison token number ** yytname = vector of string-names indexed by bison token number
** yytoknum = vector of yylex token numbers corresponding to entries in yytname ** yytoknum = vector of yylex token numbers corresponding to entries
in yytname
yyrline = vector of line-numbers of all rules. For yydebug printouts. yyrline = vector of line-numbers of all rules. For yydebug printouts.
@@ -100,7 +88,6 @@ yycheck = a vector indexed in parallel with yytable.
YYFINAL = the state number of the termination state. YYFINAL = the state number of the termination state.
YYFLAG = most negative short int. Used to flag ?? YYFLAG = most negative short int. Used to flag ??
YYNTBASE = ntokens. YYNTBASE = ntokens.
*/ */
#include "system.h" #include "system.h"
@@ -110,7 +97,7 @@ YYNTBASE = ntokens.
#include "gram.h" #include "gram.h"
#include "state.h" #include "state.h"
#include "complain.h" #include "complain.h"
#include "output.h"
extern char **tags; extern char **tags;
extern int *user_toknums; extern int *user_toknums;
@@ -129,36 +116,6 @@ extern short *goto_map;
extern short *from_state; extern short *from_state;
extern short *to_state; extern short *to_state;
extern void output_headers PARAMS ((void));
extern void output_trailers PARAMS ((void));
extern void output PARAMS ((void));
static void output_token_translations PARAMS ((void));
static void output_gram PARAMS ((void));
static void output_stos PARAMS ((void));
static void output_rule_data PARAMS ((void));
static void output_defines PARAMS ((void));
static void output_actions PARAMS ((void));
static void token_actions PARAMS ((void));
static void save_row PARAMS ((int));
static void goto_actions PARAMS ((void));
static void save_column PARAMS ((int, int));
static void sort_actions PARAMS ((void));
static void pack_table PARAMS ((void));
static void output_base PARAMS ((void));
static void output_table PARAMS ((void));
static void output_check PARAMS ((void));
static void output_parser PARAMS ((void));
static void output_program PARAMS ((void));
static void free_shifts PARAMS ((void));
static void free_reductions PARAMS ((void));
static void free_itemsets PARAMS ((void));
static int action_row PARAMS ((int));
static int default_goto PARAMS ((int));
static int matching_state PARAMS ((int));
static int pack_vector PARAMS ((int));
extern void berror PARAMS ((const char *));
extern void reader_output_yylsp PARAMS ((FILE *)); extern void reader_output_yylsp PARAMS ((FILE *));
static int nvectors; static int nvectors;
@@ -215,6 +172,10 @@ register YYLTYPE *yylsp;\n\
#define ACTSTR_SIMPLE "\n switch (yyn) {\n" #define ACTSTR_SIMPLE "\n switch (yyn) {\n"
/*------------------------------------------------------------.
| Output constant strings to the beginning of certain files. |
`------------------------------------------------------------*/
void void
output_headers (void) output_headers (void)
{ {
@@ -244,6 +205,10 @@ output_headers (void)
} }
/*-------------------------------------------------------.
| Output constant strings to the ends of certain files. |
`-------------------------------------------------------*/
void void
output_trailers (void) output_trailers (void)
{ {
@@ -261,65 +226,12 @@ output_trailers (void)
} }
void
output (void)
{
int c;
/* output_token_defines(ftable); / * JF put out token defines FIRST */
if (!semantic_parser) /* JF Put out other stuff */
{
rewind (fattrs);
while ((c = getc (fattrs)) != EOF)
putc (c, ftable);
}
reader_output_yylsp (ftable);
if (debugflag)
fputs ("\
#ifndef YYDEBUG\n\
#define YYDEBUG 1\n\
#endif\n\
\n",
ftable);
if (semantic_parser)
fprintf (ftable, "#include \"%s\"\n", attrsfile);
if (!noparserflag)
fprintf (ftable, "#include <stdio.h>\n\n");
/* Make "const" do nothing if not in ANSI C. */
fputs ("\
#ifndef __cplusplus\n\
# ifndef __STDC__\n\
# define const\n\
# endif\n\
#endif\n\
\n",
ftable);
free_itemsets ();
output_defines ();
output_token_translations ();
/* if (semantic_parser) */
/* This is now unconditional because debugging printouts can use it. */
output_gram ();
FREE (ritem);
if (semantic_parser)
output_stos ();
output_rule_data ();
output_actions ();
if (!noparserflag)
output_parser ();
output_program ();
}
static void static void
output_token_translations (void) output_token_translations (void)
{ {
register int i, j; int i, j;
/* register short *sp; JF unused */ /* short *sp; JF unused */
if (translations) if (translations)
{ {
@@ -362,9 +274,9 @@ output_token_translations (void)
static void static void
output_gram (void) output_gram (void)
{ {
register int i; int i;
register int j; int j;
register short *sp; short *sp;
/* With the ordinary parser, /* With the ordinary parser,
yyprhs and yyrhs are needed only for yydebug. */ yyprhs and yyrhs are needed only for yydebug. */
@@ -427,8 +339,8 @@ output_gram (void)
static void static void
output_stos (void) output_stos (void)
{ {
register int i; int i;
register int j; int j;
fprintf (ftable, "\nstatic const short yystos[] = { 0"); fprintf (ftable, "\nstatic const short yystos[] = { 0");
@@ -457,8 +369,8 @@ output_stos (void)
static void static void
output_rule_data (void) output_rule_data (void)
{ {
register int i; int i;
register int j; int j;
fputs ("\n\ fputs ("\n\
#if YYDEBUG != 0\n\ #if YYDEBUG != 0\n\
@@ -506,7 +418,7 @@ static const short yyrline[] = { 0", ftable);
/* this used to be i<=nsyms, but that output a final "" symbol /* this used to be i<=nsyms, but that output a final "" symbol
almost by accident */ almost by accident */
{ {
register char *p; char *p;
putc (',', ftable); putc (',', ftable);
j++; j++;
@@ -649,118 +561,40 @@ output_defines (void)
} }
/*------------------------------------------------------------------.
/* compute and output yydefact, yydefgoto, yypact, yypgoto, yytable and yycheck. */ | Decide what to do for each type of token if seen as the lookahead |
| token in specified state. The value returned is used as the |
static void | default action (yydefact) for the state. In addition, actrow is |
output_actions (void) | filled with what to do for each kind of token, index by symbol |
{ | number, with zero meaning do the default action. The value |
nvectors = nstates + nvars; | MINSHORT, a very negative number, means this situation is an |
| error. The parser recognizes this value specially. |
froms = NEW2 (nvectors, short *); | |
tos = NEW2 (nvectors, short *); | This is where conflicts are resolved. The loop over lookahead |
tally = NEW2 (nvectors, short); | rules considered lower-numbered rules last, and the last rule |
width = NEW2 (nvectors, short); | considered that likes a token gets to handle it. |
`------------------------------------------------------------------*/
token_actions ();
free_shifts ();
free_reductions ();
FREE (lookaheads);
FREE (LA);
FREE (LAruleno);
FREE (accessing_symbol);
goto_actions ();
FREE (goto_map + ntokens);
FREE (from_state);
FREE (to_state);
sort_actions ();
pack_table ();
output_base ();
output_table ();
output_check ();
}
/* Figure out the actions for the specified state, indexed by
lookahead token type.
The yydefact table is output now. The detailed info is saved for
putting into yytable later. */
static void
token_actions (void)
{
register int i;
register int j;
register int k;
actrow = NEW2 (ntokens, short);
k = action_row (0);
fprintf (ftable, "\nstatic const short yydefact[] = {%6d", k);
save_row (0);
j = 10;
for (i = 1; i < nstates; i++)
{
putc (',', ftable);
if (j >= 10)
{
putc ('\n', ftable);
j = 1;
}
else
{
j++;
}
k = action_row (i);
fprintf (ftable, "%6d", k);
save_row (i);
}
fprintf (ftable, "\n};\n");
FREE (actrow);
}
/* Decide what to do for each type of token if seen as the lookahead
token in specified state. The value returned is used as the
default action (yydefact) for the state. In addition, actrow is
filled with what to do for each kind of token, index by symbol
number, with zero meaning do the default action. The value
MINSHORT, a very negative number, means this situation is an error.
The parser recognizes this value specially.
This is where conflicts are resolved. The loop over lookahead
rules considered lower-numbered rules last, and the last rule
considered that likes a token gets to handle it. */
static int static int
action_row (int state) action_row (int state)
{ {
register int i; int i;
register int j; int j;
register int k; int k;
register int m = 0; int m = 0;
register int n = 0; int n = 0;
register int count; int count;
register int default_rule; int default_rule;
register int nreds; int nreds;
register int max; int max;
register int rule; int rule;
register int shift_state; int shift_state;
register int symbol; int symbol;
register unsigned mask; unsigned mask;
register unsigned *wordp; unsigned *wordp;
register reductions *redp; reductions *redp;
register shifts *shiftp; shifts *shiftp;
register errs *errp; errs *errp;
int nodefault = 0; /* set nonzero to inhibit having any default reduction */ int nodefault = 0; /* set nonzero to inhibit having any default reduction */
for (i = 0; i < ntokens; i++) for (i = 0; i < ntokens; i++)
@@ -914,11 +748,11 @@ action_row (int state)
static void static void
save_row (int state) save_row (int state)
{ {
register int i; int i;
register int count; int count;
register short *sp; short *sp;
register short *sp1; short *sp1;
register short *sp2; short *sp2;
count = 0; count = 0;
for (i = 0; i < ntokens; i++) for (i = 0; i < ntokens; i++)
@@ -947,29 +781,29 @@ save_row (int state)
} }
/*------------------------------------------------------------------.
/* figure out what to do after reducing with each rule, | Figure out the actions for the specified state, indexed by |
depending on the saved state from before the beginning | lookahead token type. |
of parsing the data that matched this rule. | |
| The yydefact table is output now. The detailed info is saved for |
The yydefgoto table is output now. The detailed info | putting into yytable later. |
is saved for putting into yytable later. */ `------------------------------------------------------------------*/
static void static void
goto_actions (void) token_actions (void)
{ {
register int i; int i;
register int j; int j;
register int k; int k;
state_count = NEW2 (nstates, short); actrow = NEW2 (ntokens, short);
k = default_goto (ntokens); k = action_row (0);
fprintf (ftable, "\nstatic const short yydefgoto[] = {%6d", k); fprintf (ftable, "\nstatic const short yydefact[] = {%6d", k);
save_column (ntokens, k); save_row (0);
j = 10; j = 10;
for (i = ntokens + 1; i < nsyms; i++) for (i = 1; i < nstates; i++)
{ {
putc (',', ftable); putc (',', ftable);
@@ -983,65 +817,58 @@ goto_actions (void)
j++; j++;
} }
k = default_goto (i); k = action_row (i);
fprintf (ftable, "%6d", k); fprintf (ftable, "%6d", k);
save_column (i, k); save_row (i);
} }
fprintf (ftable, "\n};\n"); fprintf (ftable, "\n};\n");
FREE (state_count); FREE (actrow);
} }
static void
static int free_shifts (void)
default_goto (int symbol)
{ {
register int i; shifts *sp, *sptmp; /* JF derefrenced freed ptr */
register int m;
register int n;
register int default_state;
register int max;
m = goto_map[symbol]; FREE (shift_table);
n = goto_map[symbol + 1];
if (m == n) for (sp = first_shift; sp; sp = sptmp)
return -1;
for (i = 0; i < nstates; i++)
state_count[i] = 0;
for (i = m; i < n; i++)
state_count[to_state[i]]++;
max = 0;
default_state = -1;
for (i = 0; i < nstates; i++)
{ {
if (state_count[i] > max) sptmp = sp->next;
{ FREE (sp);
max = state_count[i];
default_state = i;
} }
} }
return default_state;
static void
free_reductions (void)
{
reductions *rp, *rptmp; /* JF fixed freed ptr */
FREE (reduction_table);
for (rp = first_reduction; rp; rp = rptmp)
{
rptmp = rp->next;
FREE (rp);
} }
}
static void static void
save_column (int symbol, int default_state) save_column (int symbol, int default_state)
{ {
register int i; int i;
register int m; int m;
register int n; int n;
register short *sp; short *sp;
register short *sp1; short *sp1;
register short *sp2; short *sp2;
register int count; int count;
register int symno; int symno;
m = goto_map[symbol]; m = goto_map[symbol];
n = goto_map[symbol + 1]; n = goto_map[symbol + 1];
@@ -1074,6 +901,86 @@ save_column (int symbol, int default_state)
width[symno] = sp1[-1] - sp[0] + 1; width[symno] = sp1[-1] - sp[0] + 1;
} }
static int
default_goto (int symbol)
{
int i;
int m;
int n;
int default_state;
int max;
m = goto_map[symbol];
n = goto_map[symbol + 1];
if (m == n)
return -1;
for (i = 0; i < nstates; i++)
state_count[i] = 0;
for (i = m; i < n; i++)
state_count[to_state[i]]++;
max = 0;
default_state = -1;
for (i = 0; i < nstates; i++)
{
if (state_count[i] > max)
{
max = state_count[i];
default_state = i;
}
}
return default_state;
}
/*-------------------------------------------------------------------.
| Figure out what to do after reducing with each rule, depending on |
| the saved state from before the beginning of parsing the data that |
| matched this rule. |
| |
| The YYDEFGOTO table is output now. The detailed info is saved for |
| putting into YYTABLE later. |
`-------------------------------------------------------------------*/
static void
goto_actions (void)
{
int i, j, k;
state_count = NEW2 (nstates, short);
k = default_goto (ntokens);
fprintf (ftable, "\nstatic const short yydefgoto[] = {%6d", k);
save_column (ntokens, k);
j = 10;
for (i = ntokens + 1; i < nsyms; i++)
{
putc (',', ftable);
if (j >= 10)
{
putc ('\n', ftable);
j = 1;
}
else
{
j++;
}
k = default_goto (i);
fprintf (ftable, "%6d", k);
save_column (i, k);
}
fprintf (ftable, "\n};\n");
FREE (state_count);
}
/* The next few functions decide how to pack the actions and gotos /* The next few functions decide how to pack the actions and gotos
@@ -1082,11 +989,11 @@ save_column (int symbol, int default_state)
static void static void
sort_actions (void) sort_actions (void)
{ {
register int i; int i;
register int j; int j;
register int k; int k;
register int t; int t;
register int w; int w;
order = NEW2 (nvectors, short); order = NEW2 (nvectors, short);
nentries = 0; nentries = 0;
@@ -1115,65 +1022,16 @@ sort_actions (void)
} }
static void
pack_table (void)
{
register int i;
register int place;
register int state;
base = NEW2 (nvectors, short);
pos = NEW2 (nentries, short);
table = NEW2 (MAXTABLE, short);
check = NEW2 (MAXTABLE, short);
lowzero = 0;
high = 0;
for (i = 0; i < nvectors; i++)
base[i] = MINSHORT;
for (i = 0; i < MAXTABLE; i++)
check[i] = -1;
for (i = 0; i < nentries; i++)
{
state = matching_state (i);
if (state < 0)
place = pack_vector (i);
else
place = base[state];
pos[i] = place;
base[order[i]] = place;
}
for (i = 0; i < nvectors; i++)
{
if (froms[i])
FREE (froms[i]);
if (tos[i])
FREE (tos[i]);
}
FREE (froms);
FREE (tos);
FREE (pos);
}
static int static int
matching_state (int vector) matching_state (int vector)
{ {
register int i; int i;
register int j; int j;
register int k; int k;
register int t; int t;
register int w; int w;
register int match; int match;
register int prev; int prev;
i = order[vector]; i = order[vector];
if (i >= nstates) if (i >= nstates)
@@ -1203,18 +1061,17 @@ matching_state (int vector)
} }
static int static int
pack_vector (int vector) pack_vector (int vector)
{ {
register int i; int i;
register int j; int j;
register int k; int k;
register int t; int t;
register int loc = 0; int loc = 0;
register int ok; int ok;
register short *from; short *from;
register short *to; short *to;
i = order[vector]; i = order[vector];
t = tally[i]; t = tally[i];
@@ -1269,6 +1126,52 @@ pack_vector (int vector)
} }
static void
pack_table (void)
{
int i;
int place;
int state;
base = NEW2 (nvectors, short);
pos = NEW2 (nentries, short);
table = NEW2 (MAXTABLE, short);
check = NEW2 (MAXTABLE, short);
lowzero = 0;
high = 0;
for (i = 0; i < nvectors; i++)
base[i] = MINSHORT;
for (i = 0; i < MAXTABLE; i++)
check[i] = -1;
for (i = 0; i < nentries; i++)
{
state = matching_state (i);
if (state < 0)
place = pack_vector (i);
else
place = base[state];
pos[i] = place;
base[order[i]] = place;
}
for (i = 0; i < nvectors; i++)
{
if (froms[i])
FREE (froms[i]);
if (tos[i])
FREE (tos[i]);
}
FREE (froms);
FREE (tos);
FREE (pos);
}
/* the following functions output yytable, yycheck /* the following functions output yytable, yycheck
and the vectors whose elements index the portion starts */ and the vectors whose elements index the portion starts */
@@ -1276,8 +1179,8 @@ pack_vector (int vector)
static void static void
output_base (void) output_base (void)
{ {
register int i; int i;
register int j; int j;
fprintf (ftable, "\nstatic const short yypact[] = {%6d", base[0]); fprintf (ftable, "\nstatic const short yypact[] = {%6d", base[0]);
@@ -1328,8 +1231,8 @@ output_base (void)
static void static void
output_table (void) output_table (void)
{ {
register int i; int i;
register int j; int j;
fprintf (ftable, "\n\n#define\tYYLAST\t\t%d\n\n", high); fprintf (ftable, "\n\n#define\tYYLAST\t\t%d\n\n", high);
fprintf (ftable, "\nstatic const short yytable[] = {%6d", table[0]); fprintf (ftable, "\nstatic const short yytable[] = {%6d", table[0]);
@@ -1360,8 +1263,8 @@ output_table (void)
static void static void
output_check (void) output_check (void)
{ {
register int i; int i;
register int j; int j;
fprintf (ftable, "\nstatic const short yycheck[] = {%6d", check[0]); fprintf (ftable, "\nstatic const short yycheck[] = {%6d", check[0]);
@@ -1387,14 +1290,45 @@ output_check (void)
FREE (check); FREE (check);
} }
/* compute and output yydefact, yydefgoto, yypact, yypgoto, yytable
and yycheck. */
static void
output_actions (void)
{
nvectors = nstates + nvars;
froms = NEW2 (nvectors, short *);
tos = NEW2 (nvectors, short *);
tally = NEW2 (nvectors, short);
width = NEW2 (nvectors, short);
token_actions ();
free_shifts ();
free_reductions ();
FREE (lookaheads);
FREE (LA);
FREE (LAruleno);
FREE (accessing_symbol);
goto_actions ();
FREE (goto_map + ntokens);
FREE (from_state);
FREE (to_state);
sort_actions ();
pack_table ();
output_base ();
output_table ();
output_check ();
}
/* copy the parser code into the ftable file at the end. */ /* copy the parser code into the ftable file at the end. */
static void static void
output_parser (void) output_parser (void)
{ {
register int c; int c;
#ifdef DONTDEF #ifdef DONTDEF
FILE *fpars; FILE *fpars;
#else #else
@@ -1474,7 +1408,7 @@ output_parser (void)
static void static void
output_program (void) output_program (void)
{ {
register int c; int c;
if (!nolinesflag) if (!nolinesflag)
fprintf (ftable, "#line %d \"%s\"\n", lineno, infile); fprintf (ftable, "#line %d \"%s\"\n", lineno, infile);
@@ -1491,7 +1425,7 @@ output_program (void)
static void static void
free_itemsets (void) free_itemsets (void)
{ {
register core *cp, *cptmp; core *cp, *cptmp;
FREE (state_table); FREE (state_table);
@@ -1503,31 +1437,59 @@ free_itemsets (void)
} }
static void /*----------------------------------------------------------.
free_shifts (void) | Output the parsing tables and the parser code to ftable. |
`----------------------------------------------------------*/
void
output (void)
{ {
register shifts *sp, *sptmp; /* JF derefrenced freed ptr */ int c;
FREE (shift_table); /* output_token_defines(ftable); / * JF put out token defines FIRST */
if (!semantic_parser) /* JF Put out other stuff */
for (sp = first_shift; sp; sp = sptmp)
{ {
sptmp = sp->next; rewind (fattrs);
FREE (sp); while ((c = getc (fattrs)) != EOF)
} putc (c, ftable);
}
static void
free_reductions (void)
{
register reductions *rp, *rptmp; /* JF fixed freed ptr */
FREE (reduction_table);
for (rp = first_reduction; rp; rp = rptmp)
{
rptmp = rp->next;
FREE (rp);
} }
reader_output_yylsp (ftable);
if (debugflag)
fputs ("\
#ifndef YYDEBUG\n\
#define YYDEBUG 1\n\
#endif\n\
\n",
ftable);
if (semantic_parser)
fprintf (ftable, "#include \"%s\"\n", attrsfile);
if (!noparserflag)
fprintf (ftable, "#include <stdio.h>\n\n");
/* Make "const" do nothing if not in ANSI C. */
fputs ("\
#ifndef __cplusplus\n\
# ifndef __STDC__\n\
# define const\n\
# endif\n\
#endif\n\
\n",
ftable);
free_itemsets ();
output_defines ();
output_token_translations ();
/* if (semantic_parser) */
/* This is now unconditional because debugging printouts can use it. */
output_gram ();
FREE (ritem);
if (semantic_parser)
output_stos ();
output_rule_data ();
output_actions ();
if (!noparserflag)
output_parser ();
output_program ();
} }

33
src/output.h Normal file
View File

@@ -0,0 +1,33 @@
/* Output the generated parsing program for bison,
Copyright (C) 2000 Free Software Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
Bison is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
Bison is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with Bison; see the file COPYING. If not, write to the Free
Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA. */
#ifndef OUTPUT_H_
# define OUTPUT_H_
/* Output constant strings to the beginning of certain files. */
void output_headers PARAMS ((void));
/* Output constant strings to the ends of certain files. */
void output_trailers PARAMS ((void));
/* Output the parsing tables and the parser code to FTABLE. */
void output PARAMS ((void));
#endif /* !OUTPUT_H_ */

10
src/reader.c
View File

@@ -35,6 +35,7 @@
#include "lex.h" #include "lex.h"
#include "gram.h" #include "gram.h"
#include "complain.h" #include "complain.h"
#include "output.h"
#define LTYPESTR "\ #define LTYPESTR "\
\n\ \n\
@@ -70,8 +71,6 @@ extern int maxtoken;
extern void init_lex PARAMS((void)); extern void init_lex PARAMS((void));
extern char *grow_token_buffer PARAMS((char *)); extern char *grow_token_buffer PARAMS((char *));
extern void tabinit PARAMS((void)); extern void tabinit PARAMS((void));
extern void output_headers PARAMS((void));
extern void output_trailers PARAMS((void));
extern void free_symtab PARAMS((void)); extern void free_symtab PARAMS((void));
extern void open_extra_files PARAMS((void)); extern void open_extra_files PARAMS((void));
extern char *printable_version PARAMS((int)); extern char *printable_version PARAMS((int));
@@ -234,8 +233,11 @@ copy_string (FILE *fin, FILE *fout, int match)
} }
/* Dump the comment from IN to OUT1 and OUT2. C is either `*' or `/', /*---------------------------------------------------------------.
depending upon the type of comments used. OUT2 might be NULL. */ | Dump the comment from IN to OUT1 and OUT2. C is either `*' or |
| `/', depending upon the type of comments used. OUT2 might be |
| NULL. |
`---------------------------------------------------------------*/
static inline void static inline void
copy_comment2 (FILE *in, FILE *out1, FILE* out2, int c) copy_comment2 (FILE *in, FILE *out1, FILE* out2, int c)