*/
#include "system.h"
-#include "obstack.h"
#include "quotearg.h"
#include "getargs.h"
#include "files.h"
#include "conflicts.h"
#include "muscle_tab.h"
-extern void berror PARAMS((const char *));
static int nvectors;
static int nentries;
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
XFREE (yyrhs);
}
-
+
#if 0
- if (!semantic_parser && !no_parser_flag)
+ if (!semantic_parser)
obstack_sgrow (&table_obstack, "\n#endif\n");
#endif
}
int i;
short *values = (short *) alloca (sizeof (short) * nstates);
for (i = 0; i < nstates; ++i)
- values[i] = state_table[i].accessing_symbol;
+ values[i] = state_table[i]->accessing_symbol;
output_table_data (&output_obstack, values,
0, 1, nstates);
muscle_insert ("stos", obstack_finish (&output_obstack));
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 */
0, 1, nrules + 1);
muscle_insert ("r2", obstack_finish (&output_obstack));
XFREE (short_tab);
-
- 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 = state_table[state].reduction_table;
+ redp = state_table[state]->reductions;
if (redp)
{
{
/* loop over all the rules available here which require
lookahead */
- m = state_table[state].lookaheads;
- n = state_table[state + 1].lookaheads;
+ m = state_table[state]->lookaheads;
+ n = state_table[state + 1]->lookaheads;
for (i = n - 1; i >= m; i--)
- {
- rule = -LAruleno[i];
- wordp = LA (i);
- 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 = state_table[state].shift_table;
-
/* 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 = state_table[shift_state].accessing_symbol;
+ 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 (state_table[state].consistent)
+ 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++)
}
+/*-----------------------------.
+| Output the actions to OOUT. |
+`-----------------------------*/
+
+static void
+actions_output (FILE *out, size_t *line)
+{
+ 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)
{
}
}
- berror ("pack_vector");
- return 0; /* JF keep lint happy */
+ assert (!"pack_vector");
+ return 0;
}
static void
output_actions (void)
{
+ int i;
nvectors = nstates + nvars;
froms = XCALLOC (short *, nvectors);
width = XCALLOC (short, nvectors);
token_actions ();
- LIST_FREE (shifts, first_shift);
- LIST_FREE (reductions, first_reduction);
XFREE (LA);
XFREE (LAruleno);
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);
}
`------------------------------------------------------------*/
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)) == '%')
/* 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);
+ fprintf (out, "%d", line);
+ else if (muscle_value)
+ {
+ 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);
}
- muscle_insert ("skeleton", skeleton);
- output_parser (skeleton, &table_obstack);
+ muscle_insert ("skeleton", skeleton);
+ muscle_insert ("parser-file-name", parser_file_name);
+
+ output_parser (skeleton, parser);
+ xfclose (parser);
}
MUSCLE_INSERT_INT ("maxtok", max_user_token_number);
MUSCLE_INSERT_INT ("ntbase", ntokens);
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 ("ntokens", ntokens);
MUSCLE_INSERT_INT ("locations-flag", locations_flag);
+}
+
+
+/*-------------------------.
+| Output the header file. |
+`-------------------------*/
+
+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;
- /* We need to save the actions in the muscle %%action. */
- muscle_insert ("action", obstack_finish (&action_obstack));
+ 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);
+ }
- if (spec_name_prefix)
- MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
+ 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);
- LIST_FREE (core, first_state);
-
output_token_translations ();
output_gram ();
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