#include "conflicts.h"
#include "muscle_tab.h"
-extern void berror PARAMS((const char *));
static int nvectors;
static int nentries;
XFREE (yyrhs);
}
-
-#if 0
- if (!semantic_parser && !no_parser_flag)
- 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 */
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];
}
}
/* 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. */
- shiftp = state_table[state].shift_table;
-
+ shiftp = state_table[state]->shifts;
for (i = 0; i < shiftp->nshifts; i++)
{
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;
/* See which tokens are an explicit error in this state (due to
%nonassoc). For them, record MINSHORT as the action. */
- errp = err_table[state];
+ 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++)
}
}
- 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);
}
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 (oout, "%%");
else
skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
}
- muscle_insert ("skeleton", skeleton);
+ muscle_insert ("skeleton", skeleton);
output_parser (skeleton, &table_obstack);
}
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 ("locations-flag", locations_flag);
/* We need to save the actions in the muscle %%action. */
+ obstack_1grow (&action_obstack, 0);
muscle_insert ("action", obstack_finish (&action_obstack));
- if (spec_name_prefix)
- MUSCLE_INSERT_STRING ("prefix", spec_name_prefix);
}
/*----------------------------------------------------------.
{
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_master_parser ();
projects / bison.git / blobdiff