xref: /freebsd-11-stable/contrib/binutils/gas/hash.c

/* hash.c - hash table lookup strings -
   Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 1998
   Free Software Foundation, Inc.

   This file is part of GAS, the GNU Assembler.

   GAS is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   GAS is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with GAS; see the file COPYING.  If not, write to
   the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

/*
 * BUGS, GRIPES, APOLOGIA etc.
 *
 * A typical user doesn't need ALL this: I intend to make a library out
 * of it one day - Dean Elsner.
 * Also, I want to change the definition of a symbol to (address,length)
 * so I can put arbitrary binary in the names stored. [see hsh.c for that]
 *
 * This slime is common coupled inside the module. Com-coupling (and other
 * vandalism) was done to speed running time. The interfaces at the
 * module's edges are adequately clean.
 *
 * There is no way to (a) run a test script through this heap and (b)
 * compare results with previous scripts, to see if we have broken any
 * code. Use GNU (f)utilities to do this. A few commands assist test.
 * The testing is awkward: it tries to be both batch & interactive.
 * For now, interactive rules!
 */

/*
 *  The idea is to implement a symbol table. A test jig is here.
 *  Symbols are arbitrary strings; they can't contain '\0'.
 *	[See hsh.c for a more general symbol flavour.]
 *  Each symbol is associated with a char*, which can point to anything
 *  you want, allowing an arbitrary property list for each symbol.
 *
 *  The basic operations are:
 *
 *    new                     creates symbol table, returns handle
 *    find (symbol)           returns char*
 *    insert (symbol,char*)   error if symbol already in table
 *    delete (symbol)         returns char* if symbol was in table
 *    apply                   so you can delete all symbols before die()
 *    die                     destroy symbol table (free up memory)
 *
 *  Supplementary functions include:
 *
 *    say                     how big? what % full?
 *    replace (symbol,newval) report previous value
 *    jam (symbol,value)      assert symbol:=value
 *
 *  You, the caller, have control over errors: this just reports them.
 *
 *  This package requires malloc(), free().
 *  Malloc(size) returns NULL or address of char[size].
 *  Free(address) frees same.
 */

/*
 *  The code and its structures are re-enterent.
 *
 *  Before you do anything else, you must call hash_new() which will
 *  return the address of a hash-table-control-block.  You then use
 *  this address as a handle of the symbol table by passing it to all
 *  the other hash_...() functions.  The only approved way to recover
 *  the memory used by the symbol table is to call hash_die() with the
 *  handle of the symbol table.
 *
 *  Before you call hash_die() you normally delete anything pointed to
 *  by individual symbols. After hash_die() you can't use that symbol
 *  table again.
 *
 *  The char* you associate with a symbol may not be NULL (0) because
 *  NULL is returned whenever a symbol is not in the table. Any other
 *  value is OK, except DELETED, #defined below.
 *
 *  When you supply a symbol string for insertion, YOU MUST PRESERVE THE
 *  STRING until that symbol is deleted from the table. The reason is that
 *  only the address you supply, NOT the symbol string itself, is stored
 *  in the symbol table.
 *
 *  You may delete and add symbols arbitrarily.
 *  Any or all symbols may have the same 'value' (char *). In fact, these
 *  routines don't do anything with your symbol values.
 *
 *  You have no right to know where the symbol:char* mapping is stored,
 *  because it moves around in memory; also because we may change how it
 *  works and we don't want to break your code do we? However the handle
 *  (address of struct hash_control) is never changed in
 *  the life of the symbol table.
 *
 *  What you CAN find out about a symbol table is:
 *    how many slots are in the hash table?
 *    how many slots are filled with symbols?
 *    (total hashes,collisions) for (reads,writes) (*)
 *  All of the above values vary in time.
 *  (*) some of these numbers will not be meaningful if we change the
 *  internals. */

/*
 *  I N T E R N A L
 *
 *  Hash table is an array of hash_entries; each entry is a pointer to a
 *  a string and a user-supplied value 1 char* wide.
 *
 *  The array always has 2 ** n elements, n>0, n integer.
 *  There is also a 'wall' entry after the array, which is always empty
 *  and acts as a sentinel to stop running off the end of the array.
 *  When the array gets too full, we create a new array twice as large
 *  and re-hash the symbols into the new array, then forget the old array.
 *  (Of course, we copy the values into the new array before we junk the
 *  old array!)
 *
 */

