#include "obstack.h"
#include "quotearg.h"
#include "getargs.h"
-#include "xalloc.h"
#include "files.h"
#include "gram.h"
#include "LR0.h"
#include "lalr.h"
#include "reader.h"
#include "conflicts.h"
-#include "macrotab.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 macro_obstack;
+struct obstack muscle_obstack;
struct obstack output_obstack;
/* FIXME. */
static inline void
-output_table_data (struct obstack* oout,
- short* table,
- 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)
{
}
else
++j;
- obstack_fgrow1 (oout, "%6d", table[i]);
+ obstack_fgrow1 (oout, "%6d", table_data[i]);
}
obstack_1grow (oout, 0);
}
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);
- macro_insert ("translate", obstack_finish (&output_obstack));
+ 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);
- macro_insert ("prhs", obstack_finish (&output_obstack));
-
+ {
+ 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);
- macro_insert ("rhs", obstack_finish (&output_obstack));
+ muscle_insert ("rhs", obstack_finish (&output_obstack));
XFREE (yyrhs);
}
- /* if (!semantic_parser && !no_parser_flag)
- obstack_sgrow (&table_obstack, "\n#endif\n"); */
+#if 0
+ if (!semantic_parser && !no_parser_flag)
+ 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);
- macro_insert ("stos", obstack_finish (&output_obstack));
+ muscle_insert ("stos", obstack_finish (&output_obstack));
}
int j;
short *short_tab = NULL;
- output_table_data (&output_obstack, rline,
- 0, 1, nrules + 1);
- macro_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++)
/* Finish table and store. */
obstack_1grow (&output_obstack, 0);
- macro_insert ("tname", obstack_finish (&output_obstack));
+ muscle_insert ("tname", obstack_finish (&output_obstack));
/* Output YYTOKNUM. */
output_table_data (&output_obstack, user_toknums,
0, 1, ntokens + 1);
- macro_insert ("toknum", obstack_finish (&output_obstack));
+ muscle_insert ("toknum", obstack_finish (&output_obstack));
/* Output YYR1. */
- output_table_data (&output_obstack, rlhs,
- 0, 1, nrules + 1);
- macro_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);
- macro_insert ("r2", obstack_finish (&output_obstack));
+ muscle_insert ("r2", obstack_finish (&output_obstack));
XFREE (short_tab);
- XFREE (rrhs + 1);
+ XFREE (rule_table + 1);
}
/*------------------------------------------------------------------.
default_rule = 0;
nreds = 0;
- redp = reduction_table[state];
+ redp = state_table[state].reduction_table;
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;
+ wordp = LA (i);
mask = 1;
/* and find each token which the rule finds acceptable
}
}
- shiftp = shift_table[state];
+ 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
if (!shift_state)
continue;
- symbol = accessing_symbol[shift_state];
+ symbol = state_table[shift_state].accessing_symbol;
if (ISVAR (symbol))
break;
if (nreds >= 1 && !nodefault)
{
- if (consistent[state])
+ if (state_table[state].consistent)
default_rule = redp->rules[0];
else
{
save_row (i);
}
- output_table_data (&output_obstack, yydefact,
+ output_table_data (&output_obstack, yydefact,
yydefact[0], 1, nstates);
- macro_insert ("defact", obstack_finish (&output_obstack));
-
+ 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);
- }
-}
-
-
-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)
{
yydefgoto[i - ntokens] = default_state;
}
- output_table_data (&output_obstack, yydefgoto,
+ output_table_data (&output_obstack, yydefgoto,
yydefgoto[0], 1, nsyms - ntokens);
- macro_insert ("defgoto", obstack_finish (&output_obstack));
+ muscle_insert ("defgoto", obstack_finish (&output_obstack));
XFREE (state_count);
XFREE (yydefgoto);
output_base (void)
{
/* Output pact. */
- output_table_data (&output_obstack, base,
+ output_table_data (&output_obstack, base,
base[0], 1, nstates);
- macro_insert ("pact", obstack_finish (&output_obstack));
+ 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);
- macro_insert ("pgoto", obstack_finish (&output_obstack));
+ muscle_insert ("pgoto", obstack_finish (&output_obstack));
XFREE (base);
}
static void
output_table (void)
{
- output_table_data (&output_obstack, table,
+ output_table_data (&output_obstack, table,
table[0], 1, high + 1);
- macro_insert ("table", obstack_finish (&output_obstack));
+ 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);
- macro_insert ("check", obstack_finish (&output_obstack));
+ muscle_insert ("check", obstack_finish (&output_obstack));
XFREE (check);
}
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);
sort_actions ();
pack_table ();
- /* FIXME: See if this is useful. */
- /* obstack_1grow (&table_obstack, '\n'); */
+
output_base ();
output_table ();
- /* FIXME: See if this is useful. */
- /* obstack_1grow (&table_obstack, '\n'); */
+
output_check ();
+ XFREE (state_table);
}
-/*------------------------------------------.
-| Copy the parser code into TABLE_OBSTACK. |
-`------------------------------------------*/
+\f
+/*------------------------------------------------------------.
+| Copy the parser code from SKEL_FILENAME into OOUT obstack. |
+| and do the muscle substitution. |
+`------------------------------------------------------------*/
static void
-output_parser (void)
+output_parser (const char *skel_filename, struct obstack *oout)
{
int c;
FILE *fskel;
size_t line;
- int actions_dumped = 0;
- /* Loop over lines in the standard parser file. */
- if (!skeleton)
- {
- if (semantic_parser)
- skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY);
- else
- skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
- }
- fskel = xfopen (skeleton, "r");
+ fskel = xfopen (skel_filename, "r");
- /* New output code. */
+ /* New output code. */
line = 1;
c = getc (fskel);
while (c != EOF)
{
if (c == '\n')
++line;
- obstack_1grow (&table_obstack, c);
+ obstack_1grow (oout, c);
c = getc (fskel);
}
else if ((c = getc (fskel)) == '%')
{
- /* Read the macro. */
- char* macro_key = 0;
- char* macro_value = 0;
+ /* Read the muscle. */
+ const char *muscle_key = 0;
+ const char *muscle_value = 0;
+
while (isalnum (c = getc (fskel)) || c == '_')
- obstack_1grow (¯o_obstack, c);
- obstack_1grow (¯o_obstack, 0);
-
- /* Output the right value, or see if it's something special. */
- macro_key = obstack_finish (¯o_obstack);
- macro_value = macro_find (macro_key);
- if (macro_value)
- obstack_sgrow (&table_obstack, macro_value);
- else if (!strcmp (macro_key, "line"))
- obstack_fgrow1 (&table_obstack, "%d", line + 1);
- else if (!strcmp (macro_key, "action"))
- {
- size_t size = obstack_object_size (&action_obstack);
- obstack_grow (&table_obstack,
- obstack_finish (&action_obstack), size);
- }
+ 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);
+ else if (!strcmp (muscle_key, "line"))
+ obstack_fgrow1 (oout, "%d", line + 1);
+ else if (!strcmp (muscle_key, "input_line"))
+ obstack_fgrow1 (oout, "%d", lineno);
else
{
- obstack_sgrow (&table_obstack, "%%");
- obstack_sgrow (&table_obstack, macro_key);
+ obstack_sgrow (oout, "%%");
+ obstack_sgrow (oout, muscle_key);
}
}
else
- obstack_1grow (&table_obstack, '%');
+ obstack_1grow (oout, '%');
}
- /* End. */
+ /* End. */
xfclose (fskel);
}
-static void
-output_program (void)
-{
- int c;
-
- while ((c = getc (finput)) != EOF)
- obstack_1grow (&table_obstack, c);
-}
-
+/*----------------------------------------.
+| Prepare the master parser to be output |
+`----------------------------------------*/
static void
-free_itemsets (void)
+output_master_parser (void)
{
- core *cp, *cptmp;
-
- XFREE (state_table);
-
- for (cp = first_state; cp; cp = cptmp)
+ if (!skeleton)
{
- cptmp = cp->next;
- XFREE (cp);
+ if (semantic_parser)
+ skeleton = skeleton_find ("BISON_HAIRY", BISON_HAIRY);
+ else
+ skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
}
+ muscle_insert ("skeleton", skeleton);
+ output_parser (skeleton, &table_obstack);
}
+
/* FIXME. */
-#define MACRO_INSERT_INT(Key, Value) \
-{ \
- obstack_fgrow1 (¯o_obstack, "%d", Value); \
- obstack_1grow (¯o_obstack, 0); \
- macro_insert (Key, obstack_finish (¯o_obstack)); \
+#define MUSCLE_INSERT_INT(Key, Value) \
+{ \
+ obstack_fgrow1 (&muscle_obstack, "%d", Value); \
+ obstack_1grow (&muscle_obstack, 0); \
+ muscle_insert (Key, obstack_finish (&muscle_obstack)); \
}
-#define MACRO_INSERT_STRING(Key, Value) \
-{ \
- obstack_sgrow (¯o_obstack, Value); \
- obstack_1grow (¯o_obstack, 0); \
- macro_insert (Key, obstack_finish (¯o_obstack)); \
+#define MUSCLE_INSERT_STRING(Key, Value) \
+{ \
+ obstack_sgrow (&muscle_obstack, Value); \
+ obstack_1grow (&muscle_obstack, 0); \
+ muscle_insert (Key, obstack_finish (&muscle_obstack)); \
}
-#define MACRO_INSERT_PREFIX(Key, Value) \
+#define MUSCLE_INSERT_PREFIX(Key, Value) \
{ \
- obstack_fgrow2 (¯o_obstack, "%s%s", spec_name_prefix, Value); \
- obstack_1grow (¯o_obstack, 0); \
- macro_insert (Key, obstack_finish (¯o_obstack)); \
+ obstack_fgrow2 (&muscle_obstack, "%s%s", spec_name_prefix, Value); \
+ obstack_1grow (&muscle_obstack, 0); \
+ muscle_insert (Key, obstack_finish (&muscle_obstack)); \
}
static void
prepare (void)
{
- MACRO_INSERT_INT ("last", high);
- MACRO_INSERT_INT ("flag", MINSHORT);
- MACRO_INSERT_INT ("pure", pure_parser);
- MACRO_INSERT_INT ("nsym", nsyms);
- MACRO_INSERT_INT ("debug", debug_flag);
- MACRO_INSERT_INT ("final", final_state);
- MACRO_INSERT_INT ("maxtok", max_user_token_number);
- MACRO_INSERT_INT ("ntbase", ntokens);
- MACRO_INSERT_INT ("verbose", 0);
-
- MACRO_INSERT_STRING ("filename", infile);
-
- MACRO_INSERT_INT ("nnts", nvars);
- MACRO_INSERT_INT ("nrules", nrules);
- MACRO_INSERT_INT ("nstates", nstates);
- MACRO_INSERT_INT ("ntokens", ntokens);
+ MUSCLE_INSERT_INT ("last", high);
+ MUSCLE_INSERT_INT ("flag", MINSHORT);
+ MUSCLE_INSERT_INT ("pure", pure_parser);
+ MUSCLE_INSERT_INT ("nsym", nsyms);
+ MUSCLE_INSERT_INT ("debug", debug_flag);
+ 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 ("nnts", nvars);
+ MUSCLE_INSERT_INT ("nrules", nrules);
+ MUSCLE_INSERT_INT ("nstates", nstates);
+ MUSCLE_INSERT_INT ("ntokens", ntokens);
+
+ MUSCLE_INSERT_INT ("locations_flag", locations_flag);
+
+ /* We need to save the actions in the muscle %%action. */
+ muscle_insert ("action", obstack_finish (&action_obstack));
if (spec_name_prefix)
- {
- MACRO_INSERT_PREFIX ("yylex", "lex");
- MACRO_INSERT_PREFIX ("yychar", "char");
- MACRO_INSERT_PREFIX ("yylval", "lval");
- MACRO_INSERT_PREFIX ("yydebug", "debug");
- MACRO_INSERT_PREFIX ("yyerror", "error");
- MACRO_INSERT_PREFIX ("yynerrs", "nerrs");
- MACRO_INSERT_PREFIX ("yyparse", "parse");
- }
+ MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
}
/*----------------------------------------------------------.
{
obstack_init (&output_obstack);
- /* reader_output_yylsp (&table_obstack); */
- free_itemsets ();
+ LIST_FREE (core, first_state);
output_token_translations ();
output_gram ();
if (semantic_parser)
output_stos ();
output_rule_data ();
+ XFREE (user_toknums);
output_actions ();
- /* if (!no_parser_flag) */
+#if 0
+ if (!no_parser_flag) */
+#endif
prepare ();
/* Copy definitions in directive. */
- macro_insert ("definitions", obstack_finish (&attrs_obstack));
- output_parser ();
- output_program ();
+ muscle_insert ("prologue", obstack_finish (&attrs_obstack));
+
+ output_master_parser ();
- obstack_free (¯o_obstack, 0);
+ obstack_free (&muscle_obstack, 0);
obstack_free (&output_obstack, 0);
+ obstack_free (&action_obstack, 0);
}
projects / bison.git / blobdiff