/* Output the generated parsing program for bison,
- Copyright 1984, 1986, 1989, 1992, 2000 Free Software Foundation, Inc.
+
+ Copyright (C) 1984, 1986, 1989, 1992, 2000, 2001 Free Software
+ Foundation, Inc.
This file is part of Bison, the GNU Compiler Compiler.
#include "obstack.h"
#include "quotearg.h"
#include "getargs.h"
-#include "xalloc.h"
#include "files.h"
#include "gram.h"
#include "LR0.h"
#include "reader.h"
#include "conflicts.h"
-extern void berror PARAMS((const char *));
-
-
static int nvectors;
static int nentries;
-static short **froms;
-static short **tos;
-static short *tally;
-static short *width;
-static short *actrow;
-static short *state_count;
-static short *order;
-static short *base;
-static short *pos;
-static short *table;
-static short *check;
+static short **froms = NULL;
+static short **tos = NULL;
+static short *tally = NULL;
+static short *width = NULL;
+static short *actrow = NULL;
+static short *state_count = NULL;
+static short *order = NULL;
+static short *base = NULL;
+static short *pos = NULL;
+static short *table = NULL;
+static short *check = NULL;
static int lowzero;
static int high;
const char *table_name,
short *short_table,
short first_value,
- short begin, short end)
+ int begin, int end)
{
int i, j;
if (j >= 10)
{
- obstack_grow_literal_string (oout, "\n ");
+ obstack_sgrow (oout, "\n ");
j = 1;
}
else
obstack_fgrow1 (oout, "%6d", short_table[i]);
}
- obstack_grow_literal_string (oout, "\n};\n");
+ obstack_sgrow (oout, "\n};\n");
}
const char *table_name,
short *short_table,
short first_value,
- short begin, short end)
+ int begin, int end)
{
output_short_or_char_table (oout, comment, "short", table_name, short_table,
first_value, begin, end);
void
output_headers (void)
{
- char *attrsfile_quoted = quotearg_style (c_quoting_style, attrsfile);
+ char *attrsfile_quoted = 0;
if (semantic_parser)
- fprintf (fguard, GUARDSTR, attrsfile_quoted);
+ {
+ /* FIXME: This is *buggy*. ATTRSFILE is not computed yet, since
+ we are waiting for the full input file to have been read to
+ be sure of the output file name. So basically, here, a SEGV
+ is guaranteed. OTOH, currently semantic parsers are not
+ supported. */
+ attrsfile_quoted = quotearg_style (c_quoting_style, attrsfile);
+ obstack_fgrow1 (&guard_obstack, GUARDSTR, attrsfile_quoted);
+ }
if (no_parser_flag)
return;
if (semantic_parser)
obstack_fgrow1 (&action_obstack, ACTSTR, attrsfile_quoted);
else
- obstack_grow_literal_string (&action_obstack, ACTSTR_SIMPLE);
-
-/* if (semantic_parser) JF moved this below
- fprintf(ftable, "#include \"%s\"\n", attrsfile);
- fprintf(ftable, "#include <stdio.h>\n\n");
-*/
+ obstack_sgrow (&action_obstack, ACTSTR_SIMPLE);
/* Rename certain symbols if -p was specified. */
if (spec_name_prefix)
output_trailers (void)
{
if (semantic_parser)
- fprintf (fguard, "\n }\n}\n");
+ obstack_sgrow (&guard_obstack, "\n }\n}\n");
obstack_1grow (&action_obstack, '\n');
return;
if (semantic_parser)
- obstack_grow_literal_string (&action_obstack, " }\n");
+ obstack_sgrow (&action_obstack, " }\n");
- obstack_grow_literal_string (&action_obstack, "}\n");
+ obstack_sgrow (&action_obstack, "}\n");
}
static void
output_token_translations (void)
{
- obstack_grow_literal_string (&table_obstack, "\
+ obstack_sgrow (&table_obstack, "\
\n\
-/* YYRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */\n");
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */\n");
- if (translations)
- {
- obstack_fgrow2 (&table_obstack,
+ obstack_fgrow2 (&table_obstack,
"#define YYTRANSLATE(x) ((unsigned)(x) <= %d ? yytranslate[x] : %d)\
\n\
\n",
- max_user_token_number, nsyms);
+ max_user_token_number, nsyms);
- output_short_or_char_table (&table_obstack,
- "YYRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX",
- ntokens < 127 ? "char" : "short",
- "yytranslate", token_translations,
- 0, 1, max_user_token_number + 1);
- }
- else
- {
- obstack_grow_literal_string (&table_obstack,
- "\n#define YYTRANSLATE(x) (x)\n");
- }
+ output_short_or_char_table (&table_obstack,
+ "YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX",
+ ntokens < 127 ? "char" : "short",
+ "yytranslate", token_translations,
+ 0, 1, max_user_token_number + 1);
+
+ XFREE (token_translations);
}
yyprhs and yyrhs are needed only for yydebug. */
/* With the no_parser option, all tables are generated */
if (!semantic_parser && !no_parser_flag)
- obstack_grow_literal_string (&table_obstack, "\n#if YYDEBUG != 0\n");
+ obstack_sgrow (&table_obstack, "\n#if YYDEBUG\n");
- output_short_table (&table_obstack, NULL, "yyprhs", rrhs,
- 0, 1, nrules + 1);
+ {
+ int i;
+ short *values = XCALLOC (short, nrules + 1);
+ for (i = 0; i < nrules + 1; ++i)
+ values[i] = rule_table[i].rhs;
+ output_short_table (&table_obstack, NULL, "yyprhs", values,
+ 0, 1, nrules + 1);
+ XFREE (values);
+ }
{
size_t yyrhs_size = 1;
}
if (!semantic_parser && !no_parser_flag)
- obstack_grow_literal_string (&table_obstack, "\n#endif\n");
+ obstack_sgrow (&table_obstack, "\n#endif\n");
}
static void
output_stos (void)
{
- output_short_table (&table_obstack, NULL, "yystos", accessing_symbol,
+ int i;
+ short *values = (short *) alloca (sizeof (short) * nstates);
+ for (i = 0; i < nstates; ++i)
+ values[i] = state_table[i].accessing_symbol;
+ output_short_table (&table_obstack,
+ "YYSTOS[STATE] -- Accessing symbol to the STATE",
+ "yystos", values,
0, 1, nstates);
}
int j;
short *short_tab = NULL;
- obstack_grow_literal_string (&table_obstack, "\n\
-#if YYDEBUG != 0\n");
+ obstack_sgrow (&table_obstack, "\n\
+#if YYDEBUG\n");
- output_short_table (&table_obstack,
- "YYRLINE[YYN] -- source line where rule number YYN was defined",
- "yyrline", rline,
- 0, 1, nrules + 1);
+ {
+ short *values = XCALLOC (short, nrules + 1);
+ for (i = 0; i < nrules + 1; ++i)
+ values[i] = rule_table[i].line;
+ output_short_table (&table_obstack,
+ "YYRLINE[YYN] -- source line where rule number YYN was defined",
+ "yyrline", values,
+ 0, 1, nrules + 1);
+ XFREE (values);
+ }
- obstack_grow_literal_string (&table_obstack, "#endif\n\n");
+ obstack_sgrow (&table_obstack, "#endif\n\n");
if (token_table_flag || no_parser_flag)
{
/* Output the table of symbol names. */
if (!token_table_flag && !no_parser_flag)
- obstack_grow_literal_string (&table_obstack,
- "\n#if YYDEBUG != 0 || defined YYERROR_VERBOSE\n\n");
- obstack_grow_literal_string (&table_obstack, "\
+ obstack_sgrow (&table_obstack,
+ "\n#if (YYDEBUG) || defined YYERROR_VERBOSE\n\n");
+ obstack_sgrow (&table_obstack, "\
/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */\n");
- obstack_grow_literal_string (&table_obstack,
+ obstack_sgrow (&table_obstack,
"static const char *const yytname[] =\n{\n ");
j = 0;
if (j + strsize > 75)
{
- obstack_grow_literal_string (&table_obstack, "\n ");
+ obstack_sgrow (&table_obstack, "\n ");
j = 2;
}
for (p = tags[i]; p && *p; p++)
{
if (*p == '"' || *p == '\\')
- {
- obstack_fgrow1 (&table_obstack, "\\%c", *p);
- }
+ obstack_fgrow1 (&table_obstack, "\\%c", *p);
else if (*p == '\n')
- {
- obstack_grow_literal_string (&table_obstack, "\\n");
- }
+ obstack_sgrow (&table_obstack, "\\n");
else if (*p == '\t')
- {
- obstack_grow_literal_string (&table_obstack, "\\t");
- }
+ obstack_sgrow (&table_obstack, "\\t");
else if (*p == '\b')
- {
- obstack_grow_literal_string (&table_obstack, "\\b");
- }
+ obstack_sgrow (&table_obstack, "\\b");
else if (*p < 040 || *p >= 0177)
- {
- obstack_fgrow1 (&table_obstack, "\\%03o", *p);
- }
+ obstack_fgrow1 (&table_obstack, "\\%03o", *p);
else
- {
- obstack_1grow (&table_obstack, *p);
- }
+ obstack_1grow (&table_obstack, *p);
}
- obstack_grow_literal_string (&table_obstack, "\", ");
+ obstack_sgrow (&table_obstack, "\", ");
j += strsize;
}
/* add a NULL entry to list of tokens */
- obstack_grow_literal_string (&table_obstack, "NULL\n};\n");
+ obstack_sgrow (&table_obstack, "NULL\n};\n");
if (!token_table_flag && !no_parser_flag)
- obstack_grow_literal_string (&table_obstack, "#endif\n\n");
+ obstack_sgrow (&table_obstack, "#endif\n\n");
/* Output YYTOKNUM. */
if (token_table_flag)
}
/* Output YYR1. */
- output_short_table (&table_obstack,
+ {
+ short *values = XCALLOC (short, nrules + 1);
+ for (i = 0; i < nrules + 1; ++i)
+ values[i] = rule_table[i].lhs;
+ output_short_table (&table_obstack,
"YYR1[YYN] -- Symbol number of symbol that rule YYN derives",
- "yyr1", rlhs,
- 0, 1, nrules + 1);
- XFREE (rlhs + 1);
+ "yyr1", values,
+ 0, 1, nrules + 1);
+ XFREE (values);
+ }
obstack_1grow (&table_obstack, '\n');
/* Output YYR2. */
short_tab = XMALLOC (short, nrules + 1);
for (i = 1; i < nrules; i++)
- short_tab[i] = rrhs[i + 1] - rrhs[i] - 1;
- short_tab[nrules] = nitems - rrhs[nrules] - 1;
+ short_tab[i] = rule_table[i + 1].rhs - rule_table[i].rhs - 1;
+ short_tab[nrules] = nitems - rule_table[nrules].rhs - 1;
output_short_table (&table_obstack,
"YYR2[YYN] -- Number of symbols composing right hand side of rule YYN",
"yyr2", short_tab,
XFREE (short_tab);
- XFREE (rrhs + 1);
+ XFREE (rule_table + 1);
}
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;
default_rule = 0;
nreds = 0;
- redp = reduction_table[state];
+ redp = state_table[state].reductions;
if (redp)
{
{
/* loop over all the rules available here which require
lookahead */
- m = lookaheads[state];
- n = lookaheads[state + 1];
+ m = state_table[state].lookaheads;
+ n = state_table[state + 1].lookaheads;
for (i = n - 1; i >= m; i--)
- {
- rule = -LAruleno[i];
- wordp = LA + i * tokensetsize;
- mask = 1;
-
- /* and find each token which the rule finds acceptable
- to come next */
- for (j = 0; j < ntokens; j++)
- {
- /* and record this rule as the rule to use if that
- token follows. */
- if (mask & *wordp)
- actrow[j] = rule;
-
- mask <<= 1;
- if (mask == 0)
- {
- mask = 1;
- wordp++;
- }
- }
- }
+ /* and find each token which the rule finds acceptable
+ to come next */
+ for (j = 0; j < ntokens; j++)
+ /* and record this rule as the rule to use if that
+ token follows. */
+ if (BITISSET (LA (i), j))
+ actrow[j] = -LAruleno[i];
}
}
- shiftp = shift_table[state];
-
/* Now see which tokens are allowed for shifts in this state. For
them, record the shift as the thing to do. So shift is preferred
to reduce. */
-
- if (shiftp)
+ shiftp = state_table[state].shifts;
+ for (i = 0; i < shiftp->nshifts; i++)
{
- k = shiftp->nshifts;
-
- for (i = 0; i < k; i++)
- {
- shift_state = shiftp->shifts[i];
- if (!shift_state)
- continue;
+ shift_state = shiftp->shifts[i];
+ if (!shift_state)
+ continue;
- symbol = accessing_symbol[shift_state];
+ symbol = state_table[shift_state].accessing_symbol;
- if (ISVAR (symbol))
- break;
+ if (ISVAR (symbol))
+ break;
- actrow[symbol] = shift_state;
+ actrow[symbol] = shift_state;
- /* Do not use any default reduction if there is a shift for
- error */
- if (symbol == error_token_number)
- nodefault = 1;
- }
+ /* Do not use any default reduction if there is a shift for
+ error */
+ if (symbol == error_token_number)
+ nodefault = 1;
}
- errp = err_table[state];
-
/* See which tokens are an explicit error in this state (due to
%nonassoc). For them, record MINSHORT as the action. */
+ errp = state_table[state].errs;
if (errp)
{
if (nreds >= 1 && !nodefault)
{
- if (consistent[state])
+ if (state_table[state].consistent)
default_rule = redp->rules[0];
else
{
- max = 0;
+ int max = 0;
for (i = m; i < n; i++)
{
- count = 0;
+ int count = 0;
rule = -LAruleno[i];
for (j = 0; j < ntokens; j++)
}
-static void
-free_shifts (void)
-{
- shifts *sp, *sptmp; /* JF derefrenced freed ptr */
-
- XFREE (shift_table);
-
- for (sp = first_shift; sp; sp = sptmp)
- {
- sptmp = sp->next;
- XFREE (sp);
- }
-}
-
-
-static void
-free_reductions (void)
-{
- reductions *rp, *rptmp; /* JF fixed freed ptr */
-
- XFREE (reduction_table);
-
- for (rp = first_reduction; rp; rp = rptmp)
- {
- rptmp = rp->next;
- XFREE (rp);
- }
-}
-
-
-
static void
save_column (int symbol, int default_state)
{
return j;
}
}
-
- berror ("pack_vector");
- return 0; /* JF keep lint happy */
+#define pack_vector_succeeded 0
+ assert (pack_vector_succeeded);
+ return 0;
}
width = XCALLOC (short, nvectors);
token_actions ();
- free_shifts ();
- free_reductions ();
- XFREE (lookaheads);
+ LIST_FREE (shifts, first_shift);
+ LIST_FREE (reductions, first_reduction);
XFREE (LA);
XFREE (LAruleno);
- XFREE (accessing_symbol);
goto_actions ();
XFREE (goto_map + ntokens);
output_parser (void)
{
int c;
- static int number_of_dollar_signs = 0;
FILE *fskel;
+ size_t line;
+ int actions_dumped = 0;
if (pure_parser)
- obstack_grow_literal_string (&table_obstack, "#define YYPURE 1\n\n");
+ obstack_sgrow (&table_obstack, "#define YYPURE 1\n\n");
/* Loop over lines in the standard parser file. */
- if (semantic_parser)
- fskel = xfopen (skeleton_find ("BISON_HAIRY", BISON_HAIRY), "r");
- else
- fskel = xfopen (skeleton_find ("BISON_SIMPLE", BISON_SIMPLE), "r");
+ if (!skeleton)
+ {
+ if (semantic_parser)
+ skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY);
+ else
+ skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
+ }
+ assert (skeleton);
+ fskel = xfopen (skeleton, "r");
+
+ /* Set LINE to 2, not 1: `#line LINENUM' -- Here LINENUM is a
+ decimal integer constant. This specifies that the line number of
+ the *following* line of input, in its original source file, was
+ LINENUM. */
+ line = 2;
while (1)
{
- int write_line = 1;
+ enum line_type_e
+ {
+ regular_line,
+ sync_line, /* #line. */
+ actions_line /* %% actions. */
+ };
+ enum line_type_e line_type = regular_line;
c = getc (fskel);
- /* See if the line starts with `#line.
- If so, set write_line to 0. */
- if (no_lines_flag)
- if (c == '#')
- {
- c = getc (fskel);
- if (c == 'l')
- {
- c = getc (fskel);
- if (c == 'i')
- {
- c = getc (fskel);
- if (c == 'n')
- {
- c = getc (fskel);
- if (c == 'e')
- write_line = 0;
+ /* Is this line special? */
+ if (c == '#')
+ {
+ /* See if it's a `#line' line. */
+ if ((c = getc (fskel)) == 'l')
+ if ((c = getc (fskel)) == 'i')
+ if ((c = getc (fskel)) == 'n')
+ if ((c = getc (fskel)) == 'e')
+ line_type = sync_line;
+ else
+ obstack_sgrow (&table_obstack, "#lin");
+ else
+ obstack_sgrow (&table_obstack, "#li");
+ else
+ obstack_sgrow (&table_obstack, "#l");
+ else
+ obstack_sgrow (&table_obstack, "#");
+ }
+ else if (c == '%')
+ {
+ /* See if it's a `%% actions' line. */
+ if ((c = getc (fskel)) == '%')
+ if ((c = getc (fskel)) == ' ')
+ if ((c = getc (fskel)) == 'a')
+ if ((c = getc (fskel)) == 'c')
+ if ((c = getc (fskel)) == 't')
+ if ((c = getc (fskel)) == 'i')
+ if ((c = getc (fskel)) == 'o')
+ if ((c = getc (fskel)) == 'n')
+ if ((c = getc (fskel)) == 's')
+ line_type = actions_line;
+ else
+ obstack_sgrow (&table_obstack, "%% action");
else
- obstack_grow_literal_string (&table_obstack, "#lin");
- }
+ obstack_sgrow (&table_obstack, "%% actio");
+ else
+ obstack_sgrow (&table_obstack, "%% acti");
else
- obstack_grow_literal_string (&table_obstack, "#li");
- }
+ obstack_sgrow (&table_obstack, "%% act");
+ else
+ obstack_sgrow (&table_obstack, "%% ac");
else
- obstack_grow_literal_string (&table_obstack, "#l");
- }
+ obstack_sgrow (&table_obstack, "%% a");
+ else
+ obstack_sgrow (&table_obstack, "%% ");
else
- obstack_grow_literal_string (&table_obstack, "#");
- }
+ obstack_sgrow (&table_obstack, "%%");
+ else
+ obstack_sgrow (&table_obstack, "%");
+ }
+
+ switch (line_type)
+ {
+ case sync_line:
+ if (!no_lines_flag)
+ obstack_fgrow2 (&table_obstack, "#line %d %s\n",
+ line, quotearg_style (c_quoting_style, skeleton));
+
+ /* Skip the end of line. */
+ for (; c != '\n' && c != EOF; c = getc (fskel))
+ /* nothing */;
+ break;
- /* now write out the line... */
- for (; c != '\n' && c != EOF; c = getc (fskel))
- if (write_line)
+ case actions_line:
{
- /* `$' in the parser file indicates where to put the
- actions. Copy them in at this point. */
- if (c == '$')
- {
- size_t size = obstack_object_size (&action_obstack);
-
- number_of_dollar_signs++;
- assert (number_of_dollar_signs == 1);
- obstack_grow (&table_obstack,
- obstack_finish (&action_obstack),
- size);
-
- /* Skip the end of the line containing `$'. */
- write_line = 0;
- }
- else
- obstack_1grow (&table_obstack, c);
+ size_t size = obstack_object_size (&action_obstack);
+
+ actions_dumped++;
+ assert (actions_dumped == 1);
+ obstack_grow (&table_obstack,
+ obstack_finish (&action_obstack),
+ size);
}
+
+ /* Skip the end of line. */
+ for (; c != '\n' && c != EOF; c = getc (fskel))
+ /* nothing */;
+ break;
+
+ case regular_line:
+ for (; c != '\n' && c != EOF; c = getc (fskel))
+ obstack_1grow (&table_obstack, c);
+ }
+
if (c == EOF)
break;
obstack_1grow (&table_obstack, c);
+ line++;
}
- assert (number_of_dollar_signs == 1);
+ assert (actions_dumped == 1);
xfclose (fskel);
}
}
-static void
-free_itemsets (void)
-{
- core *cp, *cptmp;
-
- XFREE (state_table);
-
- for (cp = first_state; cp; cp = cptmp)
- {
- cptmp = cp->next;
- XFREE (cp);
- }
-}
-
-
/*----------------------------------------------------------.
| Output the parsing tables and the parser code to ftable. |
`----------------------------------------------------------*/
obstack_grow (&table_obstack, obstack_finish (&attrs_obstack), size);
}
reader_output_yylsp (&table_obstack);
- if (debug_flag)
- obstack_grow_literal_string (&table_obstack, "\
+ obstack_fgrow1 (&table_obstack, "\
#ifndef YYDEBUG\n\
-# define YYDEBUG 1\n\
+# define YYDEBUG %d\n\
#endif\n\
-\n");
+\n", debug_flag);
if (semantic_parser)
obstack_fgrow1 (&table_obstack, "#include %s\n",
quotearg_style (c_quoting_style, attrsfile));
- if (!no_parser_flag)
- obstack_grow_literal_string (&table_obstack, "#include <stdio.h>\n\n");
-
- /* Make "const" do nothing if not in ANSI C. */
- obstack_grow_literal_string (&table_obstack, "\
-#ifndef __cplusplus\n\
-# ifndef __STDC__\n\
-# define const\n\
-# endif\n\
-#endif\n\
-\n");
-
- free_itemsets ();
+ LIST_FREE (core, first_state);
output_defines ();
output_token_translations ();
/* if (semantic_parser) */
output_stos ();
output_rule_data ();
output_actions ();
+ XFREE (state_table);
+
if (!no_parser_flag)
output_parser ();
output_program ();
projects / bison.git / blobdiff