the executable file might be covered by the GNU General Public License. */
/*
- $Header: /usr/user/dennis_glatting/ObjC/c-runtime/dispatch.common/RCS/hash.c,v 0.12 1992/04/13 11:43:08 dennisg Exp dennisg $
- $Author: dennisg $
- $Date: 1992/04/13 11:43:08 $
+ $Header: /usr/user/dennis_glatting/ObjC/c-runtime/dispatch/RCS/hash.c,v 0.13 1992/08/18 04:46:58 dglattin Exp $
+ $Author: dglattin $
+ $Date: 1992/08/18 04:46:58 $
$Log: hash.c,v $
+ * Revision 0.13 1992/08/18 04:46:58 dglattin
+ * Saving a working version before release.
+ *
* Revision 0.12 1992/04/13 11:43:08 dennisg
* Check in after array version of run-time works.
* Expect more changes as hash version and other changes are made.
Cache_t retCache;
- /* Pass me a value greater
- than 0 and a power of 2. */
+ /* Pass me a value greater than 0 and a power of 2. */
assert(sizeOfHash);
- assert( !(sizeOfHash & (sizeOfHash - 1)));
+ assert( !(sizeOfHash & (sizeOfHash - 1)));
- /* Allocate the cache
- structure. calloc () insures
- its initialization for
- default values. */
+ /* 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. */
+ /* Allocate the array of buckets for the cache.
+ calloc() initializes all of the pointers to NULL. */
retCache->theNodeTable = calloc (sizeOfHash, sizeof (CacheNode_t));
assert(retCache->theNodeTable);
retCache->sizeOfHash = sizeOfHash;
- /* This should work for all
- processor architectures? */
- retCache->mask = ( sizeOfHash - 1 );
+ /* This should work for all processor architectures? */
+ retCache->mask = ( sizeOfHash - 1 );
- /* Store the hashing function
- so that codes can be
- computed. */
- retCache->hashFunc = aHashFunc;
+ /* Store the hashing function so that codes can be computed. */
+ retCache->hashFunc = aHashFunc;
- /* Store the function that
- compares hash keys to
- determine if they are
- equal. */
- retCache->compareFunc = aCompareFunc;
+ /* Store the function that compares hash keys to
+ determine if they are equal. */
+ retCache->compareFunc = aCompareFunc;
return retCache;
}
CacheNode_t aNode;
- /* Purge all key/value pairs
- from the table. */
+ /* Purge all key/value pairs from the table. */
while (aNode = hash_next (theCache, NULL))
hash_remove (theCache, aNode->theKey);
- /* Release the array of nodes
- and the cache itself. */
+ /* Release the array of nodes and the cache itself. */
free (theCache->theNodeTable);
free (theCache);
}
assert(aCacheNode);
- /* Initialize the new node. */
+ /* Initialize the new node. */
aCacheNode->theKey = aKey;
aCacheNode->theValue = aValue;
aCacheNode->nextNode = (* (*theCache)->theNodeTable)[ indx ];
- /* Debugging.
-
- Check the list for another
- key. */
+ /* Debugging.
+ Check the list for another key. */
#ifdef DEBUG
{ CacheNode_t checkHashNode = (* (*theCache)->theNodeTable)[ indx ];
}
#endif
- /* Install the node as the
- first element on the list. */
+ /* Install the node as the first element on the list. */
(* (*theCache)->theNodeTable)[ indx ] = aCacheNode;
- /* Bump the number of entries
- in the cache. */
+ /* Bump the number of entries in the cache. */
++ (*theCache)->entriesInHash;
- /* Check the hash table's
- fullness. We're going
- to expand if it is above
- the fullness level. */
+ /* Check the hash table's fullness. We're going
+ to expand if it is above the fullness level. */
if (FULLNESS (*theCache)) {
- /* The hash table has reached
- its fullness level. Time to
- expand it.
+
+ /* The hash table has reached its fullness level. Time to
+ expand it.
- I'm using a slow method
- here but is built on other
- primitive functions thereby
- increasing its
- correctness. */
+ I'm using a slow method here but is built on other
+ primitive functions thereby increasing its
+ correctness. */
CacheNode_t aNode = NULL;
Cache_t newCache = hash_new (EXPANSION (*theCache),
- (*theCache)->hashFunc,
- (*theCache)->compareFunc);
+ (*theCache)->hashFunc,
+ (*theCache)->compareFunc);
DEBUG_PRINTF (stderr, "Expanding cache %#x from %d to %d\n",
- *theCache, (*theCache)->sizeOfHash, newCache->sizeOfHash);
+ *theCache, (*theCache)->sizeOfHash, newCache->sizeOfHash);
- /* Copy the nodes from the
- first hash table to the
- new one. */
+ /* Copy the nodes from the first hash table to the new one. */
while (aNode = hash_next (*theCache, aNode))
hash_add (&newCache, aNode->theKey, aNode->theValue);
- /* Trash the old cache. */
+ /* Trash the old cache. */
hash_delete (*theCache);
- /* Return a pointer to the new
- hash table. */
+ /* Return a pointer to the new hash table. */
*theCache = newCache;
}
}
CacheNode_t aCacheNode = (*theCache->theNodeTable)[ indx ];
- /* We assume there is an entry
- in the table. Error if it
- is not. */
+ /* 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. */
+ /* Special case. First element is the key/value pair to be removed. */
if ((*theCache->compareFunc)(aCacheNode->theKey, aKey)) {
(*theCache->theNodeTable)[ indx ] = aCacheNode->nextNode;
free (aCacheNode);
} else {
- /* Otherwise, find the hash
- entry. */
+
+ /* Otherwise, find the hash entry. */
CacheNode_t prevHashNode = aCacheNode;
BOOL removed = NO;
assert(removed);
}
- /* Decrement the number of
- entries in the hash table. */
+ /* Decrement the number of entries in the hash table. */
--theCache->entriesInHash;
}
CacheNode_t theCacheNode = aCacheNode;
- /* If the scan is being started
- then reset the last node
- visitied pointer and bucket
- index. */
+ /* 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 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. */
+ /* 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 the list isn't exhausted then search the buckets for
+ other nodes. */
if (theCache->lastBucket < theCache->sizeOfHash) {
- /* Scan the remainder of the
- buckets looking for an entry
- at the head of the list.
- Return the first item
- found. */
+ /* 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->sizeOfHash)
if ((*theCache->theNodeTable)[ theCache->lastBucket ])
return (*theCache->theNodeTable)[ theCache->lastBucket ];
else
++theCache->lastBucket;
- /* No further nodes were found
- in the hash table. */
+ /* No further nodes were found in the hash table. */
return NULL;
} else
return NULL;
}
- /* Given key, return its
- value. Return NULL if the
- key/value pair isn't in
- the hash. */
+/*
+ * 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) {
CacheNode_t aCacheNode =
- (*theCache->theNodeTable)[(*theCache->hashFunc)(theCache, aKey)];
+ (*theCache->theNodeTable)[(*theCache->hashFunc)(theCache, aKey)];
void* retVal = NULL;
projects / gcc.git / commitdiff