#include "conflicts.h"
#include "muscle_tab.h"
-extern void berror PARAMS((const char *));
static int nvectors;
static int nentries;
struct obstack muscle_obstack;
struct obstack output_obstack;
+int error_verbose = 0;
+
/* FIXME. */
static inline void
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];
}
}
- 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++)
}
-static void
-free_shifts (void)
-{
- shifts *sp, *sptmp; /* JF derefrenced freed ptr */
-
- for (sp = first_shift; sp; sp = sptmp)
- {
- sptmp = sp->next;
- XFREE (sp);
- }
-}
-
-
-static void
-free_reductions (void)
-{
- reductions *rp, *rptmp; /* JF fixed freed ptr */
-
- for (rp = first_reduction; rp; rp = rptmp)
- {
- rptmp = rp->next;
- XFREE (rp);
- }
-}
-
-
-
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 ();
- free_shifts ();
- free_reductions ();
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);
}
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);
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);
- /* FIXME: Insert the code to recognize %%sub-skeleton for exemple. */
else
{
obstack_sgrow (oout, "%%");
else
skeleton = skeleton_find ("BISON_SIMPLE", BISON_SIMPLE);
}
+ muscle_insert ("skeleton", skeleton);
output_parser (skeleton, &table_obstack);
}
-static void
-free_itemsets (void)
-{
- core *cp, *cptmp;
- for (cp = first_state; cp; cp = cptmp)
- {
- cptmp = cp->next;
- XFREE (cp);
- }
-}
-
/* 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);
/* 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);
- free_itemsets ();
-
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