*/
#include "system.h"
-#include "obstack.h"
#include "quotearg.h"
#include "getargs.h"
-#include "xalloc.h"
#include "files.h"
#include "gram.h"
#include "LR0.h"
#include "conflicts.h"
#include "muscle_tab.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;
struct obstack muscle_obstack;
struct obstack output_obstack;
+int error_verbose = 0;
+
+/* Returns the number of lines of S. */
+static size_t
+get_lines_number (const char *s)
+{
+ size_t lines = 0;
+
+ size_t i;
+ for (i = 0; s[i]; ++i)
+ {
+ if (s[i] == '\n')
+ ++lines;
+ }
+
+ return lines;
+}
+
+
/* FIXME. */
static inline void
-output_table_data (struct obstack *oout,
- short *table_data,
- short first,
- short begin,
+output_table_data (struct obstack *oout,
+ short *table_data,
+ short first,
+ short begin,
short end)
{
int i;
int j = 1;
-
+
obstack_fgrow1 (oout, "%6d", first);
for (i = begin; i < end; ++i)
{
static void
output_token_translations (void)
{
- output_table_data (&output_obstack, token_translations,
+ output_table_data (&output_obstack, token_translations,
0, 1, max_user_token_number + 1);
muscle_insert ("translate", obstack_finish (&output_obstack));
+ XFREE (token_translations);
}
static void
output_gram (void)
{
- output_table_data (&output_obstack, 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_table_data (&output_obstack, values,
+ 0, 1, nrules + 1);
+ XFREE (values);
+ }
+
muscle_insert ("prhs", obstack_finish (&output_obstack));
-
+
{
size_t yyrhs_size = 1;
short *yyrhs, *sp;
for (sp = ritem + 1, i = 1; *sp; ++sp, ++i)
yyrhs[i] = *sp > 0 ? *sp : 0;
- output_table_data (&output_obstack, yyrhs,
+ output_table_data (&output_obstack, yyrhs,
ritem[0], 1, yyrhs_size);
muscle_insert ("rhs", obstack_finish (&output_obstack));
XFREE (yyrhs);
}
-
+
#if 0
- if (!semantic_parser && !no_parser_flag)
+ if (!semantic_parser)
obstack_sgrow (&table_obstack, "\n#endif\n");
#endif
}
static void
output_stos (void)
{
- output_table_data (&output_obstack, 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_table_data (&output_obstack, values,
0, 1, nstates);
muscle_insert ("stos", obstack_finish (&output_obstack));
}
int j;
short *short_tab = NULL;
- output_table_data (&output_obstack, rline,
- 0, 1, nrules + 1);
- muscle_insert ("rline", obstack_finish (&output_obstack));
+ {
+ short *values = XCALLOC (short, nrules + 1);
+ for (i = 0; i < nrules + 1; ++i)
+ values[i] = rule_table[i].line;
+ output_table_data (&output_obstack, values,
+ 0, 1, nrules + 1);
+ muscle_insert ("rline", obstack_finish (&output_obstack));
+ XFREE (values);
+ }
+
j = 0;
for (i = 0; i < nsyms; i++)
- /* this used to be i<=nsyms, but that output a final "" symbol
- almost by accident */
{
+ /* Be sure not to use twice the same quotearg slot. */
+ const char *cp =
+ quotearg_n_style (1, c_quoting_style,
+ quotearg_style (escape_quoting_style, tags[i]));
/* Width of the next token, including the two quotes, the coma
and the space. */
- int strsize = 4;
- char *p;
-
- for (p = tags[i]; p && *p; p++)
- if (*p == '"' || *p == '\\' || *p == '\n' || *p == '\t'
- || *p == '\b')
- strsize += 2;
- else if (*p < 040 || *p >= 0177)
- strsize += 4;
- else
- strsize++;
+ int strsize = strlen (cp) + 2;
if (j + strsize > 75)
{
j = 2;
}
- obstack_1grow (&output_obstack, '\"');
- for (p = tags[i]; p && *p; p++)
- {
- if (*p == '"' || *p == '\\')
- obstack_fgrow1 (&output_obstack, "\\%c", *p);
- else if (*p == '\n')
- obstack_sgrow (&output_obstack, "\\n");
- else if (*p == '\t')
- obstack_sgrow (&output_obstack, "\\t");
- else if (*p == '\b')
- obstack_sgrow (&output_obstack, "\\b");
- else if (*p < 040 || *p >= 0177)
- obstack_fgrow1 (&output_obstack, "\\%03o", *p);
- else
- obstack_1grow (&output_obstack, *p);
- }
-
- obstack_sgrow (&output_obstack, "\", ");
+ obstack_sgrow (&output_obstack, cp);
+ obstack_sgrow (&output_obstack, ", ");
j += strsize;
}
/* add a NULL entry to list of tokens */
muscle_insert ("toknum", obstack_finish (&output_obstack));
/* Output YYR1. */
- output_table_data (&output_obstack, rlhs,
- 0, 1, nrules + 1);
- muscle_insert ("r1", obstack_finish (&output_obstack));
- XFREE (rlhs + 1);
+ {
+ short *values = XCALLOC (short, nrules + 1);
+ for (i = 0; i < nrules + 1; ++i)
+ values[i] = rule_table[i].lhs;
+ output_table_data (&output_obstack, values,
+ 0, 1, nrules + 1);
+ muscle_insert ("r1", obstack_finish (&output_obstack));
+ XFREE (values);
+ }
/* 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;
- output_table_data (&output_obstack, short_tab,
+ short_tab[i] = rule_table[i + 1].rhs - rule_table[i].rhs - 1;
+ short_tab[nrules] = nitems - rule_table[nrules].rhs - 1;
+ output_table_data (&output_obstack, short_tab,
0, 1, nrules + 1);
muscle_insert ("r2", obstack_finish (&output_obstack));
XFREE (short_tab);
-
- XFREE (rrhs + 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++)
save_row (i);
}
- output_table_data (&output_obstack, yydefact,
+ output_table_data (&output_obstack, yydefact,
yydefact[0], 1, nstates);
muscle_insert ("defact", obstack_finish (&output_obstack));
-
+
XFREE (actrow);
XFREE (yydefact);
}
-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);
- }
-}
-
+/*-----------------------------.
+| Output the actions to OOUT. |
+`-----------------------------*/
static void
-free_reductions (void)
+actions_output (FILE *out, size_t *line)
{
- reductions *rp, *rptmp; /* JF fixed freed ptr */
-
- XFREE (reduction_table);
-
- for (rp = first_reduction; rp; rp = rptmp)
- {
- rptmp = rp->next;
- XFREE (rp);
- }
+ int rule;
+ for (rule = 1; rule < nrules + 1; ++rule)
+ if (rule_table[rule].action)
+ {
+ fprintf (out, " case %d:\n", rule);
+
+ if (!no_lines_flag)
+ fprintf (out, muscle_find ("linef"),
+ rule_table[rule].action_line,
+ quotearg_style (c_quoting_style,
+ muscle_find ("filename")));
+ /* As a Bison extension, add the ending semicolon. Since some
+ Yacc don't do that, help people using bison as a Yacc
+ finding their missing semicolons. */
+ fprintf (out, "{ %s%s }\n break;\n\n",
+ rule_table[rule].action,
+ yacc_flag ? ";" : "");
+
+ /* We always output 5 '\n' per action. */
+ *line += 5;
+ /* Get the number of lines written by the user. */
+ *line += get_lines_number (rule_table[rule].action);
+ }
}
-
static void
save_column (int symbol, int default_state)
{
yydefgoto[i - ntokens] = default_state;
}
- output_table_data (&output_obstack, yydefgoto,
+ output_table_data (&output_obstack, yydefgoto,
yydefgoto[0], 1, nsyms - ntokens);
muscle_insert ("defgoto", obstack_finish (&output_obstack));
}
}
- berror ("pack_vector");
- return 0; /* JF keep lint happy */
+ assert (!"pack_vector");
+ return 0;
}
output_base (void)
{
/* Output pact. */
- output_table_data (&output_obstack, base,
+ output_table_data (&output_obstack, base,
base[0], 1, nstates);
muscle_insert ("pact", obstack_finish (&output_obstack));
/* Output pgoto. */
- output_table_data (&output_obstack, base,
+ output_table_data (&output_obstack, base,
base[nstates], nstates + 1, nvectors);
muscle_insert ("pgoto", obstack_finish (&output_obstack));
static void
output_table (void)
{
- output_table_data (&output_obstack, table,
+ output_table_data (&output_obstack, table,
table[0], 1, high + 1);
muscle_insert ("table", obstack_finish (&output_obstack));
XFREE (table);
static void
output_check (void)
{
- output_table_data (&output_obstack, check,
+ output_table_data (&output_obstack, check,
check[0], 1, high + 1);
muscle_insert ("check", obstack_finish (&output_obstack));
XFREE (check);
static void
output_actions (void)
{
+ int i;
nvectors = nstates + nvars;
froms = XCALLOC (short *, nvectors);
width = XCALLOC (short, nvectors);
token_actions ();
- free_shifts ();
- free_reductions ();
- XFREE (lookaheads);
XFREE (LA);
XFREE (LAruleno);
- XFREE (accessing_symbol);
goto_actions ();
XFREE (goto_map + ntokens);
output_table ();
output_check ();
+
+ for (i = 0; i < nstates; ++i)
+ {
+ XFREE (state_table[i]->shifts);
+ XFREE (state_table[i]->reductions);
+ XFREE (state_table[i]->errs);
+ free (state_table[i]);
+ }
+ XFREE (state_table);
}
\f
`------------------------------------------------------------*/
static void
-output_parser (const char *skel_filename, struct obstack *oout)
+output_parser (const char *skel_filename, FILE *out)
{
int c;
FILE *fskel;
{
if (c == '\n')
++line;
- obstack_1grow (oout, c);
+ putc (c, out);
c = getc (fskel);
}
else if ((c = getc (fskel)) == '%')
const char *muscle_key = 0;
const char *muscle_value = 0;
- while (isalnum (c = getc (fskel)) || c == '_')
+ while (isalnum (c = getc (fskel)) || c == '-')
obstack_1grow (&muscle_obstack, c);
obstack_1grow (&muscle_obstack, 0);
/* Output the right value, or see if it's something special. */
muscle_key = obstack_finish (&muscle_obstack);
muscle_value = muscle_find (muscle_key);
- if (muscle_value)
- obstack_sgrow (oout, muscle_value);
+ if (!strcmp (muscle_key, "actions"))
+ actions_output (out, &line);
else if (!strcmp (muscle_key, "line"))
- obstack_fgrow1 (oout, "%d", line + 1);
- else if (!strcmp (muscle_key, "input_line"))
- obstack_fgrow1 (oout, "%d", lineno + 1);
- else if (!strcmp (muscle_key, "action"))
+ fprintf (out, "%d", line);
+ else if (muscle_value)
{
- size_t size = obstack_object_size (&action_obstack);
- obstack_grow (oout, obstack_base (&action_obstack), size);
- }
- /* FIXME: Insert the code to recognize %%sub-skeleton for exemple. */
+ fputs (muscle_value, out);
+ line += get_lines_number (muscle_value);
+ }
else
{
- obstack_sgrow (oout, "%%");
- obstack_sgrow (oout, muscle_key);
+ fputs ("%%", out);
+ fputs (muscle_key, out);
}
}
else
- obstack_1grow (oout, '%');
+ putc ('%', out);
}
/* End. */
static void
output_master_parser (void)
{
+ FILE *parser = xfopen (parser_file_name, "w");
if (!skeleton)
{
if (semantic_parser)
else
skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
}
-
- obstack_finish (&action_obstack);
- output_parser (skeleton, &table_obstack);
-}
+ muscle_insert ("skeleton", skeleton);
+ muscle_insert ("parser-file-name", parser_file_name);
-
-static void
-free_itemsets (void)
-{
- core *cp, *cptmp;
-
- XFREE (state_table);
-
- for (cp = first_state; cp; cp = cptmp)
- {
- cptmp = cp->next;
- XFREE (cp);
- }
+ output_parser (skeleton, parser);
+ xfclose (parser);
}
+
/* FIXME. */
#define MUSCLE_INSERT_INT(Key, Value) \
MUSCLE_INSERT_INT ("final", final_state);
MUSCLE_INSERT_INT ("maxtok", max_user_token_number);
MUSCLE_INSERT_INT ("ntbase", ntokens);
- MUSCLE_INSERT_INT ("verbose", 0);
+ MUSCLE_INSERT_INT ("error-verbose", error_verbose);
+ MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
MUSCLE_INSERT_INT ("nnts", nvars);
MUSCLE_INSERT_INT ("nrules", nrules);
MUSCLE_INSERT_INT ("nstates", nstates);
MUSCLE_INSERT_INT ("ntokens", ntokens);
- MUSCLE_INSERT_INT ("locations_flag", locations_flag);
+ MUSCLE_INSERT_INT ("locations-flag", locations_flag);
+}
+
+
+/*-------------------------.
+| Output the header file. |
+`-------------------------*/
- if (spec_name_prefix)
- MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
+static void
+header_output (void)
+{
+ FILE *out = xfopen (spec_defines_file, "w");
+ char *macro_name = compute_header_macro ();
+
+ fprintf (out, "#ifndef %s\n", macro_name);
+ fprintf (out, "# define %s\n\n", macro_name);
+
+ fputs (muscle_find ("tokendef"), out);
+ fprintf (out, "\
+#ifndef YYSTYPE\n\
+typedef %s
+yystype;\n\
+# define YYSTYPE yystype\n\
+#endif\n",
+ muscle_find ("stype"));
+
+ if (!pure_parser)
+ fprintf (out, "\nextern YYSTYPE %slval;\n",
+ spec_name_prefix);
+ if (semantic_parser)
+ {
+ int i;
+
+ for (i = ntokens; i < nsyms; i++)
+ /* don't make these for dummy nonterminals made by gensym. */
+ if (*tags[i] != '@')
+ fprintf (out, "# define\tNT%s\t%d\n", tags[i], i);
+ }
+
+ fprintf (out, "\n#endif /* not %s */\n", macro_name);
+ free (macro_name);
+ xfclose (out);
}
+
/*----------------------------------------------------------.
| Output the parsing tables and the parser code to ftable. |
`----------------------------------------------------------*/
{
obstack_init (&output_obstack);
- free_itemsets ();
-
output_token_translations ();
output_gram ();
if (semantic_parser)
output_stos ();
output_rule_data ();
+ XFREE (user_toknums);
output_actions ();
-
-#if 0
- if (!no_parser_flag) */
-#endif
+
prepare ();
/* Copy definitions in directive. */
+ obstack_1grow (&attrs_obstack, 0);
muscle_insert ("prologue", obstack_finish (&attrs_obstack));
+ /* Output the parser. */
output_master_parser ();
+ /* Output the header if needed. */
+ if (defines_flag)
+ header_output ();
+ free (rule_table + 1);
obstack_free (&muscle_obstack, 0);
obstack_free (&output_obstack, 0);
+ obstack_free (&action_obstack, 0);
}
projects / bison.git / blobdiff