Fix for PR libgcj/6081:

[pf3gnuchains/gcc-fork.git] / gcc / hash.c

diff --git a/gcc/hash.c b/gcc/hash.c
index 473d0ff..5cf8397 100644 (file)
--- a/gcc/hash.c
+++ b/gcc/hash.c
@@ -1,5 +1,5 @@
 /* hash.c -- hash table routines
-   Copyright (C) 1993, 94 Free Software Foundation, Inc.
+   Copyright (C) 1993, 1994, 1998, 2001 Free Software Foundation, Inc.
    Written by Steve Chamberlain <sac@cygnus.com>
 
 This file was lifted from BFD, the Binary File Descriptor library.
@@ -16,7 +16,8 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA.  */
 
 #include "config.h"
 #include "system.h"
@@ -28,58 +29,46 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define obstack_chunk_alloc xmalloc
 #define obstack_chunk_free free
 
-extern char * xmalloc ();
-
 /* The default number of entries to use when creating a hash table.  */
-#define DEFAULT_SIZE (1009)
+#define DEFAULT_SIZE 1009
 
 /* Create a new hash table, given a number of entries.  */
 
-boolean
+void
 hash_table_init_n (table, newfunc, hash, comp, size)
      struct hash_table *table;
      struct hash_entry *(*newfunc) PARAMS ((struct hash_entry *,
                                            struct hash_table *,
                                            hash_table_key));
-     unsigned long (*hash) (hash_table_key);
-     boolean (*comp) (hash_table_key, hash_table_key);
+     unsigned long (*hash) PARAMS ((hash_table_key));
+     bool (*comp) PARAMS ((hash_table_key, hash_table_key));
      unsigned int size;
 {
   unsigned int alloc;
 
   alloc = size * sizeof (struct hash_entry *);
-  if (!obstack_begin (&table->memory, alloc))
-    {
-      error ("no memory");
-      return false;
-    }
+  obstack_begin (&table->memory, alloc);
   table->table = ((struct hash_entry **)
                  obstack_alloc (&table->memory, alloc));
-  if (!table->table)
-    {
-      error ("no memory");
-      return false;
-    }
   memset ((PTR) table->table, 0, alloc);
   table->size = size;
   table->newfunc = newfunc;
   table->hash = hash;
   table->comp = comp;
-  return true;
 }
 
 /* Create a new hash table with the default number of entries.  */
 
-boolean
+void
 hash_table_init (table, newfunc, hash, comp)
      struct hash_table *table;
      struct hash_entry *(*newfunc) PARAMS ((struct hash_entry *,
                                            struct hash_table *,
                                            hash_table_key));
      unsigned long (*hash) PARAMS ((hash_table_key));
-     boolean (*comp) PARAMS ((hash_table_key, hash_table_key));
+     bool (*comp) PARAMS ((hash_table_key, hash_table_key));
 {
-  return hash_table_init_n (table, newfunc, hash, comp, DEFAULT_SIZE);
+  hash_table_init_n (table, newfunc, hash, comp, DEFAULT_SIZE);
 }
 
 /* Free a hash table.  */
@@ -98,34 +87,32 @@ struct hash_entry *
 hash_lookup (table, key, create, copy)
      struct hash_table *table;
      hash_table_key key;
-     boolean create;
+     int create;
      hash_table_key (*copy) PARAMS ((struct obstack* memory, 
                                     hash_table_key key));
 {
-  register unsigned long hash;
+  unsigned long hash;
   struct hash_entry *hashp;
   unsigned int index;
   
   hash = (*table->hash)(key);
 
   index = hash % table->size;
-  for (hashp = table->table[index];
-       hashp != (struct hash_entry *) NULL;
-       hashp = hashp->next)
-    {
-      if (hashp->hash == hash
-         && (*table->comp)(hashp->key, key))
-       return hashp;
-    }
+  for (hashp = table->table[index]; hashp != 0; hashp = hashp->next)
+    if (hashp->hash == hash
+       && (*table->comp)(hashp->key, key))
+      return hashp;
 
   if (! create)
-    return (struct hash_entry *) NULL;
+    return 0;
 
   hashp = (*table->newfunc) ((struct hash_entry *) NULL, table, key);
-  if (hashp == (struct hash_entry *) NULL)
-    return (struct hash_entry *) NULL;
+  if (hashp == 0)
+    return 0;
+
   if (copy)
     key = (*copy) (&table->memory, key);
+
   hashp->key = key;
   hashp->hash = hash;
   hashp->next = table->table[index];
@@ -136,14 +123,13 @@ hash_lookup (table, key, create, copy)
 
 /* Base method for creating a new hash table entry.  */
 
-/*ARGSUSED*/
 struct hash_entry *
 hash_newfunc (entry, table, p)
      struct hash_entry *entry;
      struct hash_table *table;
-     hash_table_key p;
+     hash_table_key p ATTRIBUTE_UNUSED;
 {
-  if (entry == (struct hash_entry *) NULL)
+  if (entry == 0)
     entry = ((struct hash_entry *)
             hash_allocate (table, sizeof (struct hash_entry)));
   return entry;
@@ -156,12 +142,7 @@ hash_allocate (table, size)
      struct hash_table *table;
      unsigned int size;
 {
-  PTR ret;
-
-  ret = obstack_alloc (&table->memory, size);
-  if (ret == NULL && size != 0)
-    error ("no memory");
-  return ret;
+  return obstack_alloc (&table->memory, size);
 }
 
 /* Traverse a hash table.  */
@@ -169,21 +150,16 @@ hash_allocate (table, size)
 void
 hash_traverse (table, func, info)
      struct hash_table *table;
-     boolean (*func) PARAMS ((struct hash_entry *, hash_table_key));
+     bool (*func) PARAMS ((struct hash_entry *, hash_table_key));
      PTR info;
 {
   unsigned int i;
+  struct hash_entry *p;
 
   for (i = 0; i < table->size; i++)
-    {
-      struct hash_entry *p;
-
-      for (p = table->table[i]; p != NULL; p = p->next)
-       {
-         if (! (*func) (p, info))
-           return;
-       }
-    }
+    for (p = table->table[i]; p != 0; p = p->next)
+      if (! (*func) (p, info))
+       return;
 }
 
 /* Hash a string.  Return a hash-code for the string.  */
@@ -207,6 +183,7 @@ string_hash (k)
       hash ^= hash >> 2;
       ++len;
     }
+
   hash += len + (len << 17);
   hash ^= hash >> 2;
 
@@ -216,7 +193,7 @@ string_hash (k)
 /* Compare two strings.  Return non-zero iff the two strings are
    the same.  */
 
-boolean
+bool
 string_compare (k1, k2)
      hash_table_key k1;
      hash_table_key k2;
@@ -228,18 +205,13 @@ string_compare (k1, k2)
 
 hash_table_key
 string_copy (memory, k)
-     struct obstack* memory;
+     struct obstack *memory;
      hash_table_key k;
 {
   char *new;
-  char *string = (char*) k;
+  char *string = (char *) k;
 
   new = (char *) obstack_alloc (memory, strlen (string) + 1);
-  if (!new)
-    {
-      error ("no memory");
-      return NULL;
-    }
   strcpy (new, string);
   
   return new;