Merge branch 'rightlib' into mergelibs-240708-1553

1 files changed, 64 insertions, 94 deletions

diff --git a/contrib/tools/bison/src/lalr.c b/contrib/tools/bison/src/lalr.c
index d99f960fbf..0f1149d7fb 100644
--- a/contrib/tools/bison/src/lalr.c
+++ b/contrib/tools/bison/src/lalr.c
@@ -1,7 +1,7 @@
 /* Compute lookahead criteria for Bison.
 
-   Copyright (C) 1984, 1986, 1989, 2000-2013 Free Software Foundation,
-   Inc.
+   Copyright (C) 1984, 1986, 1989, 2000-2015, 2018-2019 Free Software
+   Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
 
@@ -40,10 +40,10 @@
 #include "relation.h"
 #include "symtab.h"
 
-goto_number *goto_map;
-goto_number ngotos;
-state_number *from_state;
-state_number *to_state;
+goto_number *goto_map = NULL;
+goto_number ngotos = 0;
+state_number *from_state = NULL;
+state_number *to_state = NULL;
 bitsetv goto_follows = NULL;
 
 /* Linked list of goto numbers.  */
@@ -67,23 +67,17 @@ static goto_number **includes;
 static goto_list **lookback;
 
 
-
-
 void
 set_goto_map (void)
 {
-  state_number s;
-  goto_number *temp_map;
+  goto_number *temp_map = xnmalloc (nvars + 1, sizeof *temp_map);
 
   goto_map = xcalloc (nvars + 1, sizeof *goto_map);
-  temp_map = xnmalloc (nvars + 1, sizeof *temp_map);
-
   ngotos = 0;
-  for (s = 0; s < nstates; ++s)
+  for (state_number s = 0; s < nstates; ++s)
     {
       transitions *sp = states[s]->transitions;
-      int i;
-      for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
+      for (int i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
         {
           ngotos++;
 
@@ -96,14 +90,13 @@ set_goto_map (void)
 
   {
     goto_number k = 0;
-    int i;
-    for (i = ntokens; i < nsyms; i++)
+    for (symbol_number i = ntokens; i < nsyms; ++i)
       {
         temp_map[i - ntokens] = k;
         k += goto_map[i - ntokens];
       }
 
-    for (i = ntokens; i < nsyms; i++)
+    for (symbol_number i = ntokens; i < nsyms; ++i)
       goto_map[i - ntokens] = temp_map[i - ntokens];
 
     goto_map[nsyms - ntokens] = ngotos;
@@ -113,11 +106,10 @@ set_goto_map (void)
   from_state = xcalloc (ngotos, sizeof *from_state);
   to_state = xcalloc (ngotos, sizeof *to_state);
 
-  for (s = 0; s < nstates; ++s)
+  for (state_number s = 0; s < nstates; ++s)
     {
-      transitions *sp = states[s]->transitions;
-      int i;
-      for (i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
+      const transitions *sp = states[s]->transitions;
+      for (int i = sp->num - 1; i >= 0 && TRANSITION_IS_GOTO (sp, i); --i)
         {
           goto_number k = temp_map[TRANSITION_SYMBOL (sp, i) - ntokens]++;
           from_state[k] = s;
@@ -132,19 +124,14 @@ set_goto_map (void)
 goto_number
 map_goto (state_number s0, symbol_number sym)
 {
-  goto_number high;
-  goto_number low;
-  goto_number middle;
-  state_number s;
-
-  low = goto_map[sym - ntokens];
-  high = goto_map[sym - ntokens + 1] - 1;
+  goto_number low = goto_map[sym - ntokens];
+  goto_number high = goto_map[sym - ntokens + 1] - 1;
 
   for (;;)
     {
       aver (low <= high);
-      middle = (low + high) / 2;
-      s = from_state[middle];
+      goto_number middle = (low + high) / 2;
+      state_number s = from_state[middle];
       if (s == s0)
         return middle;
       else if (s < s0)
@@ -162,20 +149,18 @@ initialize_F (void)
   goto_number *edge = xnmalloc (ngotos + 1, sizeof *edge);
   goto_number nedges = 0;
 
-  goto_number i;
-
   goto_follows = bitsetv_create (ngotos, ntokens, BITSET_FIXED);
 
-  for (i = 0; i < ngotos; i++)
+  for (goto_number i = 0; i < ngotos; ++i)
     {
       state_number stateno = to_state[i];
-      transitions *sp = states[stateno]->transitions;
+      const transitions *sp = states[stateno]->transitions;
 
       int j;
       FOR_EACH_SHIFT (sp, j)
         bitset_set (goto_follows[i], TRANSITION_SYMBOL (sp, j));
 
-      for (; j < sp->num; j++)
+      for (; j < sp->num; ++j)
         {
           symbol_number sym = TRANSITION_SYMBOL (sp, j);
           if (nullable[sym - ntokens])
@@ -195,7 +180,7 @@ initialize_F (void)
 
   relation_digraph (reads, ngotos, &goto_follows);
 
-  for (i = 0; i < ngotos; i++)
+  for (goto_number i = 0; i < ngotos; ++i)
     free (reads[i]);
 
   free (reads);
@@ -220,19 +205,16 @@ build_relations (void)
 {
   goto_number *edge = xnmalloc (ngotos + 1, sizeof *edge);
   state_number *states1 = xnmalloc (ritem_longest_rhs () + 1, sizeof *states1);
-  goto_number i;
 
   includes = xnmalloc (ngotos, sizeof *includes);
 
-  for (i = 0; i < ngotos; i++)
+  for (goto_number i = 0; i < ngotos; ++i)
     {
       int nedges = 0;
       symbol_number symbol1 = states[to_state[i]]->accessing_symbol;
-      rule **rulep;
 
-      for (rulep = derives[symbol1 - ntokens]; *rulep; rulep++)
+      for (rule **rulep = derives[symbol1 - ntokens]; *rulep; rulep++)
         {
-          bool done;
           int length = 1;
           item_number const *rp;
           state *s = states[from_state[i]];
@@ -249,7 +231,7 @@ build_relations (void)
             add_lookback_edge (s, *rulep, i);
 
           length--;
-          done = false;
+          bool done = false;
           while (!done)
             {
               done = true;
@@ -272,9 +254,8 @@ build_relations (void)
         includes[i] = NULL;
       else
         {
-          int j;
           includes[i] = xnmalloc (nedges + 1, sizeof includes[i][0]);
-          for (j = 0; j < nedges; j++)
+          for (int j = 0; j < nedges; ++j)
             includes[i][j] = edge[j];
           includes[i][nedges] = END_NODE;
         }
@@ -291,11 +272,9 @@ build_relations (void)
 static void
 compute_FOLLOWS (void)
 {
-  goto_number i;
-
   relation_digraph (includes, ngotos, &goto_follows);
 
-  for (i = 0; i < ngotos; i++)
+  for (goto_number i = 0; i < ngotos; ++i)
     free (includes[i]);
 
   free (includes);
@@ -305,15 +284,12 @@ compute_FOLLOWS (void)
 static void
 compute_lookahead_tokens (void)
 {
-  size_t i;
-  goto_list *sp;
-
-  for (i = 0; i < nLA; i++)
-    for (sp = lookback[i]; sp; sp = sp->next)
+  for (size_t i = 0; i < nLA; ++i)
+    for (goto_list *sp = lookback[i]; sp; sp = sp->next)
       bitset_or (LA[i], LA[i], goto_follows[sp->value]);
 
   /* Free LOOKBACK. */
-  for (i = 0; i < nLA; i++)
+  for (size_t i = 0; i < nLA; ++i)
     LIST_FREE (goto_list, lookback[i]);
 
   free (lookback);
@@ -353,7 +329,7 @@ state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept)
           && default_reduction_only_for_accept))
     n_lookahead_tokens += rp->num;
   else
-    s->consistent = 1;
+    s->consistent = true;
 
   return n_lookahead_tokens;
 }
@@ -366,8 +342,6 @@ state_lookahead_tokens_count (state *s, bool default_reduction_only_for_accept)
 void
 initialize_LA (void)
 {
-  state_number i;
-  bitsetv pLA;
   bool default_reduction_only_for_accept;
   {
     char *default_reductions =
@@ -378,7 +352,7 @@ initialize_LA (void)
 
   /* Compute the total number of reductions requiring a lookahead.  */
   nLA = 0;
-  for (i = 0; i < nstates; i++)
+  for (state_number i = 0; i < nstates; ++i)
     nLA +=
       state_lookahead_tokens_count (states[i],
                                     default_reduction_only_for_accept);
@@ -386,11 +360,11 @@ initialize_LA (void)
   if (!nLA)
     nLA = 1;
 
-  pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
+  bitsetv pLA = LA = bitsetv_create (nLA, ntokens, BITSET_FIXED);
 
   /* Initialize the members LOOKAHEAD_TOKENS for each state whose reductions
      require lookahead tokens.  */
-  for (i = 0; i < nstates; i++)
+  for (state_number i = 0; i < nstates; ++i)
     {
       int count =
         state_lookahead_tokens_count (states[i],
@@ -411,31 +385,30 @@ initialize_LA (void)
 static void
 lookahead_tokens_print (FILE *out)
 {
-  state_number i;
-  int j, k;
   fprintf (out, "Lookahead tokens: BEGIN\n");
-  for (i = 0; i < nstates; ++i)
+  for (state_number i = 0; i < nstates; ++i)
     {
-      reductions *reds = states[i]->reductions;
-      bitset_iterator iter;
+      const reductions *reds = states[i]->reductions;
       int n_lookahead_tokens = 0;
 
       if (reds->lookahead_tokens)
-        for (k = 0; k < reds->num; ++k)
-          if (reds->lookahead_tokens[k])
+        for (int j = 0; j < reds->num; ++j)
+          if (reds->lookahead_tokens[j])
             ++n_lookahead_tokens;
 
       fprintf (out, "State %d: %d lookahead tokens\n",
                i, n_lookahead_tokens);
 
       if (reds->lookahead_tokens)
-        for (j = 0; j < reds->num; ++j)
-          BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0)
+        for (int j = 0; j < reds->num; ++j)
           {
-            fprintf (out, "   on %d (%s) -> rule %d\n",
-                     k, symbols[k]->tag,
-                     reds->rules[j]->number);
-          };
+            bitset_iterator iter;
+            int k;
+            BITSET_FOR_EACH (iter, reds->lookahead_tokens[j], k, 0)
+              fprintf (out, "   on %d (%s) -> rule %d\n",
+                       k, symbols[k]->tag,
+                       reds->rules[j]->number);
+          }
     }
   fprintf (out, "Lookahead tokens: END\n");
 }
@@ -462,25 +435,23 @@ lalr_update_state_numbers (state_number old_to_new[], state_number nstates_old)
   goto_number ngotos_reachable = 0;
   symbol_number nonterminal = 0;
   aver (nsyms == nvars + ntokens);
-  {
-    goto_number i;
-    for (i = 0; i < ngotos; ++i)
-      {
-        while (i == goto_map[nonterminal])
-          goto_map[nonterminal++] = ngotos_reachable;
-        /* If old_to_new[from_state[i]] = nstates_old, remove this goto
-           entry.  */
-        if (old_to_new[from_state[i]] != nstates_old)
-          {
-            /* from_state[i] is not removed, so it and thus to_state[i] are
-               reachable, so to_state[i] != nstates_old.  */
-            aver (old_to_new[to_state[i]] != nstates_old);
-            from_state[ngotos_reachable] = old_to_new[from_state[i]];
-            to_state[ngotos_reachable] = old_to_new[to_state[i]];
-            ++ngotos_reachable;
-          }
-      }
-  }
+
+  for (goto_number i = 0; i < ngotos; ++i)
+    {
+      while (i == goto_map[nonterminal])
+        goto_map[nonterminal++] = ngotos_reachable;
+      /* If old_to_new[from_state[i]] = nstates_old, remove this goto
+         entry.  */
+      if (old_to_new[from_state[i]] != nstates_old)
+        {
+          /* from_state[i] is not removed, so it and thus to_state[i] are
+             reachable, so to_state[i] != nstates_old.  */
+          aver (old_to_new[to_state[i]] != nstates_old);
+          from_state[ngotos_reachable] = old_to_new[from_state[i]];
+          to_state[ngotos_reachable] = old_to_new[to_state[i]];
+          ++ngotos_reachable;
+        }
+    }
   while (nonterminal <= nvars)
     {
       aver (ngotos == goto_map[nonterminal]);
@@ -493,8 +464,7 @@ lalr_update_state_numbers (state_number old_to_new[], state_number nstates_old)
 void
 lalr_free (void)
 {
-  state_number s;
-  for (s = 0; s < nstates; ++s)
+  for (state_number s = 0; s < nstates; ++s)
     states[s]->reductions->lookahead_tokens = NULL;
   bitsetv_free (LA);
 }