#include <stdio.h>

#ifndef FALSE
#define FALSE	(0)
#define TRUE	(!FALSE)
#endif /* no FALSE yet */

#include <ctype.h>
#define min(a, b)	((a) < (b) ? (a) : (b))

#include "as.h"

#define error	as_fatal

static char _deleted_[1];
#define DELETED     ((PTR)_deleted_)	/* guarenteed unique address */
#define START_POWER    (10)	/* power of two: size of new hash table */

/* TRUE if a symbol is in entry @ ptr.  */
#define islive(ptr) (ptr->hash_string && ptr->hash_string!=DELETED)

enum stat_enum {
  /* Number of slots in hash table.  The wall does not count here.
     We expect this is always a power of 2.  */
  STAT_SIZE = 0,
  /* Number of hash_ask calls.  */
  STAT_ACCESS,
  STAT_ACCESS_w,
  /* Number of collisions (total).  This may exceed STAT_ACCESS if we
     have lots of collisions/access.  */
  STAT_COLLIDE,
  STAT_COLLIDE_w,
  /* Slots used right now.  */
  STAT_USED,
  /* How many string compares?  */
  STAT_STRCMP,
  STAT_STRCMP_w,
  /* Size of statistics block... this must be last.  */
  STATLENGTH
};
#define STAT__READ     (0)	/* reading */
#define STAT__WRITE    (1)	/* writing */

/* When we grow a hash table, by what power of two do we increase it?  */
#define GROW_FACTOR 1
/* When should we grow it?  */
#define FULL_VALUE(N)	((N) / 2)

/* #define SUSPECT to do runtime checks */
/* #define TEST to be a test jig for hash...() */

#ifdef TEST
/* TEST: use smaller hash table */
#undef  START_POWER
#define START_POWER (3)
#undef  START_SIZE
#define START_SIZE  (8)
#undef  START_FULL
#define START_FULL  (4)
#endif

struct hash_entry
{
  const char *hash_string;	/* points to where the symbol string is */
  /* NULL means slot is not used */
  /* DELETED means slot was deleted */
  PTR hash_value;		/* user's datum, associated with symbol */
  unsigned long h;
};

struct hash_control {
  struct hash_entry *hash_where;/* address of hash table */
  int hash_sizelog;		/* Log of ( hash_mask + 1 ) */
  int hash_mask;		/* masks a hash into index into table */
  int hash_full;		/* when hash_stat[STAT_USED] exceeds this, */
  /* grow table */
  struct hash_entry *hash_wall;	/* point just after last (usable) entry */
  /* here we have some statistics */
  int hash_stat[STATLENGTH];	/* lies & statistics */
};

/*------------------ plan ---------------------------------- i = internal

  struct hash_control * c;
  struct hash_entry   * e;                                                    i
  int                   b[z];     buffer for statistics
  z         size of b
  char                * s;        symbol string (address) [ key ]
  char                * v;        value string (address)  [datum]
  boolean               f;        TRUE if we found s in hash table            i
  char                * t;        error string; 0 means OK
  int                   a;        access type [0...n)                         i

  c=hash_new       ()             create new hash_control

  hash_die         (c)            destroy hash_control (and hash table)
  table should be empty.
  doesn't check if table is empty.
  c has no meaning after this.

  hash_say         (c,b,z)        report statistics of hash_control.
  also report number of available statistics.

  v=hash_delete    (c,s)          delete symbol, return old value if any.
  ask()                       NULL means no old value.
  f

  v=hash_replace   (c,s,v)        replace old value of s with v.
  ask()                       NULL means no old value: no table change.
  f

  t=hash_insert    (c,s,v)        insert (s,v) in c.
  ask()                       return error string.
  f                           it is an error to insert if s is already
  in table.
  if any error, c is unchanged.

  t=hash_jam       (c,s,v)        assert that new value of s will be v.       i
  ask()                       it may decide to GROW the table.            i
  f                                                                       i
  grow()                                                                  i
  t=hash_grow      (c)            grow the hash table.                        i
  jam()                       will invoke JAM.                            i

  ?=hash_apply     (c,y)          apply y() to every symbol in c.
  y                           evtries visited in 'unspecified' order.

  v=hash_find      (c,s)          return value of s, or NULL if s not in c.
  ask()
  f

  f,e=hash_ask()   (c,s,a)        return slot where s SHOULD live.            i
  code()                      maintain collision stats in c.              i

  .=hash_code      (c,s)          compute hash-code for s,                    i
  from parameters of c.                       i

  */

