* src/closure.c, src/conflicts.c, src/derives.c, src/gram.c

* src/gram.h, src/lalr.c, src/nullable.c, src/output.c, src/print.c
* src/print_graph.c, src/reader.c, src/reduce.c: Rename rule_table
as rules.

diff --git a/ChangeLog b/ChangeLog
index 1cc44d69b6358b8a4ddae1d1ee702ace78f3ba31..0150abe0edf805df51ac3d094cdbba3d508b3b7e 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2001-12-29  Akim Demaille  <akim@epita.fr>
+
+       * src/closure.c, src/conflicts.c, src/derives.c, src/gram.c
+       * src/gram.h, src/lalr.c, src/nullable.c, src/output.c, src/print.c
+       * src/print_graph.c, src/reader.c, src/reduce.c: Rename rule_table
+       as rules.
+
+       

 2001-12-29  Akim Demaille  <akim@epita.fr>
 
        * src/gram.c (rprec, rprecsym, rassoc): Remove, unused since long
 2001-12-29  Akim Demaille  <akim@epita.fr>
 
        * src/gram.c (rprec, rprecsym, rassoc): Remove, unused since long

diff --git a/src/closure.c b/src/closure.c
index 61a111be8e6bb3805b8788360fb31571b19e7b3c..d24e2eab73dc6574c434accd111a3b76a01cf438 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -103,7 +103,7 @@ print_fderives (void)
          {
            short *rhsp;
            fprintf (stderr, "\t\t%d:", j - 1);
          {
            short *rhsp;
            fprintf (stderr, "\t\t%d:", j - 1);

-           for (rhsp = &ritem[rule_table[j].rhs]; *rhsp >= 0; ++rhsp)
+           for (rhsp = &ritem[rules[j].rhs]; *rhsp >= 0; ++rhsp)

              fprintf (stderr, " %s", symbols[*rhsp]->tag);
            fputc ('\n', stderr);
          }
              fprintf (stderr, " %s", symbols[*rhsp]->tag);
            fputc ('\n', stderr);
          }


@@ -133,7 +133,7 @@ set_firsts (void)
   for (i = ntokens; i < nsyms; i++)
     for (j = 0; derives[i][j] >= 0; ++j)
       {
   for (i = ntokens; i < nsyms; i++)
     for (j = 0; derives[i][j] >= 0; ++j)
       {

-       int symbol = ritem[rule_table[derives[i][j]].rhs];
+       int symbol = ritem[rules[derives[i][j]].rhs];

        if (ISVAR (symbol))
          SETBIT (FIRSTS (i), symbol - ntokens);
       }
        if (ISVAR (symbol))
          SETBIT (FIRSTS (i), symbol - ntokens);
       }


@@ -225,7 +225,7 @@ closure (short *core, int n)
   for (ruleno = 0; ruleno < nrules + 1; ++ruleno)
     if (BITISSET (ruleset, ruleno))
       {
   for (ruleno = 0; ruleno < nrules + 1; ++ruleno)
     if (BITISSET (ruleset, ruleno))
       {

-       int itemno = rule_table[ruleno].rhs;
+       int itemno = rules[ruleno].rhs;

        while (c < n && core[c] < itemno)
          {
            itemset[nitemset] = core[c];
        while (c < n && core[c] < itemno)
          {
            itemset[nitemset] = core[c];

diff --git a/src/conflicts.c b/src/conflicts.c
index 2dc1cc5cb30c16dea43bac7a7ff9443f8e22714e..3a979410a2b9f377649e0fdeec1ff93c6ec6b81f 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -94,7 +94,7 @@ resolve_sr_conflict (state_t *state, int lookahead)
 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */
 {
   int i;
   /* find the rule to reduce by to get precedence of reduction  */

-  int redprec = rule_table[LAruleno[lookahead]].prec;
+  int redprec = rules[LAruleno[lookahead]].prec;

   errs *errp = errs_new (ntokens + 1);
   errp->nerrs = 0;
 
   errs *errp = errs_new (ntokens + 1);
   errp->nerrs = 0;
 


@@ -172,7 +172,7 @@ set_conflicts (state_t *state)
      check for shift-reduce conflict, and try to resolve using
      precedence */
   for (i = 0; i < state->nlookaheads; ++i)
      check for shift-reduce conflict, and try to resolve using
      precedence */
   for (i = 0; i < state->nlookaheads; ++i)

-    if (rule_table[LAruleno[state->lookaheadsp + i]].prec)
+    if (rules[LAruleno[state->lookaheadsp + i]].prec)

       for (j = 0; j < tokensetsize; ++j)
        if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
          {
       for (j = 0; j < tokensetsize; ++j)
        if (LA (state->lookaheadsp + i)[j] & lookaheadset[j])
          {

diff --git a/src/derives.c b/src/derives.c
index 479a355101d1921113b74200cf0b845987b50d10..795bc08e88c3cf1a019e3ca4918197c9c193ef56 100644 (file)
--- a/src/derives.c
+++ b/src/derives.c
@@ -44,7 +44,7 @@ print_derives (void)
        {
          short *rhsp;
          fprintf (stderr, "\t\t%d:", *sp);
        {
          short *rhsp;
          fprintf (stderr, "\t\t%d:", *sp);

-         for (rhsp = &ritem[rule_table[*sp].rhs]; *rhsp >= 0; ++rhsp)
+         for (rhsp = &ritem[rules[*sp].rhs]; *rhsp >= 0; ++rhsp)

            fprintf (stderr, " %s", symbols[*rhsp]->tag);
          fprintf (stderr, " (rule %d)\n", -*rhsp - 1);
        }
            fprintf (stderr, " %s", symbols[*rhsp]->tag);
          fprintf (stderr, " (rule %d)\n", -*rhsp - 1);
        }


@@ -68,9 +68,9 @@ set_derives (void)
 
   p = delts;
   for (i = nrules; i > 0; i--)
 
   p = delts;
   for (i = nrules; i > 0; i--)

-    if (rule_table[i].useful)
+    if (rules[i].useful)

       {
       {

-       int lhs = rule_table[i].lhs;
+       int lhs = rules[i].lhs;

        p->next = dset[lhs];
        p->value = i;
        dset[lhs] = p;
        p->next = dset[lhs];
        p->value = i;
        dset[lhs] = p;

diff --git a/src/gram.c b/src/gram.c
index a67bf2e246ad36d6650624b3aa9802bc3ba672d7..f6f39f5a7a0ce7705f204addd781fd596e536d4a 100644 (file)
--- a/src/gram.c
+++ b/src/gram.c
@@ -35,7 +35,7 @@ int nvars;
 short *ritem = NULL;
 int nritems;
 
 short *ritem = NULL;
 int nritems;
 

-rule_t *rule_table = NULL;
+rule_t *rules = NULL;

 
 struct bucket **symbols = NULL;
 short *token_translations = NULL;
 
 struct bucket **symbols = NULL;
 short *token_translations = NULL;

diff --git a/src/gram.h b/src/gram.h
index bf49c4029eea11b09ea4932f0e32ed17dda1bbe0..9e16c031f5de18b624a4d7a4ec63dc3246dbcc47 100644 (file)
--- a/src/gram.h
+++ b/src/gram.h
@@ -39,27 +39,27 @@
    written.  Actions and guards are accessed via the rule number.
 
    The rules themselves are described by several arrays: amongst which
    written.  Actions and guards are accessed via the rule number.
 
    The rules themselves are described by several arrays: amongst which

-   RITEM, and RULE_TABLE.
+   RITEM, and RULES.

 
 

-   RULE_TABLE is an array of struct rule_s, which members are:
+   RULES is an array of struct rule_s, which members are:

 
 

-   RULE_TABLE[R].lhs -- the symbol number of the left hand side of
+   RULES[R].lhs -- the symbol number of the left hand side of

    rule R.  If -1, the rule has been thrown out by reduce.c and should
    be ignored.
 
    rule R.  If -1, the rule has been thrown out by reduce.c and should
    be ignored.
 

-   RULE_TABLE[R].rhs -- the index in RITEM of the beginning of the
+   RULES[R].rhs -- the index in RITEM of the beginning of the

    portion for rule R.
 
    portion for rule R.
 

-   RULE_TABLE[R].prec -- the precedence level of R.
+   RULES[R].prec -- the precedence level of R.

 
 

-   RULE_TABLE[R].precsym -- the symbol-number of the symbol in %prec
+   RULES[R].precsym -- the symbol-number of the symbol in %prec

    for R (if any).
 
    for R (if any).
 

-   RULE_TABLE[R].assoc -- the associativity of R.
+   RULES[R].assoc -- the associativity of R.

 
 

-   RULE_TABLE[R].line -- the line where R was defined.
+   RULES[R].line -- the line where R was defined.

 
 

-   RULE_TABLE[R].useful -- TRUE iff the rule is used.
+   RULES[R].useful -- TRUE iff the rule is used.

 
    The right hand side is stored as symbol numbers in a portion of
    RITEM.
 
    The right hand side is stored as symbol numbers in a portion of
    RITEM.


@@ -128,7 +128,7 @@ typedef struct rule_s
   short guard_line;
 } rule_t;
 
   short guard_line;
 } rule_t;
 

-extern struct rule_s *rule_table;
+extern struct rule_s *rules;

 
 /* Table of the symbols, indexed by the symbol number. */
 extern struct bucket **symbols;
 
 /* Table of the symbols, indexed by the symbol number. */
 extern struct bucket **symbols;

diff --git a/src/lalr.c b/src/lalr.c
index f7fead37bd9adfe5446501aa2e3996313ddd7403..55986f33127e03c95b97b4ecfd79e60e1a8587a1 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -420,7 +420,7 @@ build_relations (void)
          state_t *state = state_table[from_state[i]];
          states[0] = state->number;
 
          state_t *state = state_table[from_state[i]];
          states[0] = state->number;
 

-         for (rp = &ritem[rule_table[*rulep].rhs]; *rp >= 0; rp++)
+         for (rp = &ritem[rules[*rulep].rhs]; *rp >= 0; rp++)

            {
              shifts *sp = state->shifts;
              int j;
            {
              shifts *sp = state->shifts;
              int j;

diff --git a/src/nullable.c b/src/nullable.c
index 082f2b3211a383fb289ef438feb85585d2c8add9..f8c9b32e5cf523b36742cb375ef0a087188ce2be 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -69,21 +69,21 @@ set_nullable (void)
   p = relts;
 
   for (ruleno = 1; ruleno < nrules + 1; ++ruleno)
   p = relts;
 
   for (ruleno = 1; ruleno < nrules + 1; ++ruleno)

-    if (rule_table[ruleno].useful)
+    if (rules[ruleno].useful)

       {
       {

-       if (ritem[rule_table[ruleno].rhs] >= 0)
+       if (ritem[rules[ruleno].rhs] >= 0)

          {
            /* This rule has a non empty RHS. */
            short *r;
            int any_tokens = 0;
          {
            /* This rule has a non empty RHS. */
            short *r;
            int any_tokens = 0;

-           for (r = &ritem[rule_table[ruleno].rhs]; *r >= 0; ++r)
+           for (r = &ritem[rules[ruleno].rhs]; *r >= 0; ++r)

              if (ISTOKEN (*r))
                any_tokens = 1;
 
            /* This rule has only nonterminals: schedule it for the second
               pass.  */
            if (!any_tokens)
              if (ISTOKEN (*r))
                any_tokens = 1;
 
            /* This rule has only nonterminals: schedule it for the second
               pass.  */
            if (!any_tokens)

-             for (r = &ritem[rule_table[ruleno].rhs]; *r >= 0; ++r)
+             for (r = &ritem[rules[ruleno].rhs]; *r >= 0; ++r)

                {
                  rcount[ruleno]++;
                  p->next = rsets[*r];
                {
                  rcount[ruleno]++;
                  p->next = rsets[*r];


@@ -95,11 +95,11 @@ set_nullable (void)
        else
          {
            /* This rule has an empty RHS. */
        else
          {
            /* This rule has an empty RHS. */

-           assert (ritem[rule_table[ruleno].rhs] == -ruleno);
-           if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
+           assert (ritem[rules[ruleno].rhs] == -ruleno);
+           if (rules[ruleno].useful && !nullable[rules[ruleno].lhs])

              {
              {

-               nullable[rule_table[ruleno].lhs] = 1;
-               *s2++ = rule_table[ruleno].lhs;
+               nullable[rules[ruleno].lhs] = 1;
+               *s2++ = rules[ruleno].lhs;

              }
          }
       }
              }
          }
       }


@@ -109,10 +109,10 @@ set_nullable (void)
       {
        ruleno = p->value;
        if (--rcount[ruleno] == 0)
       {
        ruleno = p->value;
        if (--rcount[ruleno] == 0)

-         if (rule_table[ruleno].useful && !nullable[rule_table[ruleno].lhs])
+         if (rules[ruleno].useful && !nullable[rules[ruleno].lhs])

            {
            {

-             nullable[rule_table[ruleno].lhs] = 1;
-             *s2++ = rule_table[ruleno].lhs;
+             nullable[rules[ruleno].lhs] = 1;
+             *s2++ = rules[ruleno].lhs;

            }
       }
 
            }
       }
 

diff --git a/src/output.c b/src/output.c
index 37ce24cf89688fd58bd2d6012ac3faeed61476a6..3a8bc9949f4a32f22b7a967f627c18cb30d0a214 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -185,7 +185,7 @@ output_gram (void)
     int i;
     short *values = XCALLOC (short, nrules + 1);
     for (i = 0; i < nrules + 1; ++i)
     int i;
     short *values = XCALLOC (short, nrules + 1);
     for (i = 0; i < nrules + 1; ++i)

-      values[i] = rule_table[i].rhs;
+      values[i] = rules[i].rhs;

     output_table_data (&format_obstack, values,
                       0, 1, nrules + 1);
     XFREE (values);
     output_table_data (&format_obstack, values,
                       0, 1, nrules + 1);
     XFREE (values);


@@ -239,7 +239,7 @@ output_rule_data (void)
   {
     short *values = XCALLOC (short, nrules + 1);
     for (i = 0; i < nrules + 1; ++i)
   {
     short *values = XCALLOC (short, nrules + 1);
     for (i = 0; i < nrules + 1; ++i)

-      values[i] = rule_table[i].line;
+      values[i] = rules[i].line;

     output_table_data (&format_obstack, values,
                       0, 1, nrules + 1);
     muscle_insert ("rline", obstack_finish (&format_obstack));
     output_table_data (&format_obstack, values,
                       0, 1, nrules + 1);
     muscle_insert ("rline", obstack_finish (&format_obstack));


@@ -291,7 +291,7 @@ output_rule_data (void)
   {
     short *values = XCALLOC (short, nrules + 1);
     for (i = 0; i < nrules + 1; ++i)
   {
     short *values = XCALLOC (short, nrules + 1);
     for (i = 0; i < nrules + 1; ++i)

-      values[i] = rule_table[i].lhs;
+      values[i] = rules[i].lhs;

     output_table_data (&format_obstack, values,
                       0, 1, nrules + 1);
     muscle_insert ("r1", obstack_finish (&format_obstack));
     output_table_data (&format_obstack, values,
                       0, 1, nrules + 1);
     muscle_insert ("r1", obstack_finish (&format_obstack));


@@ -301,8 +301,8 @@ output_rule_data (void)
   /* Output YYR2. */
   short_tab = XMALLOC (short, nrules + 1);
   for (i = 1; i < nrules; i++)
   /* Output YYR2. */
   short_tab = XMALLOC (short, nrules + 1);
   for (i = 1; i < nrules; i++)

-    short_tab[i] = rule_table[i + 1].rhs - rule_table[i].rhs - 1;
-  short_tab[nrules] =  nritems - rule_table[nrules].rhs - 1;
+    short_tab[i] = rules[i + 1].rhs - rules[i].rhs - 1;
+  short_tab[nrules] =  nritems - rules[nrules].rhs - 1;

   output_table_data (&format_obstack, short_tab,
                     0, 1, nrules + 1);
   muscle_insert ("r2", obstack_finish (&format_obstack));
   output_table_data (&format_obstack, short_tab,
                     0, 1, nrules + 1);
   muscle_insert ("r2", obstack_finish (&format_obstack));


@@ -508,20 +508,20 @@ actions_output (FILE *out, size_t *line)
 {
   int rule;
   for (rule = 1; rule < nrules + 1; ++rule)
 {
   int rule;
   for (rule = 1; rule < nrules + 1; ++rule)

-    if (rule_table[rule].action)
+    if (rules[rule].action)

       {
        fprintf (out, "  case %d:\n", rule);
 
        if (!no_lines_flag)
          fprintf (out, muscle_find ("linef"),
       {
        fprintf (out, "  case %d:\n", rule);
 
        if (!no_lines_flag)
          fprintf (out, muscle_find ("linef"),

-                  rule_table[rule].action_line,
+                  rules[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",
                   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,
+                rules[rule].action,

                 yacc_flag ? ";" : "");
 
        /* We always output 4 '\n' per action.  */
                 yacc_flag ? ";" : "");
 
        /* We always output 4 '\n' per action.  */


@@ -530,7 +530,7 @@ actions_output (FILE *out, size_t *line)
        if (!no_lines_flag)
          ++*line;
        /* Get the number of lines written by the user.  */
        if (!no_lines_flag)
          ++*line;
        /* Get the number of lines written by the user.  */

-       *line += get_lines_number (rule_table[rule].action);
+       *line += get_lines_number (rules[rule].action);

       }
 }
 
       }
 }
 


@@ -544,17 +544,17 @@ guards_output (FILE *out, size_t *line)
 {
   int rule;
   for (rule = 1; rule < nrules + 1; ++rule)
 {
   int rule;
   for (rule = 1; rule < nrules + 1; ++rule)

-    if (rule_table[rule].action)
+    if (rules[rule].action)

       {
        fprintf (out, "  case %d:\n", rule);
 
        if (!no_lines_flag)
          fprintf (out, muscle_find ("linef"),
       {
        fprintf (out, "  case %d:\n", rule);
 
        if (!no_lines_flag)
          fprintf (out, muscle_find ("linef"),

-                  rule_table[rule].guard_line,
+                  rules[rule].guard_line,

                   quotearg_style (c_quoting_style,
                                   muscle_find ("filename")));
        fprintf (out, "{ %s; }\n    break;\n\n",
                   quotearg_style (c_quoting_style,
                                   muscle_find ("filename")));
        fprintf (out, "{ %s; }\n    break;\n\n",

-                rule_table[rule].guard);
+                rules[rule].guard);

 
        /* We always output 4 '\n' per action.  */
        *line += 4;
 
        /* We always output 4 '\n' per action.  */
        *line += 4;


@@ -562,7 +562,7 @@ guards_output (FILE *out, size_t *line)
        if (!no_lines_flag)
          ++*line;
        /* Get the number of lines written by the user.  */
        if (!no_lines_flag)
          ++*line;
        /* Get the number of lines written by the user.  */

-       *line += get_lines_number (rule_table[rule].guard);
+       *line += get_lines_number (rules[rule].guard);

       }
 }
 
       }
 }
 


@@ -1122,7 +1122,7 @@ output (void)
   if (defines_flag)
     header_output ();
 
   if (defines_flag)
     header_output ();
 

-  free (rule_table + 1);
+  free (rules + 1);

   obstack_free (&muscle_obstack, NULL);
   obstack_free (&format_obstack, NULL);
   obstack_free (&action_obstack, NULL);
   obstack_free (&muscle_obstack, NULL);
   obstack_free (&format_obstack, NULL);
   obstack_free (&action_obstack, NULL);

diff --git a/src/print.c b/src/print.c
index 96c59fc70b0d8d262ae83fd53379649bf6523b60..5a417d320f395dca180945f6806a974f3bf97101 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -93,9 +93,9 @@ print_core (FILE *out, state_t *state)
            sp++;
 
          rule = -(*sp);
            sp++;
 
          rule = -(*sp);

-         fprintf (out, "    %s  ->  ", escape (symbols[rule_table[rule].lhs]->tag));
+         fprintf (out, "    %s  ->  ", escape (symbols[rules[rule].lhs]->tag));

 
 

-         for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
+         for (sp = ritem + rules[rule].rhs; sp < sp1; sp++)

            fprintf (out, "%s ", escape (symbols[*sp]->tag));
 
          fputc ('.', out);
            fprintf (out, "%s ", escape (symbols[*sp]->tag));
 
          fputc ('.', out);


@@ -188,7 +188,7 @@ print_reductions (FILE *out, state_t *state)
   if (state->consistent)
     {
       int rule = redp->rules[0];
   if (state->consistent)
     {
       int rule = redp->rules[0];

-      int symbol = rule_table[rule].lhs;
+      int symbol = rules[rule].lhs;

       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
               rule - 1, escape (symbols[symbol]->tag));
       return;
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
               rule - 1, escape (symbols[symbol]->tag));
       return;


@@ -223,10 +223,10 @@ print_reductions (FILE *out, state_t *state)
        if (BITISSET (lookaheadset, i))
          fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
                   escape (symbols[i]->tag), default_rule - 1,
        if (BITISSET (lookaheadset, i))
          fprintf (out, _("    %-4s\t[reduce using rule %d (%s)]\n"),
                   escape (symbols[i]->tag), default_rule - 1,

-                  escape2 (symbols[rule_table[default_rule].lhs]->tag));
+                  escape2 (symbols[rules[default_rule].lhs]->tag));

 
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),
 
       fprintf (out, _("    $default\treduce using rule %d (%s)\n\n"),

-              default_rule - 1, escape (symbols[rule_table[default_rule].lhs]->tag));
+              default_rule - 1, escape (symbols[rules[default_rule].lhs]->tag));

     }
   else if (state->nlookaheads >= 1)
     {
     }
   else if (state->nlookaheads >= 1)
     {


@@ -282,7 +282,7 @@ print_reductions (FILE *out, state_t *state)
                                 _("    %-4s\treduce using rule %d (%s)\n"),
                                 escape (symbols[i]->tag),
                                 LAruleno[state->lookaheadsp + j] - 1,
                                 _("    %-4s\treduce using rule %d (%s)\n"),
                                 escape (symbols[i]->tag),
                                 LAruleno[state->lookaheadsp + j] - 1,

-                                escape2 (symbols[rule_table[LAruleno[state->lookaheadsp + j]].lhs]->tag));
+                                escape2 (symbols[rules[LAruleno[state->lookaheadsp + j]].lhs]->tag));

                      else
                        defaulted = 1;
 
                      else
                        defaulted = 1;
 


@@ -295,13 +295,13 @@ print_reductions (FILE *out, state_t *state)
                                 _("    %-4s\treduce using rule %d (%s)\n"),
                                 escape (symbols[i]->tag),
                                 LAruleno[default_LA] - 1,
                                 _("    %-4s\treduce using rule %d (%s)\n"),
                                 escape (symbols[i]->tag),
                                 LAruleno[default_LA] - 1,

-                                escape2 (symbols[rule_table[LAruleno[default_LA]].lhs]->tag));
+                                escape2 (symbols[rules[LAruleno[default_LA]].lhs]->tag));

                      defaulted = 0;
                      fprintf (out,
                               _("    %-4s\t[reduce using rule %d (%s)]\n"),
                               escape (symbols[i]->tag),
                               LAruleno[state->lookaheadsp + j] - 1,
                      defaulted = 0;
                      fprintf (out,
                               _("    %-4s\t[reduce using rule %d (%s)]\n"),
                               escape (symbols[i]->tag),
                               LAruleno[state->lookaheadsp + j] - 1,

-                              escape2 (symbols[rule_table[LAruleno[state->lookaheadsp + j]].lhs]->tag));
+                              escape2 (symbols[rules[LAruleno[state->lookaheadsp + j]].lhs]->tag));

                    }
                }
            }
                    }
                }
            }


@@ -310,7 +310,7 @@ print_reductions (FILE *out, state_t *state)
       if (default_LA >= 0)
        fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
                 default_rule - 1,
       if (default_LA >= 0)
        fprintf (out, _("    $default\treduce using rule %d (%s)\n"),
                 default_rule - 1,

-                escape (symbols[rule_table[default_rule].lhs]->tag));
+                escape (symbols[rules[default_rule].lhs]->tag));

     }
 }
 
     }
 }
 


@@ -374,11 +374,11 @@ print_grammar (FILE *out)
   fprintf (out, "  %s\n", _("Number, Line, Rule"));
   for (i = 1; i <= nrules; i++)
     /* Don't print rules disabled in reduce_grammar_tables.  */
   fprintf (out, "  %s\n", _("Number, Line, Rule"));
   for (i = 1; i <= nrules; i++)
     /* Don't print rules disabled in reduce_grammar_tables.  */

-    if (rule_table[i].useful)
+    if (rules[i].useful)

       {
        fprintf (out, _("  %3d %3d %s ->"),
       {
        fprintf (out, _("  %3d %3d %s ->"),

-                i - 1, rule_table[i].line, escape (symbols[rule_table[i].lhs]->tag));
-       rule = &ritem[rule_table[i].rhs];
+                i - 1, rules[i].line, escape (symbols[rules[i].lhs]->tag));
+       rule = &ritem[rules[i].rhs];

        if (*rule >= 0)
          while (*rule >= 0)
            fprintf (out, " %s", escape (symbols[*rule++]->tag));
        if (*rule >= 0)
          while (*rule >= 0)
            fprintf (out, " %s", escape (symbols[*rule++]->tag));


@@ -401,7 +401,7 @@ print_grammar (FILE *out)
        sprintf (buffer, " (%d)", i);
 
        for (j = 1; j <= nrules; j++)
        sprintf (buffer, " (%d)", i);
 
        for (j = 1; j <= nrules; j++)

-         for (rule = &ritem[rule_table[j].rhs]; *rule >= 0; rule++)
+         for (rule = &ritem[rules[j].rhs]; *rule >= 0; rule++)

            if (*rule == token_translations[i])
              {
                END_TEST (65);
            if (*rule == token_translations[i])
              {
                END_TEST (65);


@@ -420,9 +420,9 @@ print_grammar (FILE *out)
 
       for (j = 1; j <= nrules; j++)
        {
 
       for (j = 1; j <= nrules; j++)
        {

-         if (rule_table[j].lhs == i)
+         if (rules[j].lhs == i)

            left_count++;
            left_count++;

-         for (rule = &ritem[rule_table[j].rhs]; *rule >= 0; rule++)
+         for (rule = &ritem[rules[j].rhs]; *rule >= 0; rule++)

            if (*rule == i)
              {
                right_count++;
            if (*rule == i)
              {
                right_count++;


@@ -444,7 +444,7 @@ print_grammar (FILE *out)
          for (j = 1; j <= nrules; j++)
            {
              END_TEST (65);
          for (j = 1; j <= nrules; j++)
            {
              END_TEST (65);

-             if (rule_table[j].lhs == i)
+             if (rules[j].lhs == i)

                sprintf (buffer + strlen (buffer), " %d", j - 1);
            }
        }
                sprintf (buffer + strlen (buffer), " %d", j - 1);
            }
        }


@@ -457,7 +457,7 @@ print_grammar (FILE *out)
          sprintf (buffer + strlen (buffer), _(" on right:"));
          for (j = 1; j <= nrules; j++)
            {
          sprintf (buffer + strlen (buffer), _(" on right:"));
          for (j = 1; j <= nrules; j++)
            {

-             for (rule = &ritem[rule_table[j].rhs]; *rule >= 0; rule++)
+             for (rule = &ritem[rules[j].rhs]; *rule >= 0; rule++)

                if (*rule == i)
                  {
                    END_TEST (65);
                if (*rule == i)
                  {
                    END_TEST (65);

diff --git a/src/print_graph.c b/src/print_graph.c
index dd271d78bfbc16a1976bbfb4ef0689d17e28169e..d32e5520351e8b9f732674b99d1da258fb848c1f 100644 (file)
--- a/src/print_graph.c
+++ b/src/print_graph.c
@@ -78,9 +78,9 @@ print_core (state_t *state, struct obstack *node_obstack)
       if (i)
        obstack_1grow (node_obstack, '\n');
       obstack_fgrow1 (node_obstack, " %s -> ",
       if (i)
        obstack_1grow (node_obstack, '\n');
       obstack_fgrow1 (node_obstack, " %s -> ",

-                     escape (symbols[rule_table[rule].lhs]->tag));
+                     escape (symbols[rules[rule].lhs]->tag));

 
 

-      for (sp = ritem + rule_table[rule].rhs; sp < sp1; sp++)
+      for (sp = ritem + rules[rule].rhs; sp < sp1; sp++)

        obstack_fgrow1 (node_obstack, "%s ", escape (symbols[*sp]->tag));
 
       obstack_1grow (node_obstack, '.');
        obstack_fgrow1 (node_obstack, "%s ", escape (symbols[*sp]->tag));
 
       obstack_1grow (node_obstack, '.');

diff --git a/src/reader.c b/src/reader.c
index 527194e06ea2a3c8f99f0b234c00a65461907680..d76bd6feea7a6a71c7b7642d781026e9b95d1048 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -1720,7 +1720,7 @@ packgram (void)
     fatal (_("too many items (max %d)"), MAXSHORT);
 
   ritem = XCALLOC (short, nitems + 1);
     fatal (_("too many items (max %d)"), MAXSHORT);
 
   ritem = XCALLOC (short, nitems + 1);

-  rule_table = XCALLOC (rule_t, nrules) - 1;
+  rules = XCALLOC (rule_t, nrules) - 1;

 
   itemno = 0;
   ruleno = 1;
 
   itemno = 0;
   ruleno = 1;


@@ -1729,14 +1729,14 @@ packgram (void)
   while (p)
     {
       bucket *ruleprec = p->ruleprec;
   while (p)
     {
       bucket *ruleprec = p->ruleprec;

-      rule_table[ruleno].lhs = p->sym->value;
-      rule_table[ruleno].rhs = itemno;
-      rule_table[ruleno].line = p->line;
-      rule_table[ruleno].useful = TRUE;
-      rule_table[ruleno].action = p->action;
-      rule_table[ruleno].action_line = p->action_line;
-      rule_table[ruleno].guard = p->guard;
-      rule_table[ruleno].guard_line = p->guard_line;
+      rules[ruleno].lhs = p->sym->value;
+      rules[ruleno].rhs = itemno;
+      rules[ruleno].line = p->line;
+      rules[ruleno].useful = TRUE;
+      rules[ruleno].action = p->action;
+      rules[ruleno].action_line = p->action_line;
+      rules[ruleno].guard = p->guard;
+      rules[ruleno].guard_line = p->guard_line;

 
       p = p->next;
       while (p && p->sym)
 
       p = p->next;
       while (p && p->sym)


@@ -1746,8 +1746,8 @@ packgram (void)
             of the last token in it.  */
          if (p->sym->class == token_sym)
            {
             of the last token in it.  */
          if (p->sym->class == token_sym)
            {

-             rule_table[ruleno].prec = p->sym->prec;
-             rule_table[ruleno].assoc = p->sym->assoc;
+             rules[ruleno].prec = p->sym->prec;
+             rules[ruleno].assoc = p->sym->assoc;

            }
          if (p)
            p = p->next;
            }
          if (p)
            p = p->next;


@@ -1757,9 +1757,9 @@ packgram (void)
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {
          the specified symbol's precedence replaces the default.  */
       if (ruleprec)
        {

-         rule_table[ruleno].prec = ruleprec->prec;
-         rule_table[ruleno].assoc = ruleprec->assoc;
-         rule_table[ruleno].precsym = ruleprec->value;
+         rules[ruleno].prec = ruleprec->prec;
+         rules[ruleno].assoc = ruleprec->assoc;
+         rules[ruleno].precsym = ruleprec->value;

        }
 
       ritem[itemno++] = -ruleno;
        }
 
       ritem[itemno++] = -ruleno;

diff --git a/src/reduce.c b/src/reduce.c
index 83909619ab296456dbf64a7c0a28bdefd4926f8e..c4a2bd1c713458e69204ae2f8e33e82912ffd824 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -108,7 +108,7 @@ useful_production (int i, BSet N0)
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 
   /* A production is useful if all of the nonterminals in its appear
      in the set of useful nonterminals.  */
 

-  for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
+  for (r = &ritem[rules[i].rhs]; *r >= 0; r++)

     if (ISVAR (n = *r))
       if (!BITISSET (N0, n - ntokens))
        return FALSE;
     if (ISVAR (n = *r))
       if (!BITISSET (N0, n - ntokens))
        return FALSE;


@@ -157,7 +157,7 @@ useless_nonterminals (void)
            {
              if (useful_production (i, N))
                {
            {
              if (useful_production (i, N))
                {

-                 SETBIT (Np, rule_table[i].lhs - ntokens);
+                 SETBIT (Np, rules[i].lhs - ntokens);

                  SETBIT (P, i);
                }
            }
                  SETBIT (P, i);
                }
            }


@@ -220,9 +220,9 @@ inaccessable_symbols (void)
            {
              if (!BITISSET (Pp, i)
                  && BITISSET (P, i)
            {
              if (!BITISSET (Pp, i)
                  && BITISSET (P, i)

-                 && BITISSET (V, rule_table[i].lhs))
+                 && BITISSET (V, rules[i].lhs))

                {
                {

-                 for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
+                 for (r = &ritem[rules[i].rhs]; *r >= 0; r++)

                    if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
                      SETBIT (Vp, t);
                  SETBIT (Pp, i);
                    if (ISTOKEN (t = *r) || BITISSET (N, t - ntokens))
                      SETBIT (Vp, t);
                  SETBIT (Pp, i);


@@ -258,8 +258,8 @@ inaccessable_symbols (void)
 
   /* A token that was used in %prec should not be warned about.  */
   for (i = 1; i < nrules; i++)
 
   /* A token that was used in %prec should not be warned about.  */
   for (i = 1; i < nrules; i++)

-    if (rule_table[i].precsym != 0)
-      SETBIT (V1, rule_table[i].precsym);
+    if (rules[i].precsym != 0)
+      SETBIT (V1, rules[i].precsym);

 }
 
 static void
 }
 
 static void


@@ -289,15 +289,15 @@ reduce_grammar_tables (void)
              np++;
              if (pn != np)
                {
              np++;
              if (pn != np)
                {

-                 rule_table[np].lhs   = rule_table[pn].lhs;
-                 rule_table[np].line  = rule_table[pn].line;
-                 rule_table[np].prec  = rule_table[pn].prec;
-                 rule_table[np].assoc = rule_table[pn].assoc;
-                 rule_table[np].rhs   = rule_table[pn].rhs;
-                 if (rule_table[np].rhs != ni)
+                 rules[np].lhs   = rules[pn].lhs;
+                 rules[np].line  = rules[pn].line;
+                 rules[np].prec  = rules[pn].prec;
+                 rules[np].assoc = rules[pn].assoc;
+                 rules[np].rhs   = rules[pn].rhs;
+                 if (rules[np].rhs != ni)

                    {
                    {

-                     pi = rule_table[np].rhs;
-                     rule_table[np].rhs = ni;
+                     pi = rules[np].rhs;
+                     rules[np].rhs = ni;

                      while (ritem[pi] >= 0)
                        ritem[ni++] = ritem[pi++];
                      ritem[ni++] = -np;
                      while (ritem[pi] >= 0)
                        ritem[ni++] = ritem[pi++];
                      ritem[ni++] = -np;


@@ -324,7 +324,7 @@ reduce_grammar_tables (void)
     {
       int pn;
       for (pn = 1; pn <= nrules; pn++)
     {
       int pn;
       for (pn = 1; pn <= nrules; pn++)

-       rule_table[pn].useful = BITISSET (P, pn);
+       rules[pn].useful = BITISSET (P, pn);

     }
 }
 
     }
 }
 


@@ -367,10 +367,10 @@ nonterminals_reduce (void)
 
   for (i = 1; i <= nrules; i++)
     {
 
   for (i = 1; i <= nrules; i++)
     {

-      rule_table[i].lhs = nontermmap[rule_table[i].lhs];
-      if (ISVAR (rule_table[i].precsym))
+      rules[i].lhs = nontermmap[rules[i].lhs];
+      if (ISVAR (rules[i].precsym))

        /* Can this happen?  */
        /* Can this happen?  */

-       rule_table[i].precsym = nontermmap[rule_table[i].precsym];
+       rules[i].precsym = nontermmap[rules[i].precsym];

     }
 
   for (i = 0; i < nritems; ++i)
     }
 
   for (i = 0; i < nritems; ++i)


@@ -422,12 +422,12 @@ reduce_output (FILE *out)
       int i;
       fprintf (out, "%s\n\n", _("Useless rules:"));
       for (i = 1; i <= nrules; i++)
       int i;
       fprintf (out, "%s\n\n", _("Useless rules:"));
       for (i = 1; i <= nrules; i++)

-       if (!rule_table[i].useful)
+       if (!rules[i].useful)

          {
            rule r;
            fprintf (out, "#%-4d  ", i - 1);
          {
            rule r;
            fprintf (out, "#%-4d  ", i - 1);

-           fprintf (out, "%s:", symbols[rule_table[i].lhs]->tag);
-           for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
+           fprintf (out, "%s:", symbols[rules[i].lhs]->tag);
+           for (r = &ritem[rules[i].rhs]; *r >= 0; r++)

              fprintf (out, " %s", symbols[*r]->tag);
            fputs (";\n", out);
          }
              fprintf (out, " %s", symbols[*r]->tag);
            fputs (";\n", out);
          }


@@ -458,15 +458,15 @@ dump_grammar (FILE *out)
     {
       int rhs_count = 0;
       /* Find the last RHS index in ritems. */
     {
       int rhs_count = 0;
       /* Find the last RHS index in ritems. */

-      for (r = &ritem[rule_table[i].rhs]; *r >= 0; ++r)
+      for (r = &ritem[rules[i].rhs]; *r >= 0; ++r)

        ++rhs_count;
       fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
               i - 1,
        ++rhs_count;
       fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
               i - 1,

-              rule_table[i].prec, rule_table[i].assoc, rule_table[i].useful,
-              rule_table[i].rhs, rule_table[i].rhs + rhs_count - 1,
-              rule_table[i].lhs);
+              rules[i].prec, rules[i].assoc, rules[i].useful,
+              rules[i].rhs, rules[i].rhs + rhs_count - 1,
+              rules[i].lhs);

       /* Dumped the RHS. */
       /* Dumped the RHS. */

-      for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
+      for (r = &ritem[rules[i].rhs]; *r >= 0; r++)

        fprintf (out, "%3d", *r);
       fprintf (out, "  [%d]\n", -(*r) - 1);
     }
        fprintf (out, "%3d", *r);
       fprintf (out, "  [%d]\n", -(*r) - 1);
     }


@@ -474,8 +474,8 @@ dump_grammar (FILE *out)
   fprintf (out, "Rules interpreted\n-----------------\n\n");
   for (i = 1; i <= nrules; i++)
     {
   fprintf (out, "Rules interpreted\n-----------------\n\n");
   for (i = 1; i <= nrules; i++)
     {

-      fprintf (out, "%-5d  %s :", i, symbols[rule_table[i].lhs]->tag);
-      for (r = &ritem[rule_table[i].rhs]; *r >= 0; r++)
+      fprintf (out, "%-5d  %s :", i, symbols[rules[i].lhs]->tag);
+      for (r = &ritem[rules[i].rhs]; *r >= 0; r++)

        fprintf (out, " %s", symbols[*r]->tag);
       fputc ('\n', out);
     }
        fprintf (out, " %s", symbols[*r]->tag);
       fputc ('\n', out);
     }