* src/gram.h, src/gram.c (nitems): Remove, it is an alias of

nritems.
Adjust dependencies.

diff --git a/ChangeLog b/ChangeLog
index bffec9d99a62a6b2165869b496e48f2e35d3acd2..2f3ee21b3f050c3b03be2044f8d0b9e9d70ae860 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2002-04-07  Akim Demaille  <akim@epita.fr>
+
+       * src/gram.h, src/gram.c (nitems): Remove, it is an alias of
+       nritems.
+       Adjust dependencies.
+
+       
 2002-04-07  Akim Demaille  <akim@epita.fr>
 
        * src/reader.c: Normalize increments to prefix form.

diff --git a/src/LR0.c b/src/LR0.c
index aa46ff78270d3e4d5bb42991726b15e7dca49e94..2fa64c5ef26d476f2a9dae2613e4c751e6542017 100644 (file)
--- a/src/LR0.c
+++ b/src/LR0.c
@@ -160,7 +160,7 @@ new_itemsets (void)
 
   nshifts = 0;
 
-  for (i = 0; i < nitemset; ++i)
+  for (i = 0; i < nritemset; ++i)
     {
       int symbol = ritem[itemset[i]];
       if (symbol >= 0)
@@ -363,7 +363,7 @@ save_reductions (void)
     return;
 
   /* Find and count the active items that represent ends of rules. */
-  for (i = 0; i < nitemset; ++i)
+  for (i = 0; i < nritemset; ++i)
     {
       int item = ritem[itemset[i]];
       if (item < 0)

diff --git a/src/closure.c b/src/closure.c
index 191558a3d92a4488d4f59c97bc44db9ea4054596..05b299a7f228c34fbb89a20a76efd660a25a74a1 100644 (file)
--- a/src/closure.c
+++ b/src/closure.c
@@ -31,7 +31,7 @@
 
 /* NITEMSET is the size of the array ITEMSET.  */
 short *itemset;
-int nitemset;
+int nritemset;
 
 static bitset ruleset;
 
@@ -258,7 +258,7 @@ closure (short *core, int n)
     if (ISVAR (ritem[core[c]]))
       bitset_or (ruleset, ruleset, FDERIVES (ritem[core[c]]));
 
-  nitemset = 0;
+  nritemset = 0;
   c = 0;
   for (ruleno = 0; ruleno < nrules + 1; ++ruleno)
     if (bitset_test (ruleset, ruleno))
@@ -266,23 +266,23 @@ closure (short *core, int n)
        int itemno = rules[ruleno].rhs - ritem;
        while (c < n && core[c] < itemno)
          {
-           itemset[nitemset] = core[c];
-           nitemset++;
+           itemset[nritemset] = core[c];
+           nritemset++;
            c++;
          }
-       itemset[nitemset] = itemno;
-       nitemset++;
+       itemset[nritemset] = itemno;
+       nritemset++;
       }
 
   while (c < n)
     {
-      itemset[nitemset] = core[c];
-      nitemset++;
+      itemset[nritemset] = core[c];
+      nritemset++;
       c++;
     }
 
   if (trace_flag)
-    print_closure ("output", itemset, nitemset);
+    print_closure ("output", itemset, nritemset);
 }
 
 

diff --git a/src/closure.h b/src/closure.h
index b4f1bdf09c61cf0c67d78b308abe2f39e4657f2f..32082d15a06468edcf34e4ccc1a5195510e86b46 100644 (file)
--- a/src/closure.h
+++ b/src/closure.h
@@ -50,6 +50,6 @@ void closure PARAMS ((short *items, int n));
 void free_closure PARAMS ((void));
 
 extern short *itemset;
-extern int nitemset;
+extern int nritemset;
 
 #endif /* !CLOSURE_H_ */

diff --git a/src/gram.c b/src/gram.c
index e3638d39ae29555a84b8d0b32082e1ef737df352..6d8fe0a74370ee8af51eef75c9d7ba61a9f6dfe2 100644 (file)
--- a/src/gram.c
+++ b/src/gram.c
@@ -27,18 +27,17 @@
 
 /* comments for these variables are in gram.h  */
 
-int nitems = 0;
-int nrules = 0;
-int nsyms = 0;
-int ntokens = 1;
-int nvars = 0;
-
 short *ritem = NULL;
 int nritems = 0;
 
 rule_t *rules = NULL;
+int nrules = 0;
 
 symbol_t **symbols = NULL;
+int nsyms = 0;
+int ntokens = 1;
+int nvars = 0;
+
 short *token_translations = NULL;
 
 int start_symbol = 0;

diff --git a/src/gram.h b/src/gram.h
index d22be7a960228e1705617a3ca0875f543ce3a846..cc8e7ff9445011b9560f9f205508757dd21f6033 100644 (file)
--- a/src/gram.h
+++ b/src/gram.h
@@ -82,7 +82,7 @@
    says which rule it is for.
 
    The portions of RITEM come in order of increasing rule number and
-   are followed by an element which is zero to mark the end.  nitems
+   are followed by an element which is zero to mark the end.  nritems
    is the total length of ritem, not counting the final zero.  Each
    element of RITEM is called an "item" and its index in RITEM is an
    item number.
@@ -104,7 +104,6 @@
 #define        ISTOKEN(s)      ((s) < ntokens)
 #define        ISVAR(s)        ((s) >= ntokens)
 
-extern int nitems;
 extern int nrules;
 extern int nsyms;
 extern int ntokens;

diff --git a/src/print.c b/src/print.c
index 5c1ef12751c1014e1f932e894ee0f52cfc491dd7..31158a71d541cd26ae383a7483dd4c2cc9d8c3d6 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -70,20 +70,20 @@ print_core (FILE *out, state_t *state)
 {
   int i;
   short *sitems = state->items;
-  int snitems   = state->nitems;
+  int snritems   = state->nitems;
 
   /* New experimental feature: if TRACE_FLAGS output all the items of
      a state, not only its kernel.  */
   if (trace_flag)
     {
-      closure (sitems, snitems);
+      closure (sitems, snritems);
       sitems = itemset;
-      snitems = nitemset;
+      snritems = nritemset;
     }
 
-  if (snitems)
+  if (snritems)
     {
-      for (i = 0; i < snitems; i++)
+      for (i = 0; i < snritems; i++)
        {
          short *sp;
          short *sp1;

diff --git a/src/print_graph.c b/src/print_graph.c
index 2570ab58d445806cd5b771ae2c02fb358867ec16..707013e7071536a2952303b4f74078f0e1141918 100644 (file)
--- a/src/print_graph.c
+++ b/src/print_graph.c
@@ -51,18 +51,18 @@ print_core (state_t *state, struct obstack *node_obstack)
 {
   int i;
   short *sitems = state->items;
-  int snitems   = state->nitems;
+  int snritems   = state->nitems;
 
   /* Output all the items of a state, not only its kernel.  */
   if (trace_flag)
     {
-      closure (sitems, snitems);
+      closure (sitems, snritems);
       sitems = itemset;
-      snitems = nitemset;
+      snritems = nritemset;
     }
 
   obstack_fgrow1 (node_obstack, "state %2d\n", state->number);
-  for (i = 0; i < snitems; i++)
+  for (i = 0; i < snritems; i++)
     {
       short *sp;
       short *sp1;

diff --git a/src/reader.c b/src/reader.c
index c8d90ec40d52ee5f9d82bafd4515f003098e5344..98b7b8033beea6bbaa5d8bfcbdad791ca1c6abdd 100644 (file)
--- a/src/reader.c
+++ b/src/reader.c
@@ -1433,7 +1433,7 @@ readgram (void)
        /* start a new rule and record its lhs.  */
 
        ++nrules;
-       ++nitems;
+       ++nritems;
 
        p = symbol_list_new (lhs);
 
@@ -1511,7 +1511,7 @@ readgram (void)
                   current one, so that the action just read can
                   belong to it.  */
                ++nrules;
-               ++nitems;
+               ++nritems;
                p = symbol_list_new (sdummy);
                /* Attach its lineno to that of the host rule. */
                p->line = crule->line;
@@ -1532,7 +1532,7 @@ readgram (void)
 
                /* Insert the dummy generated by that rule into this
                   rule.  */
-               ++nitems;
+               ++nritems;
                p = symbol_list_new (sdummy);
                p1->next = p;
                p1 = p;
@@ -1542,7 +1542,7 @@ readgram (void)
 
            if (t == tok_identifier)
              {
-               ++nitems;
+               ++nritems;
                p = symbol_list_new (symval);
                p1->next = p;
                p1 = p;
@@ -1633,7 +1633,7 @@ readgram (void)
   p->next->next->next = symbol_list_new (NULL);
   p->next->next->next->next = grammar;
   nrules += 1;
-  nitems += 3;
+  nritems += 3;
   grammar = p;
   startval = axiom;
 
@@ -1742,10 +1742,10 @@ packgram (void)
   symbol_list *p;
 
   /* We use short to index items.  */
-  if (nitems >= MAXSHORT)
+  if (nritems >= MAXSHORT)
     fatal (_("too many items (max %d)"), MAXSHORT);
 
-  ritem = XCALLOC (short, nitems + 1);
+  ritem = XCALLOC (short, nritems + 1);
   rules = XCALLOC (rule_t, nrules) - 1;
 
   itemno = 0;
@@ -1793,8 +1793,7 @@ packgram (void)
     }
 
   ritem[itemno] = 0;
-  nritems = itemno;
-  assert (nritems == nitems);
+  assert (itemno == nritems);
 
   if (trace_flag)
     ritem_print (stderr);

diff --git a/src/reduce.c b/src/reduce.c
index ba605df4c04b8843cb8af4724acb951a5b762eb9..256817505722905f706b36c7ae396237443168bd 100644 (file)
--- a/src/reduce.c
+++ b/src/reduce.c
@@ -269,7 +269,6 @@ reduce_grammar_tables (void)
       {
        length = rule_rhs_length (&rules[r]);
        nritems -= length + 1;
-       nitems -= length + 1;
       }
   }
 }
@@ -383,8 +382,8 @@ dump_grammar (FILE *out)
 
   fprintf (out, "REDUCED GRAMMAR\n\n");
   fprintf (out,
-          "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nitems = %d\n\n",
-          ntokens, nvars, nsyms, nrules, nitems);
+          "ntokens = %d, nvars = %d, nsyms = %d, nrules = %d, nritems = %d\n\n",
+          ntokens, nvars, nsyms, nrules, nritems);
   fprintf (out, "Variables\n---------\n\n");
   fprintf (out, "Value  Sprec  Sassoc  Tag\n");
   for (i = ntokens; i < nsyms; i++)

diff --git a/src/state.h b/src/state.h
index 9446f4f652ca9696391d3fa78f6c5e02cb790073..f8fab67d9cf9128b3bbc71090c2378bb4ab8665b 100644 (file)
--- a/src/state.h
+++ b/src/state.h
@@ -41,7 +41,7 @@
    the last thing accepted to reach that state.  It is the
    accessing_symbol of the core.
 
-   Each core contains a vector of nitems items which are the indices
+   Each core contains a vector of NITEMS items which are the indices
    in the ritems vector of the items that are selected in this state.
 
    The link field is used for chaining symbols that hash states by