/* Returned by hash_ask() to stop extra testing. hash_ask() wants to
   return both a slot and a status. This is the status.  TRUE: found
   symbol FALSE: absent: empty or deleted slot Also returned by
   hash_jam().  TRUE: we replaced a value FALSE: we inserted a value.  */
static char hash_found;

static struct hash_entry *hash_ask PARAMS ((struct hash_control *,
					    const char *, int));
static int hash_code PARAMS ((struct hash_control *, const char *));
static const char *hash_grow PARAMS ((struct hash_control *));

/* Create a new hash table.  Return NULL if failed; otherwise return handle
   (address of struct hash).  */
struct hash_control *
hash_new ()
{
  struct hash_control *retval;
  struct hash_entry *room;	/* points to hash table */
  struct hash_entry *wall;
  struct hash_entry *entry;
  int *ip;		/* scan stats block of struct hash_control */
  int *nd;		/* limit of stats block */

  room = (struct hash_entry *) xmalloc (sizeof (struct hash_entry)
					/* +1 for the wall entry */
					* ((1 << START_POWER) + 1));
  retval = (struct hash_control *) xmalloc (sizeof (struct hash_control));

  nd = retval->hash_stat + STATLENGTH;
  for (ip = retval->hash_stat; ip < nd; ip++)
    *ip = 0;

  retval->hash_stat[STAT_SIZE] = 1 << START_POWER;
  retval->hash_mask = (1 << START_POWER) - 1;
  retval->hash_sizelog = START_POWER;
  /* works for 1's compl ok */
  retval->hash_where = room;
  retval->hash_wall =
    wall = room + (1 << START_POWER);
  retval->hash_full = FULL_VALUE (1 << START_POWER);
  for (entry = room; entry <= wall; entry++)
    entry->hash_string = NULL;
  return retval;
}

/*
 *           h a s h _ d i e ( )
 *
 * Table should be empty, but this is not checked.
 * To empty the table, try hash_apply()ing a symbol deleter.
 * Return to free memory both the hash table and it's control
 * block.
 * 'handle' has no meaning after this function.
 * No errors are recoverable.
 */
void
hash_die (handle)
     struct hash_control *handle;
{
  free ((char *) handle->hash_where);
  free ((char *) handle);
}

#ifdef TEST
/*
 *           h a s h _ s a y ( )
 *
 * Return the size of the statistics table, and as many statistics as
 * we can until either (a) we have run out of statistics or (b) caller
 * has run out of buffer.
 * NOTE: hash_say treats all statistics alike.
 * These numbers may change with time, due to insertions, deletions
 * and expansions of the table.
 * The first "statistic" returned is the length of hash_stat[].
 * Then contents of hash_stat[] are read out (in ascending order)
 * until your buffer or hash_stat[] is exausted.
 */
static void
hash_say (handle, buffer, bufsiz)
     struct hash_control *handle;
     int buffer[ /*bufsiz*/ ];
     int bufsiz;
{
  int *nd;		/* limit of statistics block */
  int *ip;		/* scan statistics */

  ip = handle->hash_stat;
  nd = ip + min (bufsiz - 1, STATLENGTH);
  if (bufsiz > 0)		/* trust nothing! bufsiz<=0 is dangerous */
    {
      *buffer++ = STATLENGTH;
      for (; ip < nd; ip++, buffer++)
	{
	  *buffer = *ip;
	}
    }
}
#endif

/*
 *           h a s h _ d e l e t e ( )
 *
 * Try to delete a symbol from the table.
 * If it was there, return its value (and adjust STAT_USED).
 * Otherwise, return NULL.
 * Anyway, the symbol is not present after this function.
 *
 */
PTR				/* NULL if string not in table, else */
/* returns value of deleted symbol */
hash_delete (handle, string)
     struct hash_control *handle;
     const char *string;
{
  PTR retval;
  struct hash_entry *entry;

  entry = hash_ask (handle, string, STAT__WRITE);
  if (hash_found)
    {
      retval = entry->hash_value;
      entry->hash_string = DELETED;
      handle->hash_stat[STAT_USED] -= 1;
#ifdef SUSPECT
      if (handle->hash_stat[STAT_USED] < 0)
	{
	  error ("hash_delete");
	}
#endif /* def SUSPECT */
    }
  else
    {
      retval = NULL;
    }
  return (retval);
}

