X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/33f7f342c349a8bdb87bbb6b420ae56133115221..ddb9db15:/src/tables.c

diff --git a/src/tables.c b/src/tables.c
index f99f07b2..87b6b76d 100644
--- a/src/tables.c
+++ b/src/tables.c
@@ -1,6 +1,6 @@
 /* Output the generated parsing program for Bison.
 
-   Copyright (C) 1984, 1986, 1989, 1992, 2000-2006, 2009-2012 Free
+   Copyright (C) 1984, 1986, 1989, 1992, 2000-2006, 2009-2013 Free
    Software Foundation, Inc.
 
    This file is part of Bison, the GNU Compiler Compiler.
@@ -395,7 +395,7 @@ save_row (state_number s)
       base_number *sp1 = froms[s] = xnmalloc (count, sizeof *sp1);
       base_number *sp2 = tos[s] = xnmalloc (count, sizeof *sp2);
       unsigned int *sp3 = conflict_tos[s] =
-        nondeterministic_parser ? xnmalloc (count, sizeof *sp3) : NULL;;
+        nondeterministic_parser ? xnmalloc (count, sizeof *sp3) : NULL;
 
       /* Store non defaulted actions.  */
       for (i = 0; i < ntokens; i++)
@@ -513,37 +513,38 @@ save_column (symbol_number sym, state_number default_state)
 }
 
 
-/*-------------------------------------------------------------.
-| Return `the' most common destination GOTO on SYM (a nterm).  |
-`-------------------------------------------------------------*/
+/*----------------------------------------------------------------.
+| The default state for SYM: the state which is 'the' most common |
+| GOTO destination on SYM (an nterm).                             |
+`----------------------------------------------------------------*/
 
 static state_number
 default_goto (symbol_number sym, size_t state_count[])
 {
-  state_number s;
-  goto_number i;
-  goto_number m = goto_map[sym - ntokens];
-  goto_number n = goto_map[sym - ntokens + 1];
-  state_number default_state = -1;
-  size_t max = 0;
-
-  if (m == n)
-    return -1;
+  goto_number begin = goto_map[sym - ntokens];
+  goto_number end = goto_map[sym - ntokens + 1];
+  state_number res = -1;
 
-  for (s = 0; s < nstates; s++)
-    state_count[s] = 0;
+  if (begin != end)
+    {
+      size_t max = 0;
+      goto_number i;
+      state_number s;
 
-  for (i = m; i < n; i++)
-    state_count[to_state[i]]++;
+      for (s = 0; s < nstates; s++)
+        state_count[s] = 0;
 
-  for (s = 0; s < nstates; s++)
-    if (state_count[s] > max)
-      {
-        max = state_count[s];
-        default_state = s;
-      }
+      for (i = begin; i < end; i++)
+        state_count[to_state[i]]++;
 
-  return default_state;
+      for (s = 0; s < nstates; s++)
+        if (max < state_count[s])
+          {
+            max = state_count[s];
+            res = s;
+          }
+    }
+  return res;
 }
 
 
@@ -620,47 +621,43 @@ static state_number
 matching_state (vector_number vector)
 {
   vector_number i = order[vector];
-  size_t t;
-  int w;
-  int prev;
-
   /* If VECTOR is a nterm, return -1.  */
-  if (nstates <= i)
-    return -1;
-
-  t = tally[i];
-  w = width[i];
-
-  /* If VECTOR has GLR conflicts, return -1 */
-  if (conflict_tos[i] != NULL)
+  if (i < nstates)
     {
-      int j;
-      for (j = 0; j < t; j += 1)
-        if (conflict_tos[i][j] != 0)
-          return -1;
-    }
+      size_t t = tally[i];
+      int w = width[i];
+      int prev;
 
-  for (prev = vector - 1; prev >= 0; prev--)
-    {
-      vector_number j = order[prev];
-      int k;
-      int match = 1;
-
-      /* Given how ORDER was computed, if the WIDTH or TALLY is
-         different, there cannot be a matching state.  */
-      if (width[j] != w || tally[j] != t)
-        return -1;
-
-      for (k = 0; match && k < t; k++)
-        if (tos[j][k] != tos[i][k]
-            || froms[j][k] != froms[i][k]
-            || (conflict_tos[j] != NULL && conflict_tos[j][k] != 0))
-          match = 0;
-
-      if (match)
-        return j;
-    }
+      /* If VECTOR has GLR conflicts, return -1 */
+      if (conflict_tos[i] != NULL)
+        {
+          int j;
+          for (j = 0; j < t; j += 1)
+            if (conflict_tos[i][j] != 0)
+              return -1;
+        }
 
+      for (prev = vector - 1; 0 <= prev; prev--)
+        {
+          vector_number j = order[prev];
+          /* Given how ORDER was computed, if the WIDTH or TALLY is
+             different, there cannot be a matching state.  */
+          if (width[j] != w || tally[j] != t)
+            return -1;
+          else
+            {
+              bool match = true;
+              int k;
+              for (k = 0; match && k < t; k++)
+                if (tos[j][k] != tos[i][k]
+                    || froms[j][k] != froms[i][k]
+                    || (conflict_tos[j] != NULL && conflict_tos[j][k] != 0))
+                  match = false;
+              if (match)
+                return j;
+            }
+        }
+    }
   return -1;
 }