Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-28 21:53: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>
* 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 \
derives.h \
files.h getargs.h gram.h lex.h \
state.h \
output.h state.h \
symtab.h system.h types.h
data_DATA = bison.simple bison.hairy

3
src/main.c
View File

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

726
src/output.c
View File

@@ -19,29 +19,17 @@
02111-1307, USA. */
/* functions to output parsing data to various files. Entries are:
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.
/* The parser tables consist of these tables.
Starred ones needed only for the semantic parser.
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
** 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.
@@ -100,7 +88,6 @@ yycheck = a vector indexed in parallel with yytable.
YYFINAL = the state number of the termination state.
YYFLAG = most negative short int. Used to flag ??
YYNTBASE = ntokens.
*/
#include "system.h"
@@ -110,7 +97,7 @@ YYNTBASE = ntokens.
#include "gram.h"
#include "state.h"
#include "complain.h"
#include "output.h"
extern char **tags;
extern int *user_toknums;
@@ -129,36 +116,6 @@ extern short *goto_map;
extern short *from_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 *));
static int nvectors;
@@ -215,6 +172,10 @@ register YYLTYPE *yylsp;\n\
#define ACTSTR_SIMPLE "\n switch (yyn) {\n"
/*------------------------------------------------------------.
| Output constant strings to the beginning of certain files. |
`------------------------------------------------------------*/
void
output_headers (void)
{
@@ -244,6 +205,10 @@ output_headers (void)
}
/*-------------------------------------------------------.
| Output constant strings to the ends of certain files. |
`-------------------------------------------------------*/
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
output_token_translations (void)
{
register int i, j;
/* register short *sp; JF unused */
int i, j;
/* short *sp; JF unused */
if (translations)
{
@@ -362,9 +274,9 @@ output_token_translations (void)
static void
output_gram (void)
{
register int i;
register int j;
register short *sp;
int i;
int j;
short *sp;
/* With the ordinary parser,
yyprhs and yyrhs are needed only for yydebug. */
@@ -427,8 +339,8 @@ output_gram (void)
static void
output_stos (void)
{
register int i;
register int j;
int i;
int j;
fprintf (ftable, "\nstatic const short yystos[] = { 0");
@@ -457,8 +369,8 @@ output_stos (void)
static void
output_rule_data (void)
{
register int i;
register int j;
int i;
int j;
fputs ("\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
almost by accident */
{
register char *p;
char *p;
putc (',', ftable);
j++;
@@ -649,118 +561,40 @@ output_defines (void)
}
/* 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 ();
}
/* 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. */
/*------------------------------------------------------------------.
| 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
action_row (int state)
{
register int i;
register int j;
register int k;
register int m = 0;
register int n = 0;
register int count;
register int default_rule;
register int nreds;
register int max;
register int rule;
register int shift_state;
register int symbol;
register unsigned mask;
register unsigned *wordp;
register reductions *redp;
register shifts *shiftp;
register errs *errp;
int i;
int j;
int k;
int m = 0;
int n = 0;
int count;
int default_rule;
int nreds;
int max;
int rule;
int shift_state;
int symbol;
unsigned mask;
unsigned *wordp;
reductions *redp;
shifts *shiftp;
errs *errp;
int nodefault = 0; /* set nonzero to inhibit having any default reduction */
for (i = 0; i < ntokens; i++)
@@ -914,11 +748,11 @@ action_row (int state)
static void
save_row (int state)
{
register int i;
register int count;
register short *sp;
register short *sp1;
register short *sp2;
int i;
int count;
short *sp;
short *sp1;
short *sp2;
count = 0;
for (i = 0; i < ntokens; i++)
@@ -947,29 +781,29 @@ save_row (int 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. */
/*------------------------------------------------------------------.
| 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
goto_actions (void)
token_actions (void)
{
register int i;
register int j;
register int k;
int i;
int j;
int k;
state_count = NEW2 (nstates, short);
actrow = NEW2 (ntokens, short);
k = default_goto (ntokens);
fprintf (ftable, "\nstatic const short yydefgoto[] = {%6d", k);
save_column (ntokens, k);
k = action_row (0);
fprintf (ftable, "\nstatic const short yydefact[] = {%6d", k);
save_row (0);
j = 10;
for (i = ntokens + 1; i < nsyms; i++)
for (i = 1; i < nstates; i++)
{
putc (',', ftable);
@@ -983,65 +817,58 @@ goto_actions (void)
j++;
}
k = default_goto (i);
k = action_row (i);
fprintf (ftable, "%6d", k);
save_column (i, k);
save_row (i);
}
fprintf (ftable, "\n};\n");
FREE (state_count);
FREE (actrow);
}
static int
default_goto (int symbol)
static void
free_shifts (void)
{
register int i;
register int m;
register int n;
register int default_state;
register int max;
shifts *sp, *sptmp; /* JF derefrenced freed ptr */
m = goto_map[symbol];
n = goto_map[symbol + 1];
FREE (shift_table);
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++)
for (sp = first_shift; sp; sp = sptmp)
{
if (state_count[i] > max)
{
max = state_count[i];
default_state = i;
sptmp = sp->next;
FREE (sp);
}
}
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
save_column (int symbol, int default_state)
{
register int i;
register int m;
register int n;
register short *sp;
register short *sp1;
register short *sp2;
register int count;
register int symno;
int i;
int m;
int n;
short *sp;
short *sp1;
short *sp2;
int count;
int symno;
m = goto_map[symbol];
n = goto_map[symbol + 1];
@@ -1074,6 +901,86 @@ save_column (int symbol, int default_state)
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
@@ -1082,11 +989,11 @@ save_column (int symbol, int default_state)
static void
sort_actions (void)
{
register int i;
register int j;
register int k;
register int t;
register int w;
int i;
int j;
int k;
int t;
int w;
order = NEW2 (nvectors, short);
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
matching_state (int vector)
{
register int i;
register int j;
register int k;
register int t;
register int w;
register int match;
register int prev;
int i;
int j;
int k;
int t;
int w;
int match;
int prev;
i = order[vector];
if (i >= nstates)
@@ -1203,18 +1061,17 @@ matching_state (int vector)
}
static int
pack_vector (int vector)
{
register int i;
register int j;
register int k;
register int t;
register int loc = 0;
register int ok;
register short *from;
register short *to;
int i;
int j;
int k;
int t;
int loc = 0;
int ok;
short *from;
short *to;
i = order[vector];
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
and the vectors whose elements index the portion starts */
@@ -1276,8 +1179,8 @@ pack_vector (int vector)
static void
output_base (void)
{
register int i;
register int j;
int i;
int j;
fprintf (ftable, "\nstatic const short yypact[] = {%6d", base[0]);
@@ -1328,8 +1231,8 @@ output_base (void)
static void
output_table (void)
{
register int i;
register int j;
int i;
int j;
fprintf (ftable, "\n\n#define\tYYLAST\t\t%d\n\n", high);
fprintf (ftable, "\nstatic const short yytable[] = {%6d", table[0]);
@@ -1360,8 +1263,8 @@ output_table (void)
static void
output_check (void)
{
register int i;
register int j;
int i;
int j;
fprintf (ftable, "\nstatic const short yycheck[] = {%6d", check[0]);
@@ -1387,14 +1290,45 @@ output_check (void)
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. */
static void
output_parser (void)
{
register int c;
int c;
#ifdef DONTDEF
FILE *fpars;
#else
@@ -1474,7 +1408,7 @@ output_parser (void)
static void
output_program (void)
{
register int c;
int c;
if (!nolinesflag)
fprintf (ftable, "#line %d \"%s\"\n", lineno, infile);
@@ -1491,7 +1425,7 @@ output_program (void)
static void
free_itemsets (void)
{
register core *cp, *cptmp;
core *cp, *cptmp;
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);
for (sp = first_shift; sp; sp = sptmp)
/* output_token_defines(ftable); / * JF put out token defines FIRST */
if (!semantic_parser) /* JF Put out other stuff */
{
sptmp = sp->next;
FREE (sp);
}
}
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);
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 ();
}

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 "gram.h"
#include "complain.h"
#include "output.h"
#define LTYPESTR "\
\n\
@@ -70,8 +71,6 @@ extern int maxtoken;
extern void init_lex PARAMS((void));
extern char *grow_token_buffer PARAMS((char *));
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 open_extra_files PARAMS((void));
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
copy_comment2 (FILE *in, FILE *out1, FILE* out2, int c)