/*
 *                   h a s h _ r e p l a c e ( )
 *
 * Try to replace the old value of a symbol with a new value.
 * Normally return the old value.
 * Return NULL and don't change the table if the symbol is not already
 * in the table.
 */
PTR
hash_replace (handle, string, value)
     struct hash_control *handle;
     const char *string;
     PTR value;
{
  struct hash_entry *entry;
  char *retval;

  entry = hash_ask (handle, string, STAT__WRITE);
  if (hash_found)
    {
      retval = entry->hash_value;
      entry->hash_value = value;
    }
  else
    {
      retval = NULL;
    }
  ;
  return retval;
}

/*
 *                   h a s h _ i n s e r t ( )
 *
 * Insert a (symbol-string, value) into the hash table.
 * Return an error string, 0 means OK.
 * It is an 'error' to insert an existing symbol.
 */

const char *			/* return error string */
hash_insert (handle, string, value)
     struct hash_control *handle;
     const char *string;
     PTR value;
{
  struct hash_entry *entry;
  const char *retval;

  retval = 0;
  if (handle->hash_stat[STAT_USED] > handle->hash_full)
    {
      retval = hash_grow (handle);
    }
  if (!retval)
    {
      entry = hash_ask (handle, string, STAT__WRITE);
      if (hash_found)
	{
	  retval = "exists";
	}
      else
	{
	  entry->hash_value = value;
	  entry->hash_string = string;
	  handle->hash_stat[STAT_USED] += 1;
	}
    }
  return retval;
}

/*
 *               h a s h _ j a m ( )
 *
 * Regardless of what was in the symbol table before, after hash_jam()
 * the named symbol has the given value. The symbol is either inserted or
 * (its value is) replaced.
 * An error message string is returned, 0 means OK.
 *
 * WARNING: this may decide to grow the hashed symbol table.
 * To do this, we call hash_grow(), WHICH WILL recursively CALL US.
 *
 * We report status internally: hash_found is TRUE if we replaced, but
 * false if we inserted.
 */
const char *
hash_jam (handle, string, value)
     struct hash_control *handle;
     const char *string;
     PTR value;
{
  const char *retval;
  struct hash_entry *entry;

  retval = 0;
  if (handle->hash_stat[STAT_USED] > handle->hash_full)
    {
      retval = hash_grow (handle);
    }
  if (!retval)
    {
      entry = hash_ask (handle, string, STAT__WRITE);
      if (!hash_found)
	{
	  entry->hash_string = string;
	  handle->hash_stat[STAT_USED] += 1;
	}
      entry->hash_value = value;
    }
  return retval;
}

/*
 *               h a s h _ g r o w ( )
 *
 * Grow a new (bigger) hash table from the old one.
 * We choose to double the hash table's size.
 * Return a human-scrutible error string: 0 if OK.
 * Warning! This uses hash_jam(), which had better not recurse
 * back here! Hash_jam() conditionally calls us, but we ALWAYS
 * call hash_jam()!
 * Internal.
 */
static const char *
hash_grow (handle)		/* make a hash table grow */
     struct hash_control *handle;
{
  struct hash_entry *newwall;
  struct hash_entry *newwhere;
  struct hash_entry *newtrack;
  struct hash_entry *oldtrack;
  struct hash_entry *oldwhere;
  struct hash_entry *oldwall;
  int temp;
  int newsize;
  const char *string;
  const char *retval;
#ifdef SUSPECT
  int oldused;
#endif

  /*
   * capture info about old hash table
   */
  oldwhere = handle->hash_where;
  oldwall = handle->hash_wall;
#ifdef SUSPECT
  oldused = handle->hash_stat[STAT_USED];
#endif
  /*
   * attempt to get enough room for a hash table twice as big
   */
  temp = handle->hash_stat[STAT_SIZE];
  newwhere = ((struct hash_entry *)
	      xmalloc ((unsigned long) ((temp << (GROW_FACTOR + 1))
					/* +1 for wall slot */
					* sizeof (struct hash_entry))));
  if (newwhere == NULL)
    return "no_room";

