Initial check in. Preliminary development stage.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@46 138bc75d-0d04-0410-961f-82ee72b054a4

gcc/objc/hash.c

+/* -*-c-*-
+ * This file contains the hashing implementation.
+ *
+  $Header$
+  $Author$
+  $Date$
+  $Log$
+*/
+ 
+
+#include  <hash.h>
+#include  <ObjC.h>
+
+#include  <assert.h>
+#include  <libc.h>
+#include  <math.h>
+
+
+                                                /* Local forward decl. */
+  u_int hashValue( Cache_t, void* );
+
+
+Cache_t hash_new( u_int numberOfBuckets ) {
+
+  Cache_t retCache;
+  int     i;
+
+
+  assert( numberOfBuckets );
+
+                                                /* Allocate the cache 
+                                                  structure.  calloc() insures
+                                                  its initialization for
+                                                  default values. */
+  retCache = calloc( 1, sizeof( Cache ));
+  assert( retCache );
+  
+                                                /* Allocate the array of 
+                                                  buckets for the cache.  
+                                                  calloc() initializes all of 
+                                                  the pointers to NULL. */
+  retCache->theNodeTable = calloc( numberOfBuckets, sizeof( CacheNode_t ));
+  assert( retCache->theNodeTable );
+  
+  retCache->numberOfBuckets = numberOfBuckets;
+
+                                                /* Calculate the number of 
+                                                  bits required to represent 
+                                                  the hash mask. */
+  retCache->numberOfMaskBits = 
+    ceil( log( retCache->numberOfBuckets ) / log( 2 ));
+
+                                                /* Form a bit mask for the 
+                                                  hash. */
+  for( i = 0; i < retCache->numberOfMaskBits; ++i )
+    retCache->mask = ( retCache->mask << 1 ) | 0x01 ;
+
+  assert( retCache->numberOfMaskBits );
+  assert( retCache->mask );
+
+  return retCache;
+}
+
+
+void hash_delete( Cache_t theCache ) {
+
+  void* aNode;
+  
+
+                                                /* Purge all key/value pairs 
+                                                  from the table. */
+  while( aNode = hash_next( theCache, NULL ))
+    hash_remove( theCache, aNode );
+
+                                                /* Release the array of nodes 
+                                                  and the cache itself. */
+  free( theCache->theNodeTable );
+  free( theCache );
+}
+
+
+void hash_add( Cache_t theCache, void* aKey, void* aValue ) {
+
+  u_int       indx = hashValue( theCache, aKey );
+  CacheNode_t aCacheNode = calloc( 1, sizeof( CacheNode ));
+
+
+  assert( aCacheNode );
+  
+                                                /* Initialize the new node. */
+  aCacheNode->theKey    = aKey;
+  aCacheNode->theValue  = aValue;
+  aCacheNode->nextNode  = ( *theCache->theNodeTable )[ indx ];
+  
+                                                /* Debugging.
+                                                
+                                                  Check the list for another 
+                                                  key. */
+#ifdef DEBUG
+    { CacheNode_t checkHashNode = ( *theCache->theNodeTable )[ indx ];
+    
+      while( checkHashNode ) {
+    
+        assert( checkHashNode->theKey != aKey );
+        checkHashNode = checkHashNode->nextNode;
+      }
+    }
+
+                                                /* Install the node as the
+                                                  first element on the list. */
+  ( *theCache->theNodeTable )[ indx ] = aCacheNode;
+
+#endif
+}
+
+
+void hash_remove( Cache_t theCache, void* aKey ) {
+
+  u_int       indx = hashValue( theCache, aKey );
+  CacheNode_t aCacheNode = ( *theCache->theNodeTable )[ indx ];
+  
+  
+                                                /* We assume there is an entry 
+                                                  in the table.  Error if it 
+                                                  is not. */
+  assert( aCacheNode );
+  
+                                                /* Special case.  First element 
+                                                  is the key/value pair to be 
+                                                  removed. */
+  if( aCacheNode->theKey == aKey ) {
+    ( *theCache->theNodeTable )[ indx ] = aCacheNode->nextNode;
+    free( aCacheNode );
+  } else {
+                                                /* Otherwise, find the hash 
+                                                  entry. */
+    CacheNode_t prevHashNode = aCacheNode;
+    BOOL        removed = NO;
+    
+    do {
+    
+      if( aCacheNode->theKey == aKey ) {
+        prevHashNode->nextNode = aCacheNode->nextNode, removed = YES;
+        free( aCacheNode );
+      } else
+        prevHashNode = aCacheNode, aCacheNode = aCacheNode->nextNode;
+    } while( !removed && aCacheNode );
+    assert( removed );
+  }
+}
+
+
+void* hash_value_for_key( Cache_t theCache, void* aKey ) {
+
+  u_int       indx = hashValue( theCache, aKey );
+  CacheNode_t aCacheNode = ( *theCache->theNodeTable )[ indx ];
+  void*       retVal = NULL;
+  
+
+  if( aCacheNode ) {
+    BOOL  found = NO;
+  
+    do {
+      if( aCacheNode->theKey == aKey )
+        retVal = aCacheNode->theValue, found = YES;
+      else
+        aCacheNode = aCacheNode->nextNode;
+    } while( !found && aCacheNode );
+  }
+  
+  return retVal;
+}
+
+
+CacheNode_t hash_next( Cache_t theCache, CacheNode_t aCacheNode ) {
+
+  CacheNode_t theCacheNode = aCacheNode;
+  
+  
+                                                /* If the scan is being started
+                                                  then reset the last node 
+                                                  visitied pointer and bucket 
+                                                  index. */
+  if( !theCacheNode )
+    theCache->lastBucket  = 0;
+  
+                                                /* If there is a node visited
+                                                  last then check for another 
+                                                  entry in the same bucket; 
+                                                  Otherwise step to the next 
+                                                  bucket. */
+  if( theCacheNode )
+    if( theCacheNode->nextNode )
+                                                /* There is a node which 
+                                                  follows the last node 
+                                                  returned.  Step to that node 
+                                                  and retun it. */
+      return theCacheNode->nextNode;
+    else
+      ++theCache->lastBucket;
+
+                                                /* If the list isn't exhausted 
+                                                  then search the buckets for 
+                                                  other nodes. */
+  if( theCache->lastBucket < theCache->numberOfBuckets ) {
+                                                /*  Scan the remainder of the 
+                                                  buckets looking for an entry
+                                                  at the head of the list.  
+                                                  Return the first item 
+                                                  found. */
+    while( theCache->lastBucket < theCache->numberOfBuckets )
+      if(( *theCache->theNodeTable )[ theCache->lastBucket ])
+        return ( *theCache->theNodeTable )[ theCache->lastBucket ];
+      else
+        ++theCache->lastBucket;
+  
+                                                /* No further nodes were found
+                                                  in the hash table. */
+    return NULL;
+  } else
+    return NULL;
+}
+
+
+u_int hashValue( Cache_t theCache, void* aKey ) {
+
+  u_int hash = 0;
+  int   i;
+  
+  
+  assert( theCache->numberOfMaskBits );
+  for( i = 0; i < ( sizeof( aKey ) * 8 ); i += theCache->numberOfMaskBits )
+    hash ^= (( u_int )aKey ) >> i ;
+
+  return ( hash & theCache->mask ) % theCache->numberOfBuckets;
+}
+

