/* hash.c -- hash table routines for BFD
- Copyright (C) 1993, 94 Free Software Foundation, Inc.
+ Copyright 1993, 1994, 1995, 1997, 1999, 2001, 2002
+ Free Software Foundation, Inc.
Written by Steve Chamberlain <sac@cygnus.com>
This file is part of BFD, the Binary File Descriptor library.
#include "bfd.h"
#include "sysdep.h"
#include "libbfd.h"
-#include "obstack.h"
+#include "objalloc.h"
/*
SECTION
The function <<bfd_hash_table_init>> take as an argument a
function to use to create new entries. For a basic hash
table, use the function <<bfd_hash_newfunc>>. @xref{Deriving
- a New Hash Table Type} for why you would want to use a
+ a New Hash Table Type}, for why you would want to use a
different value for this argument.
@findex bfd_hash_allocate
- <<bfd_hash_table_init>> will create an obstack which will be
+ <<bfd_hash_table_init>> will create an objalloc which will be
used to allocate new entries. You may allocate memory on this
- obstack using <<bfd_hash_allocate>>.
+ objalloc using <<bfd_hash_allocate>>.
@findex bfd_hash_table_free
Use <<bfd_hash_table_free>> to free up all the memory that has
If the @var{create} argument is <<true>>, and a new entry is
created, the @var{copy} argument is used to decide whether to
- copy the string onto the hash table obstack or not. If
+ copy the string onto the hash table objalloc or not. If
@var{copy} is passed as <<false>>, you must be careful not to
deallocate or modify the string as long as the hash table
exists.
Write other derived routines
You will want to write other routines for your new hash table,
- as well.
+ as well.
You will want an initialization routine which calls the
initialization routine of the hash table you are deriving from
<<aout_link_hash_traverse>> in aoutx.h.
*/
-/* Obstack allocation and deallocation routines. */
-#define obstack_chunk_alloc malloc
-#define obstack_chunk_free free
-
/* The default number of entries to use when creating a hash table. */
#define DEFAULT_SIZE (4051)
unsigned int alloc;
alloc = size * sizeof (struct bfd_hash_entry *);
- if (!obstack_begin (&table->memory, alloc))
+
+ table->memory = (PTR) objalloc_create ();
+ if (table->memory == NULL)
{
bfd_set_error (bfd_error_no_memory);
return false;
}
table->table = ((struct bfd_hash_entry **)
- obstack_alloc (&table->memory, alloc));
- if (!table->table)
+ objalloc_alloc ((struct objalloc *) table->memory, alloc));
+ if (table->table == NULL)
{
bfd_set_error (bfd_error_no_memory);
return false;
bfd_hash_table_free (table)
struct bfd_hash_table *table;
{
- obstack_free (&table->memory, (PTR) NULL);
+ objalloc_free ((struct objalloc *) table->memory);
+ table->memory = NULL;
}
/* Look up a string in a hash table. */
struct bfd_hash_entry *hashp;
unsigned int len;
unsigned int index;
-
+
hash = 0;
len = 0;
s = (const unsigned char *) string;
{
hash += c + (c << 17);
hash ^= hash >> 2;
- ++len;
}
+ len = (s - (const unsigned char *) string) - 1;
hash += len + (len << 17);
hash ^= hash >> 2;
{
char *new;
- new = (char *) obstack_alloc (&table->memory, len + 1);
+ new = (char *) objalloc_alloc ((struct objalloc *) table->memory,
+ len + 1);
if (!new)
{
bfd_set_error (bfd_error_no_memory);
return (struct bfd_hash_entry *) NULL;
}
- strcpy (new, string);
+ memcpy (new, string, len + 1);
string = new;
}
hashp->string = string;
bfd_hash_newfunc (entry, table, string)
struct bfd_hash_entry *entry;
struct bfd_hash_table *table;
- const char *string;
+ const char *string ATTRIBUTE_UNUSED;
{
if (entry == (struct bfd_hash_entry *) NULL)
entry = ((struct bfd_hash_entry *)
{
PTR ret;
- ret = obstack_alloc (&table->memory, size);
+ ret = objalloc_alloc ((struct objalloc *) table->memory, size);
if (ret == NULL && size != 0)
bfd_set_error (bfd_error_no_memory);
return ret;
_bfd_stringtab_init ()
{
struct bfd_strtab_hash *table;
+ bfd_size_type amt = sizeof (struct bfd_strtab_hash);
- table = (struct bfd_strtab_hash *) malloc (sizeof (struct bfd_strtab_hash));
+ table = (struct bfd_strtab_hash *) bfd_malloc (amt);
if (table == NULL)
- {
- bfd_set_error (bfd_error_no_memory);
- return NULL;
- }
+ return NULL;
if (! bfd_hash_table_init (&table->table, strtab_hash_newfunc))
{
for (entry = tab->first; entry != NULL; entry = entry->next)
{
- register const char *str;
- register size_t len;
+ const char *str;
+ size_t len;
str = entry->root.string;
len = strlen (str) + 1;
bfd_byte buf[2];
/* The output length includes the null byte. */
- bfd_put_16 (abfd, len, buf);
- if (bfd_write ((PTR) buf, 1, 2, abfd) != 2)
+ bfd_put_16 (abfd, (bfd_vma) len, buf);
+ if (bfd_bwrite ((PTR) buf, (bfd_size_type) 2, abfd) != 2)
return false;
}
- if (bfd_write ((PTR) str, 1, len, abfd) != len)
+ if (bfd_bwrite ((PTR) str, (bfd_size_type) len, abfd) != len)
return false;
}