  /*
   * have enough room: now we do all the work.
   * double the size of everything in handle.
   */
  handle->hash_mask = ((handle->hash_mask + 1) << GROW_FACTOR) - 1;
  handle->hash_stat[STAT_SIZE] <<= GROW_FACTOR;
  newsize = handle->hash_stat[STAT_SIZE];
  handle->hash_where = newwhere;
  handle->hash_full <<= GROW_FACTOR;
  handle->hash_sizelog += GROW_FACTOR;
  handle->hash_wall = newwall = newwhere + newsize;
  /* Set all those pesky new slots to vacant.  */
  for (newtrack = newwhere; newtrack <= newwall; newtrack++)
    newtrack->hash_string = NULL;
  /* We will do a scan of the old table, the hard way, using the
   * new control block to re-insert the data into new hash table.  */
  handle->hash_stat[STAT_USED] = 0;
  for (oldtrack = oldwhere; oldtrack < oldwall; oldtrack++)
    if (((string = oldtrack->hash_string) != NULL) && string != DELETED)
      if ((retval = hash_jam (handle, string, oldtrack->hash_value)))
	return retval;

#ifdef SUSPECT
  if (handle->hash_stat[STAT_USED] != oldused)
    return "hash_used";
#endif

  /* We have a completely faked up control block.
     Return the old hash table.  */
  free ((char *) oldwhere);

  return 0;
}

#ifdef TEST
/*
 *          h a s h _ a p p l y ( )
 *
 * Use this to scan each entry in symbol table.
 * For each symbol, this calls (applys) a nominated function supplying the
 * symbol's value (and the symbol's name).
 * The idea is you use this to destroy whatever is associted with
 * any values in the table BEFORE you destroy the table with hash_die.
 * Of course, you can use it for other jobs; whenever you need to
 * visit all extant symbols in the table.
 *
 * We choose to have a call-you-back idea for two reasons:
 *  asthetic: it is a neater idea to use apply than an explicit loop
 *  sensible: if we ever had to grow the symbol table (due to insertions)
 *            then we would lose our place in the table when we re-hashed
 *            symbols into the new table in a different order.
 *
 * The order symbols are visited depends entirely on the hashing function.
 * Whenever you insert a (symbol, value) you risk expanding the table. If
 * you do expand the table, then the hashing function WILL change, so you
 * MIGHT get a different order of symbols visited. In other words, if you
 * want the same order of visiting symbols as the last time you used
 * hash_apply() then you better not have done any hash_insert()s or
 * hash_jam()s since the last time you used hash_apply().
 *
 * In future we may use the value returned by your nominated function.
 * One idea is to abort the scan if, after applying the function to a
 * certain node, the function returns a certain code.
 *
 * The function you supply should be of the form:
 *      void myfunct(string,value)
 *              char * string;        |* the symbol's name *|
 *              char * value;         |* the symbol's value *|
 *      {
 *        |* ... *|
 *      }
 *
 */
void
hash_apply (handle, function)
     struct hash_control *handle;
     void (*function) ();
{
  struct hash_entry *entry;
  struct hash_entry *wall;

  wall = handle->hash_wall;
  for (entry = handle->hash_where; entry < wall; entry++)
    {
      if (islive (entry))	/* silly code: tests entry->string twice! */
	{
	  (*function) (entry->hash_string, entry->hash_value);
	}
    }
}
#endif

/*
 *          h a s h _ f i n d ( )
 *
 * Given symbol string, find value (if any).
 * Return found value or NULL.
 */
PTR
hash_find (handle, string)
     struct hash_control *handle;
     const char *string;
{
  struct hash_entry *entry;

  entry = hash_ask (handle, string, STAT__READ);
  if (hash_found)
    return entry->hash_value;
  else
    return NULL;
}

/*
 *          h a s h _ a s k ( )
 *
 * Searches for given symbol string.
 * Return the slot where it OUGHT to live. It may be there.
 * Return hash_found: TRUE only if symbol is in that slot.
 * Access argument is to help keep statistics in control block.
 * Internal.
 */
static struct hash_entry *	/* string slot, may be empty or deleted */
hash_ask (handle, string, access_type)
     struct hash_control *handle;
     const char *string;
     int access_type;
{
  const char *s;
  struct hash_entry *slot;
  int collision;	/* count collisions */
  int strcmps;
  int hcode;

  /* start looking here */
  hcode = hash_code (handle, string);
  slot = handle->hash_where + (hcode & handle->hash_mask);

  handle->hash_stat[STAT_ACCESS + access_type] += 1;
  collision = strcmps = 0;
  hash_found = FALSE;
  while (((s = slot->hash_string) != NULL) && s != DELETED)
    {
      if (string == s)
	{
	  hash_found = TRUE;
	  break;
	}
      if (slot->h == (unsigned long) hcode)
	{
	  if (!strcmp (string, s))
	    {
	      hash_found = TRUE;
	      break;
	    }
	  strcmps++;
	}
      collision++;
      slot++;
    }
  /*
   * slot:                                                      return:
   *       in use:     we found string                           slot
   *       at empty:
   *                   at wall:        we fell off: wrap round   ????
   *                   in table:       dig here                  slot
   *       at DELETED: dig here                                  slot
   */
  if (slot == handle->hash_wall)
    {
      slot = handle->hash_where;/* now look again */
      while (((s = slot->hash_string) != NULL) && s != DELETED)
	{
	  if (string == s)
	    {
	      hash_found = TRUE;
	      break;
	    }
	  if (slot->h == (unsigned long) hcode)
	    {
	      if (!strcmp (string, s))
		{
		  hash_found = TRUE;
		  break;
		}
	      strcmps++;
	    }
	  collision++;
	  slot++;
	}
      /*
       * slot:                                                   return:
       *       in use: we found it                                slot
       *       empty:  wall:         ERROR IMPOSSIBLE             !!!!
       *               in table:     dig here                     slot
       *       DELETED:dig here                                   slot
       */
    }
  handle->hash_stat[STAT_COLLIDE + access_type] += collision;
  handle->hash_stat[STAT_STRCMP + access_type] += strcmps;
  if (!hash_found)
    slot->h = hcode;
  return slot;			/* also return hash_found */
}

/*
 *           h a s h _ c o d e
 *
 * Does hashing of symbol string to hash number.
 * Internal.
 */
static int
hash_code (handle, string)
     struct hash_control *handle;
     const char *string;
{
#if 1 /* There seems to be some interesting property of this function
	 that prevents the bfd version below from being an adequate
	 substitute.  @@ Figure out what this property is!  */
  long h;		/* hash code built here */
  long c;		/* each character lands here */
  int n;		/* Amount to shift h by */

  n = (handle->hash_sizelog - 3);
  h = 0;
  while ((c = *string++) != 0)
    {
      h += c;
      h = (h << 3) + (h >> n) + c;
    }
  return h;
#else
  /* from bfd */
  unsigned long h = 0;
  unsigned int len = 0;
  unsigned int c;

  while ((c = *string++) != 0)
    {
      h += c + (c << 17);
      h ^= h >> 2;
      ++len;
    }
  h += len + (len << 17);
  h ^= h >> 2;
  return h;
#endif
}

void
hash_print_statistics (file, name, h)
     FILE *file;
     const char *name;
     struct hash_control *h;
{
  unsigned long sz, used, pct;

  if (h == 0)
    return;

  sz = h->hash_stat[STAT_SIZE];
  used = h->hash_stat[STAT_USED];
  pct = (used * 100 + sz / 2) / sz;

  fprintf (file, "%s hash statistics:\n\t%lu/%lu slots used (%lu%%)\n",
	   name, used, sz, pct);

#define P(name, off)							\
  fprintf (file, "\t%-16s %6dr + %6dw = %7d\n", name,			\
	   h->hash_stat[off+STAT__READ],				\
	   h->hash_stat[off+STAT__WRITE],				\
	   h->hash_stat[off+STAT__READ] + h->hash_stat[off+STAT__WRITE])

  P ("accesses:", STAT_ACCESS);
  P ("collisions:", STAT_COLLIDE);
  P ("string compares:", STAT_STRCMP);

#undef P
}

/*
 * Here is a test program to exercise above.
 */
#ifdef TEST

#define TABLES (6)		/* number of hash tables to maintain */
/* (at once) in any testing */
#define STATBUFSIZE (12)	/* we can have 12 statistics */

int statbuf[STATBUFSIZE];	/* display statistics here */
char answer[100];		/* human farts here */
char *hashtable[TABLES];	/* we test many hash tables at once */
char *h;			/* points to curent hash_control */
char **pp;
char *p;
char *name;
char *value;
int size;
int used;
char command;
int number;			/* number 0:TABLES-1 of current hashed */
/* symbol table */

main ()
{
  void applicatee ();
  void destroy ();
  char *what ();
  int *ip;

  number = 0;
  h = 0;
  printf ("type h <RETURN> for help\n");
  for (;;)
    {
      printf ("hash_test command: ");
      gets (answer);
      command = answer[0];
      if (isupper (command))
	command = tolower (command);	/* ecch! */
      switch (command)
	{
	case '#':
	  printf ("old hash table #=%d.\n", number);
	  whattable ();
	  break;
	case '?':
	  for (pp = hashtable; pp < hashtable + TABLES; pp++)
	    {
	      printf ("address of hash table #%d control block is %xx\n"
		      ,pp - hashtable, *pp);
	    }
	  break;
	case 'a':
	  hash_apply (h, applicatee);
	  break;
	case 'd':
	  hash_apply (h, destroy);
	  hash_die (h);
	  break;
	case 'f':
	  p = hash_find (h, name = what ("symbol"));
	  printf ("value of \"%s\" is \"%s\"\n", name, p ? p : "NOT-PRESENT");
	  break;
	case 'h':
	  printf ("# show old, select new default hash table number\n");
	  printf ("? display all hashtable control block addresses\n");
	  printf ("a apply a simple display-er to each symbol in table\n");
	  printf ("d die: destroy hashtable\n");
	  printf ("f find value of nominated symbol\n");
	  printf ("h this help\n");
	  printf ("i insert value into symbol\n");
	  printf ("j jam value into symbol\n");
	  printf ("n new hashtable\n");
	  printf ("r replace a value with another\n");
	  printf ("s say what %% of table is used\n");
	  printf ("q exit this program\n");
	  printf ("x delete a symbol from table, report its value\n");
	  break;
	case 'i':
	  p = hash_insert (h, name = what ("symbol"), value = what ("value"));
	  if (p)
	    {
	      printf ("symbol=\"%s\"  value=\"%s\"  error=%s\n", name, value,
		      p);
	    }
	  break;
	case 'j':
	  p = hash_jam (h, name = what ("symbol"), value = what ("value"));
	  if (p)
	    {
	      printf ("symbol=\"%s\"  value=\"%s\"  error=%s\n", name, value, p);
	    }
	  break;
	case 'n':
	  h = hashtable[number] = (char *) hash_new ();
	  break;
	case 'q':
	  exit (EXIT_SUCCESS);
	case 'r':
	  p = hash_replace (h, name = what ("symbol"), value = what ("value"));
	  printf ("old value was \"%s\"\n", p ? p : "{}");
	  break;
	case 's':
	  hash_say (h, statbuf, STATBUFSIZE);
	  for (ip = statbuf; ip < statbuf + STATBUFSIZE; ip++)
	    {
	      printf ("%d ", *ip);
	    }
	  printf ("\n");
	  break;
	case 'x':
	  p = hash_delete (h, name = what ("symbol"));
	  printf ("old value was \"%s\"\n", p ? p : "{}");
	  break;
	default:
	  printf ("I can't understand command \"%c\"\n", command);
	  break;
	}
    }
}

char *
what (description)
     char *description;
{
  char *retval;
  char *malloc ();

  printf ("   %s : ", description);
  gets (answer);
  /* will one day clean up answer here */
  retval = malloc (strlen (answer) + 1);
  if (!retval)
    {
      error ("room");
    }
  (void) strcpy (retval, answer);
  return (retval);
}

void
destroy (string, value)
     char *string;
     char *value;
{
  free (string);
  free (value);
}


void
applicatee (string, value)
     char *string;
     char *value;
{
  printf ("%.20s-%.20s\n", string, value);
}

whattable ()			/* determine number: what hash table to use */
     /* also determine h: points to hash_control */
{

  for (;;)
    {
      printf ("   what hash table (%d:%d) ?  ", 0, TABLES - 1);
      gets (answer);
      sscanf (answer, "%d", &number);
      if (number >= 0 && number < TABLES)
	{
	  h = hashtable[number];
	  if (!h)
	    {
	      printf ("warning: current hash-table-#%d. has no hash-control\n", number);
	    }
	  return;
	}
      else
	{
	  printf ("invalid hash table number: %d\n", number);
	}
    }
}



#endif /* #ifdef TEST */

/* end of hash.c */