gcc/objc/hash.h

+/* -*-c-*-
+ * This is a general purpose hash object.
+ *
+ * The hash object used throughout the run-time
+ *  is an integer hash.  The key and data is of type
+ *  void*.  The hashing function converts the key to
+ *  an integer and computes it hash value.
+ *
+  $Header$
+  $Author$
+  $Date$
+  $Log$
+*/
+ 
+
+#ifndef _hash_INCLUDE_GNU
+#define _hash_INCLUDE_GNU
+
+                                                /* If someone is using a c++
+                                                  compiler then adjust the 
+                                                  types in the file back 
+                                                  to C. */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include  <sys/types.h>
+
+
+/*
+ * This data structure is used to hold items
+ *  stored in a hash table.  Each node holds 
+ *  a key/value pair.
+ *
+ * Items in the cache are really of type void*.
+ */
+typedef struct cache_node {
+  struct cache_node*  nextNode;                   /* Pointer to next entry on
+                                                    the list.  NULL indicates
+                                                    end of list. */
+  void*               theKey;                     /* Key used to locate the
+                                                    value.  Used to locate
+                                                    value when more than one
+                                                    key computes the same hash
+                                                    value. */
+  void*               theValue;                   /* Value stored for the
+                                                    key. */
+} CacheNode, *CacheNode_t;
+
+
+/*
+ * This data structure is the cache.
+ *
+ * It must be passed to all of the hashing routines
+ *  (except for new).
+ */
+typedef struct cache {
+  /*
+   * Variables used to implement the
+   *  hash itself.
+   */
+  CacheNode_t (* theNodeTable )[];                /* Pointer to an array of
+                                                    hash nodes. */
+  u_int       numberOfBuckets,                    /* Number of buckets 
+                                                    allocated for the hash
+                                                    table (number of array
+                                                    entries allocated for
+                                                    "theCache"). */
+              mask,                               /* Mask used when computing
+                                                    a hash value.  The number
+                                                    of bits set in the mask
+                                                    is contained in the next
+                                                    member variable. */
+              numberOfMaskBits;                   /* Number of bits used for
+                                                    the mask.  Useful for 
+                                                    efficient hash value
+                                                    calculation. */
+  /*
+   * Variables used to implement indexing
+   *  through the hash table.
+   */
+  u_int       lastBucket;                         /* Tracks which entry in the
+                                                    array where the last value
+                                                    was returned. */
+} Cache, *Cache_t;
+
+
+                                                /* Prototypes for hash
+                                                  functions. */
+                                                /* Allocate and initialize 
+                                                  a hash table.  Hash table 
+                                                  size taken as a parameter. 
+                                                    A value of 0 is not 
+                                                  allowed. */ 
+Cache_t hash_new( u_int numberOfBuckets );
+                                                /* Deallocate all of the
+                                                  hash nodes and the cache
+                                                  itself. */
+void hash_delete( Cache_t theCache );
+                                                /* Add the key/value pair
+                                                  to the hash table.  assert()
+                                                  if the key is already in
+                                                  the hash. */
+void hash_add( Cache_t theCache, void* aKey, void* aValue );
+                                                /* Remove the key/value pair
+                                                  from the hash table.  
+                                                  assert() if the key isn't 
+                                                  in the table. */
+void hash_remove( Cache_t theCache, void* aKey );
+                                                /* Given key, return its 
+                                                  value.  Return NULL if the
+                                                  key/value pair isn't in
+                                                  the hash. */
+void* hash_value_for_key( Cache_t theCache, void* aKey );
+                                                /* Used to index through the
+                                                  hash table.  Start with NULL
+                                                  to get the first entry.
+                                                  
+                                                  Successive calls pass the
+                                                  value returned previously.
+                                                  ** Don't modify the hash
+                                                  during this operation *** 
+                                                  
+                                                  Cache nodes are returned
+                                                  such that key or value can
+                                                  ber extracted. */
+CacheNode_t hash_next( Cache_t theCache, CacheNode_t aCacheNode );
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif