When reducing initial empty rules, Bison parser read an initial

[bison.git] / lib / hash.c

diff --git a/lib/hash.c b/lib/hash.c
index df8f4bd615c25b3b022cf90efc9ddd300e3cfeab..7373a011ceceef9f94faa1c5a55d1409139b7e52 100644 (file)
--- a/lib/hash.c
+++ b/lib/hash.c
@@ -1,5 +1,8 @@
 /* hash - hashing table processing.
 /* hash - hashing table processing.

-   Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
+
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software
+   Foundation, Inc.
+

    Written by Jim Meyering, 1992.
 
    This program is free software; you can redistribute it and/or modify
    Written by Jim Meyering, 1992.
 
    This program is free software; you can redistribute it and/or modify


@@ -27,13 +30,10 @@
 #if HAVE_STDLIB_H
 # include <stdlib.h>
 #endif
 #if HAVE_STDLIB_H
 # include <stdlib.h>
 #endif

-#if HAVE_STDBOOL_H
-# include <stdbool.h>
-#else
-typedef enum {false = 0, true = 1} bool;
-#endif
+
+#include <limits.h>
+#include <stdbool.h>

 #include <stdio.h>
 #include <stdio.h>

-#include <assert.h>

 
 #ifndef HAVE_DECL_FREE
 "this configure-time declaration test was not run"
 
 #ifndef HAVE_DECL_FREE
 "this configure-time declaration test was not run"


@@ -263,7 +263,8 @@ hash_lookup (const Hash_table *table, const void *entry)
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 

-  assert (bucket < table->bucket_limit);
+  if (! (bucket < table->bucket_limit))
+    abort ();

 
   if (bucket->data == NULL)
     return NULL;
 
   if (bucket->data == NULL)
     return NULL;


@@ -292,12 +293,11 @@ hash_get_first (const Hash_table *table)
   if (table->n_entries == 0)
     return NULL;
 
   if (table->n_entries == 0)
     return NULL;
 

-  for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
-    if (bucket->data)
+  for (bucket = table->bucket; ; bucket++)
+    if (! (bucket < table->bucket_limit))
+      abort ();
+    else if (bucket->data)

       return bucket->data;
       return bucket->data;

-
-  assert (0);
-  return NULL;

 }
 
 /* Return the user data for the entry following ENTRY, where ENTRY has been
 }
 
 /* Return the user data for the entry following ENTRY, where ENTRY has been


@@ -311,7 +311,8 @@ hash_get_next (const Hash_table *table, const void *entry)
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 

-  assert (bucket < table->bucket_limit);
+  if (! (bucket < table->bucket_limit))
+    abort ();

 
   /* Find next entry in the same bucket.  */
   for (cursor = bucket; cursor; cursor = cursor->next)
 
   /* Find next entry in the same bucket.  */
   for (cursor = bucket; cursor; cursor = cursor->next)


@@ -403,9 +404,6 @@ hash_do_for_each (const Hash_table *table, Hash_processor processor,
 unsigned
 hash_string (const char *string, unsigned n_buckets)
 {
 unsigned
 hash_string (const char *string, unsigned n_buckets)
 {

-# ifndef CHAR_BIT
-#  define CHAR_BIT 8
-# endif

 # define ROTATE_LEFT(Value, Shift) \
   ((Value) << (Shift) | (Value) >> ((sizeof (unsigned) * CHAR_BIT) - (Shift)))
 # define HASH_ONE_CHAR(Value, Byte) \
 # define ROTATE_LEFT(Value, Shift) \
   ((Value) << (Shift) | (Value) >> ((sizeof (unsigned) * CHAR_BIT) - (Shift)))
 # define HASH_ONE_CHAR(Value, Byte) \


@@ -754,7 +752,9 @@ hash_find_entry (Hash_table *table, const void *entry,
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 

-  assert (bucket < table->bucket_limit);
+  if (! (bucket < table->bucket_limit))
+    abort ();
+

   *bucket_head = bucket;
 
   /* Test for empty bucket.  */
   *bucket_head = bucket;
 
   /* Test for empty bucket.  */


@@ -848,7 +848,9 @@ hash_rehash (Hash_table *table, unsigned candidate)
            = (new_table->bucket
               + new_table->hasher (data, new_table->n_buckets));
 
            = (new_table->bucket
               + new_table->hasher (data, new_table->n_buckets));
 

-         assert (new_bucket < new_table->bucket_limit);
+         if (! (new_bucket < new_table->bucket_limit))
+           abort ();
+

          next = cursor->next;
 
          if (new_bucket->data)
          next = cursor->next;
 
          if (new_bucket->data)


@@ -912,7 +914,9 @@ hash_insert (Hash_table *table, const void *entry)
   void *data;
   struct hash_entry *bucket;
 
   void *data;
   struct hash_entry *bucket;
 

-  assert (entry);              /* cannot insert a NULL entry */
+  /* The caller cannot insert a NULL entry.  */
+  if (! entry)
+    abort ();

 
   /* If there's a matching entry already in the table, return that.  */
   if ((data = hash_find_entry (table, entry, &bucket, false)) != NULL)
 
   /* If there's a matching entry already in the table, return that.  */
   if ((data = hash_find_entry (table, entry, &bucket, false)) != NULL)