Skip to content

R
riscv-gcc-1
Commit d0bd180d by Richard Stallman
Options

Fix indentation, clean up comments. 

Rename structure fields and typedefs.

From-SVN: r2192
parent 2156dfe3
Showing with 71 additions and 83 deletions
gcc/objc/hash.h
......@@ -23,10 +23,16 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
the executable file might be covered by the GNU General Public License. */
/*
$Header: /home/fsf/rms/c-runtime/dispatch/RCS/hash.h,v 0.11 1992/08/31 21:15:02 dglattin Exp rms $
$Author: dglattin $
$Date: 1992/08/31 21:15:02 $
$Header: /home/fsf/rms/c-runtime/dispatch/RCS/hash.h,v 0.12 1992/09/02 01:59:40 rms Exp rms $
$Author: rms $
$Date: 1992/09/02 01:59:40 $
$Log: hash.h,v $
* Revision 0.12 1992/09/02 01:59:40 rms
* Changed the format of various sections to conform with GNU standard.
* Deleted dependencies on some header files.
* Replaced the use of the functions from memory.h with funtions like bzero.
* Changed the include format.
*
* Revision 0.11 1992/08/31 21:15:02 dglattin
* minor documentation changes.
*
......@@ -85,17 +91,14 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
* 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
struct cache_node *next; /* Pointer to next entry on the list.
NULL indicates end of list. */
void *key; /* 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;
void *value; /* Value stored for the key. */
} *node_ptr;
/*
......@@ -107,7 +110,7 @@ typedef struct cache_node {
* typedef. Therefore, to remove compiler warnings the functions passed to
* hash_new will have to be casted to this type.
*/
typedef unsigned int (*HashFunc)(void*, void*);
typedef unsigned int (*hash_func_type)(void*, void*);
/*
* This data type is the function that compares two hash keys and returns an
......@@ -116,7 +119,7 @@ typedef unsigned int (*HashFunc)(void*, void*);
* second.
*/
typedef int (*CompareFunc)(void*, void*);
typedef int (*compare_func_type)(void*, void*);
/*
......@@ -126,61 +129,48 @@ typedef int (*CompareFunc)(void*, void*);
* (except for new).
*/
typedef struct cache {
/*
* Variables used to implement the
* hash itself.
*/
CacheNode_t (*theNodeTable)[]; /* Pointer to an array of
hash nodes. */
/*
* Variables used to track the size of the hash
* table so to determine when to resize it.
*/
unsigned int sizeOfHash, /* Number of buckets
allocated for the hash
table (number of array
entries allocated for
"theNodeTable"). Must be
a power of two. */
unsigned int entriesInHash, /* Current number of entries
in the hash table. */
unsigned int mask; /* Precomputed mask. */
/*
* Variables used to implement indexing
* through the hash table.
*/
unsigned int lastBucket; /* Tracks which entry in the
array where the last value
was returned. */
/* Variables used to implement the hash itself. */
node_ptr (*node_table)[]; /* Pointer to an array of hash nodes. */
/* Variables used to track the size of the hash table so to determine
when to resize it. */
unsigned int size; /* Number of buckets allocated for the hash table
(number of array entries allocated for
"node_table"). Must be a power of two. */
unsigned int used; /* Current number of entries in the hash table. */
unsigned int mask; /* Precomputed mask. */
/* Variables used to implement indexing through the hash table. */
unsigned int last_bucket; /* Tracks which entry in the array where
the last value was returned. */
/* Function used to compute a hash code given a key.
This function is specified when the hash table is created. */
HashFunc hashFunc;
/* Function used to compare two hash keys to determine
if they are equal. */
CompareFunc compareFunc;
} Cache, *Cache_t;
/* Allocate and initialize a hash table. */
Cache_t
hash_new (unsigned int sizeOfHash,
HashFunc aHashFunc, CompareFunc aCompareFunc);
This function is specified when the hash table is created. */
hash_func_type hash_func;
/* Function used to compare two hash keys to see if they are equal. */
compare_func_type compare_func;
} *cache_ptr;
/* Allocate and initialize a hash table. */
cache_ptr hash_new (unsigned int size,
hash_func_type hash_func, compare_func_type compare_func);
/* Deallocate all of the hash nodes and the cache itself. */
void
hash_delete (Cache_t theCache);
/* Deallocate all of the hash nodes and the cache itself. */
void hash_delete (cache_ptr cache);
/* Add the key/value pair to the hash table. If the
hash table reaches a level of fullnes then it will be resized.
assert if the key is already in the hash. */
void
hash_add (Cache_t *theCache, void *aKey, void *aValue);
assert if the key is already in the hash. */
void hash_add (cache_ptr *cachep, void *key, void *value);
/* 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);
assert if the key isn't in the table. */
void hash_remove (cache_ptr cache, void *key);
/* Used to index through the hash table. Start with NULL
to get the first entry.
......@@ -189,13 +179,13 @@ hash_remove (Cache_t theCache, void *aKey);
** Don't modify the hash during this operation ***
Cache nodes are returned such that key or value can
be extracted. */
CacheNode_t
hash_next (Cache_t theCache, CacheNode_t aCacheNode);
be extracted. */
node_ptr hash_next (cache_ptr cache, node_ptr node);
/* Used to return a value from a hash table using a given key. */
void*
hash_value_for_key (Cache_t theCache, void *aKey);
void *hash_value_for_key (cache_ptr cache, void *key);
/************************************************
......@@ -207,49 +197,47 @@ hash_value_for_key (Cache_t theCache, void *aKey);
************************************************/
/* Calculate a hash code by performing some
manipulation of the key pointer. */
manipulation of the key pointer. */
static inline unsigned int
intHash(Cache_t theCache, void *aKey)
hash_int (cache_ptr cache, void *key)
{
assert (sizeof (unsigned int) == sizeof (key));
assert(sizeof (unsigned int) == sizeof (aKey));
return ((unsigned int)aKey >> (sizeof(void*) - 1)) & theCache->mask ;
return ((unsigned int)key >> (sizeof (void *) - 1)) & cache->mask;
}
/* Calculate a hash code by iterating over a NULL
terminate string. */
terminate string. */
static inline unsigned int
strHash(Cache_t theCache, void *aKey)
hash_string (cache_ptr cache, void *key)
{
unsigned int ret = 0;
unsigned int ctr = 0;
while(*(char*)aKey) {
ret ^= *(char*)aKey++ << ctr;
ctr = (ctr + 1) % sizeof(void*);
while (*(char*)key) {
ret ^= *(char*)key++ << ctr;
ctr = (ctr + 1) % sizeof (void *);
}
return ret & theCache->mask ;
return ret & cache->mask;
}
/* Compare two integers. */
/* Compare two integers. */
static inline int
intCmp(void *k1, void *k2)
compare_ints (void *k1, void *k2)
{
return !((int)k1 - (int)k2);
}
/* Compare two strings. */
/* Compare two strings. */
static inline int
strCmp(void *k1, void *k2)
compare_strings (void *k1, void *k2)
{
return !strcmp(k1, k2);
return !strcmp (k1, k2);
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment