Stop storing rules from 1 to nrules + 1.

* src/LR0.c, src/closure.c, src/derives.c, src/gram.c, src/lalr.c
* src/nullable.c, src/output.c, src/print.c, src/reader.c
* src/reduce.c: Allocate and free from &rules[0], not &rules[1].
Iterate from 0 to nrules.
Use rule_number_as_item_number and item_number_as_rule_number.
Adjust to `derive' now containing possibly 0.
* src/gram.h (rule_number_as_item_number, item_number_as_rule_number):
Handle the `- 1' part in rule numbers from/to item numbers.
* src/conflicts.c (log_resolution): Fix the message which reversed
shift and reduce.
* src/output.c (action_row): Initialize default_rule to -1.
(token_actions): Adjust.
* tests/sets.at (Nullable, Firsts): Fix the previously bogus
expected output.
* tests/conflicts.at (Resolved SR Conflicts): Likewise.

diff --git a/ChangeLog b/ChangeLog
index 2313d099231483e2728ba7cc61a0876ea6d62845..2f34da0b4dcedc6083a4522bce009b59ee3ee709 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,23 @@
+2002-07-25  Akim Demaille  <akim@epita.fr>
+
+       Stop storing rules from 1 to nrules + 1.
+
+       * src/LR0.c, src/closure.c, src/derives.c, src/gram.c, src/lalr.c
+       * src/nullable.c, src/output.c, src/print.c, src/reader.c
+       * src/reduce.c: Allocate and free from &rules[0], not &rules[1].
+       Iterate from 0 to nrules.
+       Use rule_number_as_item_number and item_number_as_rule_number.
+       Adjust to `derive' now containing possibly 0.
+       * src/gram.h (rule_number_as_item_number, item_number_as_rule_number):
+       Handle the `- 1' part in rule numbers from/to item numbers.
+       * src/conflicts.c (log_resolution): Fix the message which reversed
+       shift and reduce.
+       * src/output.c (action_row): Initialize default_rule to -1.
+       (token_actions): Adjust.
+       * tests/sets.at (Nullable, Firsts): Fix the previously bogus
+       expected output.
+       * tests/conflicts.at (Resolved SR Conflicts): Likewise.
+

 2002-07-25  Akim Demaille  <akim@epita.fr>
 
        * data/c.m4 (b4_c_function, b4_c_ansi_args, b4_c_ansi_arg)
 2002-07-25  Akim Demaille  <akim@epita.fr>
 
        * data/c.m4 (b4_c_function, b4_c_ansi_args, b4_c_ansi_arg)

diff --git a/src/LR0.c b/src/LR0.c
index a7a62e5921478a59858eeef62047f9abad25c77b..80f69a9eda9af33cacdba037daf4415d4e1b65fb 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -105,7 +105,7 @@ allocate_itemsets (void)
   int count = 0;
   short *symbol_count = XCALLOC (short, nsyms + nuseless_nonterminals);
 
   int count = 0;
   short *symbol_count = XCALLOC (short, nsyms + nuseless_nonterminals);
 

-  for (r = 1; r < nrules + 1; ++r)
+  for (r = 0; r < nrules; ++r)

     for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
       {
        count++;
     for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
       {
        count++;


@@ -140,7 +140,7 @@ allocate_storage (void)
   allocate_itemsets ();
 
   shiftset = XCALLOC (state_number_t, nsyms);
   allocate_itemsets ();
 
   shiftset = XCALLOC (state_number_t, nsyms);

-  redset = XCALLOC (short, nrules + 1);
+  redset = XCALLOC (short, nrules);

   state_hash_new ();
   shift_symbol = XCALLOC (symbol_number_t, nsyms);
 }
   state_hash_new ();
   shift_symbol = XCALLOC (symbol_number_t, nsyms);
 }


@@ -233,7 +233,7 @@ get_state (symbol_number_t symbol, size_t core_size, item_number_t *core)
 | Use the information computed by new_itemsets to find the state    |
 | numbers reached by each shift transition from STATE.              |
 |                                                                   |
 | Use the information computed by new_itemsets to find the state    |
 | numbers reached by each shift transition from STATE.              |
 |                                                                   |

-| TRANSITIONSET is set up as a vector of state numbers of those states.  |
+| SHIFTSET is set up as a vector of state numbers of those states.  |

 `------------------------------------------------------------------*/
 
 static void
 `------------------------------------------------------------------*/
 
 static void


@@ -292,7 +292,7 @@ save_reductions (state_t *state)
     {
       int item = ritem[itemset[i]];
       if (item < 0)
     {
       int item = ritem[itemset[i]];
       if (item < 0)

-       redset[count++] = -item;
+       redset[count++] = item_number_as_rule_number (item);

     }
 
   /* Make a reductions structure and copy the data into it.  */
     }
 
   /* Make a reductions structure and copy the data into it.  */

diff --git a/src/closure.c b/src/closure.c
index 33dd9b7a4b7e719ce09c189adb94137fdd2cedc0..70ecab1189b8e2d323619fd7a2028573b953a197 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -158,14 +158,14 @@ set_fderives (void)
   symbol_number_t i, j;
   rule_number_t k;
 
   symbol_number_t i, j;
   rule_number_t k;
 

-  fderives = bitsetv_create (nvars, nrules + 1, BITSET_FIXED);
+  fderives = bitsetv_create (nvars, nrules, BITSET_FIXED);

 
   set_firsts ();
 
   for (i = ntokens; i < nsyms; ++i)
     for (j = ntokens; j < nsyms; ++j)
       if (bitset_test (FIRSTS (i), j - ntokens))
 
   set_firsts ();
 
   for (i = ntokens; i < nsyms; ++i)
     for (j = ntokens; j < nsyms; ++j)
       if (bitset_test (FIRSTS (i), j - ntokens))

-       for (k = 0; derives[j][k] > 0; ++k)
+       for (k = 0; derives[j][k] >= 0; ++k)

          bitset_set (FDERIVES (i), derives[j][k]);
 
   if (trace_flag)
          bitset_set (FDERIVES (i), derives[j][k]);
 
   if (trace_flag)


@@ -181,7 +181,7 @@ new_closure (int n)
 {
   itemset = XCALLOC (item_number_t, n);
 
 {
   itemset = XCALLOC (item_number_t, n);
 

-  ruleset = bitset_create (nrules + 1, BITSET_FIXED);
+  ruleset = bitset_create (nrules, BITSET_FIXED);

 
   set_fderives ();
 }
 
   set_fderives ();
 }

diff --git a/src/conflicts.c b/src/conflicts.c
index 825f76407e1fb3652b73fb931f4e3d45cd55985e..55468fd2b8efb56da25f4835222f95e03d75ea8a 100644 (file)
--- a/src/conflicts.c
+++ b/src/conflicts.c
@@ -67,7 +67,7 @@ log_resolution (rule_t *rule, symbol_number_t token,
       switch (resolution)
        {
        case shift_resolution:
       switch (resolution)
        {
        case shift_resolution:

-       case left_resolution:
+       case right_resolution:

          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as shift"),
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as shift"),


@@ -75,7 +75,7 @@ log_resolution (rule_t *rule, symbol_number_t token,
                          symbols[token]->tag);
          break;
        case reduce_resolution:
                          symbols[token]->tag);
          break;
        case reduce_resolution:

-       case right_resolution:
+       case left_resolution:

          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as reduce"),
          obstack_fgrow2 (&solved_conflicts_obstack,
                          _("\
     Conflict between rule %d and token %s resolved as reduce"),

diff --git a/src/derives.c b/src/derives.c
index 456dfb2202e4e095488fe153c5149ec8353e79a4..f88b7002426eb29f0a77670be3080efcf4078a29 100644 (file)
--- a/src/derives.c
+++ b/src/derives.c
@@ -46,9 +46,9 @@ print_derives (void)
     {
       rule_number_t *rp;
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);
     {
       rule_number_t *rp;
       fprintf (stderr, "\t%s derives\n", symbols[i]->tag);

-      for (rp = derives[i]; *rp > 0; rp++)
+      for (rp = derives[i]; *rp >= 0; rp++)

        {
        {

-         fprintf (stderr, "\t\t%3d ", *rp - 1);
+         fprintf (stderr, "\t\t%3d ", *rp);

          rule_rhs_print (&rules[*rp], stderr);
        }
     }
          rule_rhs_print (&rules[*rp], stderr);
        }
     }


@@ -61,7 +61,7 @@ void
 set_derives (void)
 {
   symbol_number_t i;
 set_derives (void)
 {
   symbol_number_t i;

-  rule_number_t r;
+  int r;

   rule_number_t *q;
 
   /* DSET[NTERM] -- A linked list of the numbers of the rules whose
   rule_number_t *q;
 
   /* DSET[NTERM] -- A linked list of the numbers of the rules whose


@@ -71,9 +71,9 @@ set_derives (void)
   /* DELTS[RULE] -- There are NRULES rule number to attach to nterms.
      Instead of performing NRULES allocations for each, have an array
      indexed by rule numbers.  */
   /* DELTS[RULE] -- There are NRULES rule number to attach to nterms.
      Instead of performing NRULES allocations for each, have an array
      indexed by rule numbers.  */

-  rule_list_t *delts = XCALLOC (rule_list_t, nrules + 1);
+  rule_list_t *delts = XCALLOC (rule_list_t, nrules);

 
 

-  for (r = nrules; r > 0; r--)
+  for (r = nrules - 1; r >= 0; --r)

     {
       symbol_number_t lhs = rules[r].lhs->number;
       rule_list_t *p = &delts[r];
     {
       symbol_number_t lhs = rules[r].lhs->number;
       rule_list_t *p = &delts[r];

diff --git a/src/gram.c b/src/gram.c
index 51aa94844dbd39dcb3a7c56510bc7416b2df8090..c28f5b5ed2d1abbb319837f9278035d1d2e8a29f 100644 (file)
--- a/src/gram.c
+++ b/src/gram.c
@@ -56,7 +56,7 @@ int pure_parser = 0;
 void
 rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
 {
 void
 rule_lhs_print (rule_t *rule, symbol_t *previous_lhs, FILE *out)
 {

-  fprintf (out, "  %3d ", rule->number - 1);
+  fprintf (out, "  %3d ", rule->number);

   if (previous_lhs != rule->lhs)
     {
       fprintf (out, "%s:", rule->lhs->tag);
   if (previous_lhs != rule->lhs)
     {
       fprintf (out, "%s:", rule->lhs->tag);


@@ -132,7 +132,7 @@ ritem_print (FILE *out)
     if (ritem[i] >= 0)
       fprintf (out, "  %s", symbols[ritem[i]]->tag);
     else
     if (ritem[i] >= 0)
       fprintf (out, "  %s", symbols[ritem[i]]->tag);
     else

-      fprintf (out, "  (rule %d)\n", -ritem[i] - 1);
+      fprintf (out, "  (rule %d)\n", item_number_as_rule_number (ritem[i]));

   fputs ("\n\n", out);
 }
 
   fputs ("\n\n", out);
 }
 


@@ -147,7 +147,7 @@ ritem_longest_rhs (void)
   int max = 0;
   rule_number_t r;
 
   int max = 0;
   rule_number_t r;
 

-  for (r = 1; r < nrules + 1; ++r)
+  for (r = 0; r < nrules; ++r)

     {
       int length = rule_rhs_length (&rules[r]);
       if (length > max)
     {
       int length = rule_rhs_length (&rules[r]);
       if (length > max)


@@ -191,7 +191,7 @@ grammar_rules_partial_print (FILE *out, const char *title,
 void
 grammar_rules_print (FILE *out)
 {
 void
 grammar_rules_print (FILE *out)
 {

-  grammar_rules_partial_print (out, _("Grammar"), 1, nrules + 1);
+  grammar_rules_partial_print (out, _("Grammar"), 0, nrules);

 }
 
 
 }
 
 


@@ -225,7 +225,7 @@ grammar_dump (FILE *out, const char *title)
   {
     rule_number_t i;
     fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");
   {
     rule_number_t i;
     fprintf (out, "Num (Prec, Assoc, Useful, Ritem Range) Lhs -> Rhs (Ritem range) [Num]\n");

-    for (i = 1; i < nrules + nuseless_productions + 1; i++)
+    for (i = 0; i < nrules + nuseless_productions; i++)

       {
        rule_t *rule = &rules[i];
        item_number_t *r = NULL;
       {
        rule_t *rule = &rules[i];
        item_number_t *r = NULL;


@@ -234,7 +234,7 @@ grammar_dump (FILE *out, const char *title)
        for (r = rule->rhs; *r >= 0; ++r)
          ++rhs_count;
        fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",
        for (r = rule->rhs; *r >= 0; ++r)
          ++rhs_count;
        fprintf (out, "%3d (%2d, %2d, %2d, %2d-%2d)   %2d ->",

-                i - 1,
+                i,

                 rule->prec ? rule->prec->prec : 0,
                 rule->prec ? rule->prec->assoc : 0,
                 rule->useful,
                 rule->prec ? rule->prec->prec : 0,
                 rule->prec ? rule->prec->assoc : 0,
                 rule->useful,


@@ -244,7 +244,7 @@ grammar_dump (FILE *out, const char *title)
        /* Dumped the RHS. */
        for (r = rule->rhs; *r >= 0; r++)
          fprintf (out, " %3d", *r);
        /* Dumped the RHS. */
        for (r = rule->rhs; *r >= 0; r++)
          fprintf (out, " %3d", *r);

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

       }
   }
   fprintf (out, "\n\n");
       }
   }
   fprintf (out, "\n\n");


@@ -252,7 +252,7 @@ grammar_dump (FILE *out, const char *title)
   fprintf (out, "Rules interpreted\n-----------------\n\n");
   {
     rule_number_t r;
   fprintf (out, "Rules interpreted\n-----------------\n\n");
   {
     rule_number_t r;

-    for (r = 1; r < nrules + nuseless_productions + 1; r++)
+    for (r = 0; r < nrules + nuseless_productions; r++)

       {
        fprintf (out, "%-5d  ", r);
        rule_print (&rules[r], out);
       {
        fprintf (out, "%-5d  ", r);
        rule_print (&rules[r], out);


@@ -266,7 +266,7 @@ void
 grammar_free (void)
 {
   XFREE (ritem);
 grammar_free (void)
 {
   XFREE (ritem);

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

   XFREE (token_translations);
   /* Free the symbol table data structure.  */
   symbols_free ();
   XFREE (token_translations);
   /* Free the symbol table data structure.  */
   symbols_free ();

diff --git a/src/gram.h b/src/gram.h
index 36b19c1b03120dfdbc144eb8976175bb08c7dc5f..fc827ee47460d97ae8d4cc3a43e4a59e2e1ba000 100644 (file)
--- a/src/gram.h
+++ b/src/gram.h
@@ -120,7 +120,7 @@ extern unsigned int nritems;
 /* There is weird relationship between OT1H item_number_t and OTOH
    symbol_number_t and rule_number_t: we store the latter in
    item_number_t.  symbol_number_t are stored as are, while
 /* There is weird relationship between OT1H item_number_t and OTOH
    symbol_number_t and rule_number_t: we store the latter in
    item_number_t.  symbol_number_t are stored as are, while

-   the negation of rule_number_t are stored.
+   the negation of (rule_number_t + 1) are stored.

 
    Therefore, an symbol_number_t must be a valid item_number_t, and we
    sometimes have to perform the converse transformation.  */
 
    Therefore, an symbol_number_t must be a valid item_number_t, and we
    sometimes have to perform the converse transformation.  */


@@ -134,8 +134,8 @@ typedef short rule_number_t;
 # define RULE_NUMBER_MAX ((rule_number_t) SHRT_MAX)
 extern rule_number_t nrules;
 # define int_of_rule_number(RNum) ((int) (RNum))
 # define RULE_NUMBER_MAX ((rule_number_t) SHRT_MAX)
 extern rule_number_t nrules;
 # define int_of_rule_number(RNum) ((int) (RNum))

-# define rule_number_as_item_number(RNum) ((item_number_t) (- RNum))
-# define item_number_as_rule_number(INum) ((rule_number_t) (- INum))
+# define rule_number_as_item_number(RNum) ((item_number_t) (- RNum - 1))
+# define item_number_as_rule_number(INum) ((rule_number_t) (- INum - 1))

 
 
 /*--------.
 
 
 /*--------.

diff --git a/src/lalr.c b/src/lalr.c
index d07f19bbda08f5c866db7946995e222a96417d3e..6d4a431ae5f33a6e27f63ec74a36b59a9f34fc67 100644 (file)
--- a/src/lalr.c
+++ b/src/lalr.c
@@ -264,7 +264,7 @@ build_relations (void)
       symbol_number_t symbol1 = states[to_state[i]]->accessing_symbol;
       rule_number_t *rulep;
 
       symbol_number_t symbol1 = states[to_state[i]]->accessing_symbol;
       rule_number_t *rulep;
 

-      for (rulep = derives[symbol1]; *rulep > 0; rulep++)
+      for (rulep = derives[symbol1]; *rulep >= 0; rulep++)

        {
          int done;
          int length = 1;
        {
          int done;
          int length = 1;


@@ -438,7 +438,7 @@ lookaheads_print (FILE *out)
        {
          fprintf (out, "   on %d (%s) -> rule %d\n",
                   k, symbols[k]->tag,
        {
          fprintf (out, "   on %d (%s) -> rule %d\n",
                   k, symbols[k]->tag,

-                  states[i]->lookaheads_rule[j]->number - 1);
+                  states[i]->lookaheads_rule[j]->number);

        };
     }
   fprintf (out, "Lookaheads: END\n");
        };
     }
   fprintf (out, "Lookaheads: END\n");

diff --git a/src/nullable.c b/src/nullable.c
index c8b0b7d6c90d954c1fcf3edaa54d41010e079869..6a70fa572be96a66dd3aa90c4b8dc6374234408f 100644 (file)
--- a/src/nullable.c
+++ b/src/nullable.c
@@ -58,7 +58,7 @@ set_nullable (void)
   rule_list_t *p;
 
   symbol_number_t *squeue = XCALLOC (symbol_number_t, nvars);
   rule_list_t *p;
 
   symbol_number_t *squeue = XCALLOC (symbol_number_t, nvars);

-  short *rcount = XCALLOC (short, nrules + 1);
+  short *rcount = XCALLOC (short, nrules);

   /* RITEM contains all the rules, including useless productions.
      Hence we must allocate room for useless nonterminals too.  */
   rule_list_t **rsets = XCALLOC (rule_list_t *, nvars) - ntokens;
   /* RITEM contains all the rules, including useless productions.
      Hence we must allocate room for useless nonterminals too.  */
   rule_list_t **rsets = XCALLOC (rule_list_t *, nvars) - ntokens;


@@ -74,7 +74,7 @@ set_nullable (void)
   s1 = s2 = squeue;
   p = relts;
 
   s1 = s2 = squeue;
   p = relts;
 

-  for (ruleno = 1; ruleno < nrules + 1; ++ruleno)
+  for (ruleno = 0; ruleno < nrules; ++ruleno)

     if (rules[ruleno].useful)
       {
        rule_t *rule = &rules[ruleno];
     if (rules[ruleno].useful)
       {
        rule_t *rule = &rules[ruleno];

diff --git a/src/output.c b/src/output.c
index 735ef33ae22f3189629d26fc8f7fa55310b47513..127950f2b527c062737120bfaf4b008a7b372a4e 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -365,14 +365,14 @@ prepare_rules (void)
   rule_number_t r;
   unsigned int i = 0;
   item_number_t *rhs = XMALLOC (item_number_t, nritems);
   rule_number_t r;
   unsigned int i = 0;
   item_number_t *rhs = XMALLOC (item_number_t, nritems);

-  unsigned int *prhs = XMALLOC (unsigned int, nrules + 1);
-  unsigned int *rline = XMALLOC (unsigned int, nrules + 1);
-  symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules + 1);
-  unsigned int *r2 = XMALLOC (unsigned int, nrules + 1);
-  short *dprec = XMALLOC (short, nrules + 1);
-  short *merger = XMALLOC (short, nrules + 1);
-
-  for (r = 1; r < nrules + 1; ++r)
+  unsigned int *prhs = XMALLOC (unsigned int, nrules);
+  unsigned int *rline = XMALLOC (unsigned int, nrules);
+  symbol_number_t *r1 = XMALLOC (symbol_number_t, nrules);
+  unsigned int *r2 = XMALLOC (unsigned int, nrules);
+  short *dprec = XMALLOC (short, nrules);
+  short *merger = XMALLOC (short, nrules);
+
+  for (r = 0; r < nrules; ++r)

     {
       item_number_t *rhsp = NULL;
       /* Index of rule R in RHS. */
     {
       item_number_t *rhsp = NULL;
       /* Index of rule R in RHS. */


@@ -396,12 +396,12 @@ prepare_rules (void)
   assert (i == nritems);
 
   muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);
   assert (i == nritems);
 
   muscle_insert_item_number_table ("rhs", rhs, ritem[0], 1, nritems);

-  muscle_insert_unsigned_int_table ("prhs", prhs, 0, 1, nrules + 1);
-  muscle_insert_unsigned_int_table ("rline", rline, 0, 1, nrules + 1);
-  muscle_insert_symbol_number_table ("r1", r1, 0, 1, nrules + 1);
-  muscle_insert_unsigned_int_table ("r2", r2, 0, 1, nrules + 1);
-  muscle_insert_short_table ("dprec", dprec, 0, 1, nrules + 1);
-  muscle_insert_short_table ("merger", merger, 0, 1, nrules + 1);
+  muscle_insert_unsigned_int_table ("prhs", prhs, 0, 0, nrules);
+  muscle_insert_unsigned_int_table ("rline", rline, 0, 0, nrules);
+  muscle_insert_symbol_number_table ("r1", r1, 0, 0, nrules);
+  muscle_insert_unsigned_int_table ("r2", r2, 0, 0, nrules);
+  muscle_insert_short_table ("dprec", dprec, 0, 0, nrules);
+  muscle_insert_short_table ("merger", merger, 0, 0, nrules);

 
   free (rhs);
   free (prhs);
 
   free (rhs);
   free (prhs);


@@ -434,8 +434,8 @@ prepare_states (void)
 | by non-zero entries in CONFLROW, create a list of possible        |
 | reductions that are alternatives to the shift or reduction        |
 | currently recorded for that token in STATE.  Store the alternative |
 | by non-zero entries in CONFLROW, create a list of possible        |
 | reductions that are alternatives to the shift or reduction        |
 | currently recorded for that token in STATE.  Store the alternative |

-| reductions followed by a 0 in conflict_list, updating                     |
-| conflict_list_cnt, and storing an index to the start of the list   |
+| reductions followed by a 0 in CONFLICT_LIST, updating                     |
+| CONFLICT_LIST_CNT, and storing an index to the start of the list   |

 | back into CONFLROW.                                               |
 `-------------------------------------------------------------------*/
 
 | back into CONFLROW.                                               |
 `-------------------------------------------------------------------*/
 


@@ -461,7 +461,7 @@ conflict_row (state_t *state)
            {
              assert (conflict_list_free > 0);
              conflict_list[conflict_list_cnt]
            {
              assert (conflict_list_free > 0);
              conflict_list[conflict_list_cnt]

-               = state->lookaheads_rule[i]->number;
+               = state->lookaheads_rule[i]->number + 1;

              conflict_list_cnt += 1;
              conflict_list_free -= 1;
            }
              conflict_list_cnt += 1;
              conflict_list_free -= 1;
            }


@@ -488,7 +488,7 @@ conflict_row (state_t *state)
 | considered that likes a token gets to handle it.                  |
 |                                                                   |
 | For GLR parsers, also sets CONFLROW[SYM] to an index into         |
 | considered that likes a token gets to handle it.                  |
 |                                                                   |
 | For GLR parsers, also sets CONFLROW[SYM] to an index into         |

-| conflict_list iff there is an unresolved conflict (s/r or r/r)    |
+| CONFLICT_LIST iff there is an unresolved conflict (s/r or r/r)    |

 | with symbol SYM. The default reduction is not used for a symbol   |
 | that has any such conflicts.                                      |
 `------------------------------------------------------------------*/
 | with symbol SYM. The default reduction is not used for a symbol   |
 | that has any such conflicts.                                      |
 `------------------------------------------------------------------*/


@@ -497,7 +497,7 @@ static rule_number_t
 action_row (state_t *state)
 {
   int i;
 action_row (state_t *state)
 {
   int i;

-  rule_number_t default_rule = 0;
+  rule_number_t default_rule = -1;

   reductions_t *redp = state->reductions;
   transitions_t *transitions = state->transitions;
   errs_t *errp = state->errs;
   reductions_t *redp = state->reductions;
   transitions_t *transitions = state->transitions;
   errs_t *errp = state->errs;


@@ -601,7 +601,7 @@ action_row (state_t *state)
   /* If have no default rule, the default is an error.
      So replace any action which says "error" with "use default".  */
 
   /* If have no default rule, the default is an error.
      So replace any action which says "error" with "use default".  */
 

-  if (default_rule == 0)
+  if (default_rule == -1)

     for (i = 0; i < ntokens; i++)
       if (actrow[i] == ACTION_MIN)
        actrow[i] = 0;
     for (i = 0; i < ntokens; i++)
       if (actrow[i] == ACTION_MIN)
        actrow[i] = 0;


@@ -689,7 +689,7 @@ token_actions (void)
 
   for (i = 0; i < nstates; ++i)
     {
 
   for (i = 0; i < nstates; ++i)
     {

-      yydefact[i] = action_row (states[i]);
+      yydefact[i] = action_row (states[i]) + 1;

       save_row (i);
     }
 
       save_row (i);
     }
 


@@ -711,10 +711,10 @@ actions_output (FILE *out)
   rule_number_t r;
 
   fputs ("m4_define([b4_actions], \n[[", out);
   rule_number_t r;
 
   fputs ("m4_define([b4_actions], \n[[", out);

-  for (r = 1; r < nrules + 1; ++r)
+  for (r = 0; r < nrules; ++r)

     if (rules[r].action)
       {
     if (rules[r].action)
       {

-       fprintf (out, "  case %d:\n", r);
+       fprintf (out, "  case %d:\n", r + 1);

 
        if (!no_lines_flag)
          fprintf (out, muscle_find ("linef"),
 
        if (!no_lines_flag)
          fprintf (out, muscle_find ("linef"),

diff --git a/src/print.c b/src/print.c
index 7adb51b06016495469461e2b4b49e3a9cf1d894f..67490875402b6d494f3878b7035cdc84571d66a1 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -97,7 +97,7 @@ print_core (FILE *out, state_t *state)
       while (*sp >= 0)
        sp++;
 
       while (*sp >= 0)
        sp++;
 

-      rule = -(*sp);
+      rule = item_number_as_rule_number (*sp);

 
       rule_lhs_print (&rules[rule], previous_lhs, out);
       previous_lhs = rules[rule].lhs;
 
       rule_lhs_print (&rules[rule], previous_lhs, out);
       previous_lhs = rules[rule].lhs;


@@ -288,7 +288,7 @@ print_reduction (FILE *out, size_t width,
   if (!enabled)
     fputc ('[', out);
   fprintf (out, _("reduce using rule %d (%s)"),
   if (!enabled)
     fputc ('[', out);
   fprintf (out, _("reduce using rule %d (%s)"),

-          rule->number - 1, rule->lhs->tag);
+          rule->number, rule->lhs->tag);

   if (!enabled)
     fputc (']', out);
   fputc ('\n', out);
   if (!enabled)
     fputc (']', out);
   fputc ('\n', out);


@@ -473,12 +473,12 @@ print_grammar (FILE *out)
        END_TEST (50);
        sprintf (buffer, " (%d)", i);
 
        END_TEST (50);
        sprintf (buffer, " (%d)", i);
 

-       for (r = 1; r < nrules + 1; r++)
+       for (r = 0; r < nrules; r++)

          for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
            if (item_number_as_symbol_number (*rhsp) == token_translations[i])
              {
                END_TEST (65);
          for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
            if (item_number_as_symbol_number (*rhsp) == token_translations[i])
              {
                END_TEST (65);

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

                break;
              }
        fprintf (out, "%s\n", buffer);
                break;
              }
        fprintf (out, "%s\n", buffer);


@@ -493,7 +493,7 @@ print_grammar (FILE *out)
       rule_number_t r;
       const char *tag = symbols[i]->tag;
 
       rule_number_t r;
       const char *tag = symbols[i]->tag;
 

-      for (r = 1; r < nrules + 1; r++)
+      for (r = 0; r < nrules; r++)

        {
          item_number_t *rhsp;
          if (rules[r].lhs->number == i)
        {
          item_number_t *rhsp;
          if (rules[r].lhs->number == i)


@@ -517,11 +517,11 @@ print_grammar (FILE *out)
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on left:"));
 
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on left:"));
 

-         for (r = 1; r < nrules + 1; r++)
+         for (r = 0; r < nrules; r++)

            {
              END_TEST (65);
              if (rules[r].lhs->number == i)
            {
              END_TEST (65);
              if (rules[r].lhs->number == i)

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

            }
        }
 
            }
        }
 


@@ -531,14 +531,14 @@ print_grammar (FILE *out)
            sprintf (buffer + strlen (buffer), ",");
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on right:"));
            sprintf (buffer + strlen (buffer), ",");
          END_TEST (50);
          sprintf (buffer + strlen (buffer), _(" on right:"));

-         for (r = 1; r < nrules + 1; r++)
+         for (r = 0; r < nrules; r++)

            {
              item_number_t *rhsp;
              for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
                if (item_number_as_symbol_number (*rhsp) == i)
                  {
                    END_TEST (65);
            {
              item_number_t *rhsp;
              for (rhsp = rules[r].rhs; *rhsp >= 0; rhsp++)
                if (item_number_as_symbol_number (*rhsp) == i)
                  {
                    END_TEST (65);

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

                    break;
                  }
            }
                    break;
                  }
            }

diff --git a/src/reader.c b/src/reader.c
index 86f3adf4d4fca3082a869b47fa2663cd37d4dda1..a029b6714cc9fd01bb0190086205e658f9192e41 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -406,11 +406,11 @@ static void
 packgram (void)
 {
   unsigned int itemno = 0;
 packgram (void)
 {
   unsigned int itemno = 0;

-  rule_number_t ruleno = 1;
+  rule_number_t ruleno = 0;

   symbol_list_t *p = grammar;
 
   ritem = XCALLOC (item_number_t, nritems);
   symbol_list_t *p = grammar;
 
   ritem = XCALLOC (item_number_t, nritems);

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

 
   while (p)
     {
 
   while (p)
     {


@@ -447,7 +447,7 @@ packgram (void)
          rules[ruleno].precsym = ruleprec;
          rules[ruleno].prec = ruleprec;
        }
          rules[ruleno].precsym = ruleprec;
          rules[ruleno].prec = ruleprec;
        }

-      ritem[itemno++] = -ruleno;
+      ritem[itemno++] = rule_number_as_item_number (ruleno);

       ++ruleno;
 
       if (p)
       ++ruleno;
 
       if (p)

diff --git a/src/reduce.c b/src/reduce.c
index fb97597216782d34b40842c78da262015560107f..154e63bf404af9d6279b2dde8044a3268fae58d8 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -111,7 +111,7 @@ useless_nonterminals (void)
   while (1)
     {
       bitset_copy (Np, N);
   while (1)
     {
       bitset_copy (Np, N);

-      for (r = 1; r < nrules + 1; r++)
+      for (r = 0; r < nrules; r++)

        if (!bitset_test (P, r)
            && useful_production (r, N))
          {
        if (!bitset_test (P, r)
            && useful_production (r, N))
          {


@@ -158,7 +158,7 @@ inaccessable_symbols (void)
      user can know.  */
 
   Vp = bitset_create (nsyms, BITSET_FIXED);
      user can know.  */
 
   Vp = bitset_create (nsyms, BITSET_FIXED);

-  Pp = bitset_create (nrules + 1, BITSET_FIXED);
+  Pp = bitset_create (nrules, BITSET_FIXED);

 
   /* If the start symbol isn't useful, then nothing will be useful. */
   if (bitset_test (N, axiom->number - ntokens))
 
   /* If the start symbol isn't useful, then nothing will be useful. */
   if (bitset_test (N, axiom->number - ntokens))


@@ -169,7 +169,7 @@ inaccessable_symbols (void)
        {
          rule_number_t r;
          bitset_copy (Vp, V);
        {
          rule_number_t r;
          bitset_copy (Vp, V);

-         for (r = 1; r < nrules + 1; r++)
+         for (r = 0; r < nrules; r++)

            {
              if (!bitset_test (Pp, r)
                  && bitset_test (P, r)
            {
              if (!bitset_test (Pp, r)
                  && bitset_test (P, r)


@@ -215,10 +215,10 @@ inaccessable_symbols (void)
 
   /* A token that was used in %prec should not be warned about.  */
   {
 
   /* A token that was used in %prec should not be warned about.  */
   {

-    rule_number_t i;
-    for (i = 1; i < nrules + 1; i++)
-      if (rules[i].precsym != 0)
-       bitset_set (V1, rules[i].precsym->number);
+    rule_number_t r;
+    for (r = 0; r < nrules; ++r)
+      if (rules[r].precsym != 0)
+       bitset_set (V1, rules[r].precsym->number);

   }
 }
 
   }
 }
 


@@ -234,7 +234,7 @@ reduce_grammar_tables (void)
   /* Report and flag useless productions.  */
   {
     rule_number_t r;
   /* Report and flag useless productions.  */
   {
     rule_number_t r;

-    for (r = 1; r < nrules + 1; r++)
+    for (r = 0; r < nrules; r++)

       {
        rules[r].useful = bitset_test (P, r);
        if (!rules[r].useful)
       {
        rules[r].useful = bitset_test (P, r);
        if (!rules[r].useful)


@@ -249,17 +249,17 @@ reduce_grammar_tables (void)
   /* Map the nonterminals to their new index: useful first, useless
      afterwards.  Kept for later report.  */
   {
   /* Map the nonterminals to their new index: useful first, useless
      afterwards.  Kept for later report.  */
   {

-    int useful = 1;
-    int useless = nrules + 1 - nuseless_productions;
-    rule_t *rules_sorted = XMALLOC (rule_t, nrules + 1) - 1;
+    int useful = 0;
+    int useless = nrules - nuseless_productions;
+    rule_t *rules_sorted = XMALLOC (rule_t, nrules);

     rule_number_t r;
     rule_number_t r;

-    for (r = 1; r < nrules + 1; ++r)
+    for (r = 0; r < nrules; ++r)

       rules_sorted[rules[r].useful ? useful++ : useless++] = rules[r];
       rules_sorted[rules[r].useful ? useful++ : useless++] = rules[r];

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

     rules = rules_sorted;
 
     /* Renumber the rules markers in RITEMS.  */
     rules = rules_sorted;
 
     /* Renumber the rules markers in RITEMS.  */

-    for (r = 1; r < nrules + 1; ++r)
+    for (r = 0; r < nrules; ++r)

       {
        item_number_t *rhsp = rules[r].rhs;
        for (/* Nothing. */; *rhsp >= 0; ++rhsp)
       {
        item_number_t *rhsp = rules[r].rhs;
        for (/* Nothing. */; *rhsp >= 0; ++rhsp)


@@ -274,7 +274,7 @@ reduce_grammar_tables (void)
   {
     int r;
     int length;
   {
     int r;
     int length;

-    for (r = nrules + 1; r < nrules + 1 + nuseless_productions; ++r)
+    for (r = nrules; r < nrules + nuseless_productions; ++r)

       {
        length = rule_rhs_length (&rules[r]);
        nritems -= length + 1;
       {
        length = rule_rhs_length (&rules[r]);
        nritems -= length + 1;


@@ -326,7 +326,7 @@ nonterminals_reduce (void)
 
   {
     rule_number_t r;
 
   {
     rule_number_t r;

-    for (r = 1; r < nrules + 1; ++r)
+    for (r = 0; r < nrules; ++r)

       {
        item_number_t *rhsp;
        for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)
       {
        item_number_t *rhsp;
        for (rhsp = rules[r].rhs; *rhsp >= 0; ++rhsp)


@@ -376,8 +376,8 @@ reduce_output (FILE *out)
 
   if (nuseless_productions > 0)
     grammar_rules_partial_print (out, _("Useless rules"),
 
   if (nuseless_productions > 0)
     grammar_rules_partial_print (out, _("Useless rules"),

-                                nrules + 1,
-                                nuseless_productions + nrules + 1);
+                                nrules,
+                                nrules + nuseless_productions);

 }
 \f
 
 }
 \f
 


@@ -425,7 +425,7 @@ reduce_grammar (void)
   /* Allocate the global sets used to compute the reduced grammar */
 
   N = bitset_create (nvars, BITSET_FIXED);
   /* Allocate the global sets used to compute the reduced grammar */
 
   N = bitset_create (nvars, BITSET_FIXED);

-  P =  bitset_create (nrules + 1, BITSET_FIXED);
+  P =  bitset_create (nrules, BITSET_FIXED);

   V = bitset_create (nsyms, BITSET_FIXED);
   V1 = bitset_create (nsyms, BITSET_FIXED);
 
   V = bitset_create (nsyms, BITSET_FIXED);
   V1 = bitset_create (nsyms, BITSET_FIXED);
 

diff --git a/tests/conflicts.at b/tests/conflicts.at
index 4694014948e5f9ecd1b2fe9942eb35819218fb19..43b37dfcdf848d963e488129922d5fa1347a34e9 100644 (file)
--- a/tests/conflicts.at
+++ b/tests/conflicts.at
@@ -326,7 +326,7 @@ state 5
     1    | exp OP exp .  [$, OP]
 
     $default  reduce using rule 1 (exp)
     1    | exp OP exp .  [$, OP]
 
     $default  reduce using rule 1 (exp)

-    Conflict between rule 2 and token OP resolved as shift (%left OP).
+    Conflict between rule 1 and token OP resolved as reduce (%left OP).

 ]])
 
 AT_CLEANUP
 ]])
 
 AT_CLEANUP

diff --git a/tests/sets.at b/tests/sets.at
index e1cf3ff62594f88fb6b55c71dd7ad3c0be2661b8..28c582494e91ac8fe413857d2fc78fb2e1115264 100644 (file)
--- a/tests/sets.at
+++ b/tests/sets.at
@@ -98,12 +98,12 @@ FIRSTS
                e
 FDERIVES
        $axiom derives
                e
 FDERIVES
        $axiom derives

-                 1  e $
-                 2  'e'
-                 3  /* empty */
+                 0  e $
+                 1  'e'
+                 2  /* empty */

        e derives
        e derives

-                 2  'e'
-                 3  /* empty */
+                 1  'e'
+                 2  /* empty */

 ]])
 
 AT_CLEANUP
 ]])
 
 AT_CLEANUP


@@ -233,22 +233,22 @@ FIRSTS
                exp
 FDERIVES
        $axiom derives
                exp
 FDERIVES
        $axiom derives

-                 1  exp $
-                 2  exp '<' exp
-                 3  exp '>' exp
-                 4  exp '+' exp
-                 5  exp '-' exp
-                 6  exp '^' exp
-                 7  exp '=' exp
-                 8  "exp"
+                 0  exp $
+                 1  exp '<' exp
+                 2  exp '>' exp
+                 3  exp '+' exp
+                 4  exp '-' exp
+                 5  exp '^' exp
+                 6  exp '=' exp
+                 7  "exp"

        exp derives
        exp derives

-                 2  exp '<' exp
-                 3  exp '>' exp
-                 4  exp '+' exp
-                 5  exp '-' exp
-                 6  exp '^' exp
-                 7  exp '=' exp
-                 8  "exp"
+                 1  exp '<' exp
+                 2  exp '>' exp
+                 3  exp '+' exp
+                 4  exp '-' exp
+                 5  exp '^' exp
+                 6  exp '=' exp
+                 7  "exp"

 ]])
 
 AT_CLEANUP
 ]])
 
 AT_CLEANUP