1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/.brch__default	Sat Feb 11 18:00:56 2012 -0800
     1.3 @@ -0,0 +1,1 @@
     1.4 +The default branch is for use with normal C code.  Other branches specialize the library for use with VMS..  they may need VMS header files, and the working directory may be located at various different positions relative to the VMS implementation.
     1.5 \ No newline at end of file

     2.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     2.2 +++ b/.hgeol	Sat Feb 11 18:00:56 2012 -0800
     2.3 @@ -0,0 +1,14 @@
     2.4 +
     2.5 +[patterns]
     2.6 +**.py = native
     2.7 +**.txt = native
     2.8 +**.c = native
     2.9 +**.h = native
    2.10 +**.cpp = native
    2.11 +**.java = native
    2.12 +**.class = bin
    2.13 +**.jar = bin
    2.14 +**.sh = native
    2.15 +**.pl = native
    2.16 +**.jpg = bin
    2.17 +**.gif = bin

     3.1 --- a/MurmurHash2.c	Thu Feb 09 15:49:46 2012 +0100
     3.2 +++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
     3.3 @@ -1,64 +0,0 @@
     3.4 -//-----------------------------------------------------------------------------
     3.5 -// MurmurHash2, by Austin Appleby
     3.6 -
     3.7 -// Note - This code makes a few assumptions about how your machine behaves -
     3.8 -
     3.9 -// 1. We can read a 4-byte value from any address without crashing
    3.10 -// 2. sizeof(int) == 4
    3.11 -
    3.12 -// And it has a few limitations -
    3.13 -
    3.14 -// 1. It will not work incrementally.
    3.15 -// 2. It will not produce the same results on little-endian and big-endian
    3.16 -//    machines.
    3.17 -
    3.18 -unsigned int MurmurHash2 ( const void * key, int len, unsigned int seed )
    3.19 -{
    3.20 -	// 'm' and 'r' are mixing constants generated offline.
    3.21 -	// They're not really 'magic', they just happen to work well.
    3.22 -
    3.23 -	const unsigned int m = 0x5bd1e995;
    3.24 -	const int r = 24;
    3.25 -
    3.26 -	// Initialize the hash to a 'random' value
    3.27 -
    3.28 -	unsigned int h = seed ^ len;
    3.29 -
    3.30 -	// Mix 4 bytes at a time into the hash
    3.31 -
    3.32 -	const unsigned char * data = (const unsigned char *)key;
    3.33 -
    3.34 -	while(len >= 4)
    3.35 -	{
    3.36 -		unsigned int k = *(unsigned int *)data;
    3.37 -
    3.38 -		k *= m; 
    3.39 -		k ^= k >> r; 
    3.40 -		k *= m; 
    3.41 -		
    3.42 -		h *= m; 
    3.43 -		h ^= k;
    3.44 -
    3.45 -		data += 4;
    3.46 -		len -= 4;
    3.47 -	}
    3.48 -	
    3.49 -	// Handle the last few bytes of the input array
    3.50 -
    3.51 -	switch(len)
    3.52 -	{
    3.53 -	case 3: h ^= data[2] << 16;
    3.54 -	case 2: h ^= data[1] << 8;
    3.55 -	case 1: h ^= data[0];
    3.56 -	        h *= m;
    3.57 -	};
    3.58 -
    3.59 -	// Do a few final mixes of the hash to ensure the last few
    3.60 -	// bytes are well-incorporated.
    3.61 -
    3.62 -	h ^= h >> 13;
    3.63 -	h *= m;
    3.64 -	h ^= h >> 15;
    3.65 -
    3.66 -	return h;
    3.67 -} 

     4.1 --- a/PrivateHash.c	Thu Feb 09 15:49:46 2012 +0100
     4.2 +++ b/PrivateHash.c	Sat Feb 11 18:00:56 2012 -0800
     4.3 @@ -1,249 +1,242 @@
     4.4 -/*
     4.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
     4.6 - *  Licensed under GNU General Public License version 2
     4.7 - *
     4.8 - *
     4.9 - * Author: seanhalle@yahoo.com
    4.10 - */
    4.11 -
    4.12 -
    4.13 -#include <stdio.h>
    4.14 -#include <string.h>
    4.15 -#include <errno.h>
    4.16 -#include <stdlib.h>
    4.17 -
    4.18 -#include "PrivateHash.h"
    4.19 -#include "../vmalloc.h"
    4.20 -
    4.21 -
    4.22 - HashTable *
    4.23 -makeHashTable( int numHashSlots, FreeEntryContentFnPtr freeFn )
    4.24 - { HashTable * retTable;
    4.25 -   retTable = VMS__malloc( sizeof( HashTable ) );
    4.26 -
    4.27 -   retTable->freeEntryContentFn = freeFn;
    4.28 -   
    4.29 -   retTable->entries    = VMS__malloc( numHashSlots * sizeof(HashEntry *) );
    4.30 -   retTable->numEntries = 0;
    4.31 -   retTable->tableSz    = numHashSlots;
    4.32 -
    4.33 -   nullOutTablesArray( retTable );
    4.34 -
    4.35 -   return retTable;
    4.36 - }
    4.37 -
    4.38 - void
    4.39 -doubleTableSize( HashTable *table )
    4.40 - { int i, oldTableSz, newTableSz;
    4.41 -   HashEntry *entry, *nextEntry, **oldEntries, **newEntries;
    4.42 -
    4.43 -   oldTableSz = table->tableSz;
    4.44 -   oldEntries = table->entries;
    4.45 -
    4.46 -   newTableSz = 2 * oldTableSz + 1;
    4.47 -   newEntries = VMS__malloc( newTableSz * sizeof(HashEntry *) );
    4.48 -
    4.49 -   table->tableSz    = newTableSz;
    4.50 -   table->entries    = newEntries;
    4.51 -   table->numEntries = 0; //about to add them all back!
    4.52 -
    4.53 -      // move all the entries from old to new
    4.54 -   for( i=0; i < oldTableSz; i++ )
    4.55 -    { if( oldEntries[i] != NULL )
    4.56 -       { entry = oldEntries[i];
    4.57 -         while( entry != NULL )
    4.58 -          { nextEntry = entry->next;
    4.59 -            entry->next = NULL;
    4.60 -            putEntryIntoTable( entry, table ); //does not allocate anything
    4.61 -            entry = nextEntry;
    4.62 -          }
    4.63 -       }
    4.64 -    }
    4.65 - }
    4.66 -
    4.67 -void
    4.68 -nullOutTablesArray( HashTable *table )
    4.69 - { int i, tableSz;
    4.70 -   tableSz = table->tableSz;
    4.71 -   HashEntry ** entries = table->entries;
    4.72 -   for( i = 0; i < tableSz; i++ )
    4.73 -      entries[ i ] = NULL;
    4.74 - }
    4.75 -
    4.76 -unsigned int
    4.77 -hashThisKey( char* s, int hashSz )
    4.78 - { unsigned int h = 0;
    4.79 -   unsigned int i;
    4.80 -   hashkey_t* key = (hashkey_t*)s;
    4.81 -
    4.82 -   for(i=0 ; i<sizeof(hashkey_t); i++ )
    4.83 -      h = key->hashable[i] + h*31;
    4.84 -   return h % hashSz;
    4.85 - }
    4.86 -
    4.87 -/*Need this to be separated out, for use in both getParam and putParam
    4.88 - */
    4.89 -HashEntry *
    4.90 -getEntryFromTable( char *key, HashTable * table )
    4.91 - {  unsigned int
    4.92 -   hashIndex = hashThisKey( key, table->tableSz );
    4.93 -    HashEntry*
    4.94 -   hashEntry = table->entries[ hashIndex ];
    4.95 -   for( ; hashEntry != NULL; hashEntry = hashEntry->next )
    4.96 -    {
    4.97 -       if( memcmp( hashEntry->key, key, sizeof(hashkey_t) ) == 0 )
    4.98 -           return hashEntry;
    4.99 -    }
   4.100 -   return NULL;
   4.101 - }
   4.102 -
   4.103 -void *
   4.104 -getValueFromTable( char *key, HashTable * table )
   4.105 - { HashEntry *entry;
   4.106 -   entry = getEntryFromTable( key, table );
   4.107 -   if( entry == NULL ) return NULL;
   4.108 -
   4.109 -   return entry->content;
   4.110 - }
   4.111 -
   4.112 -
   4.113 -/*If key already has a value, clobber the old one and replace it
   4.114 - */
   4.115 - int
   4.116 -addValueIntoTable( char* key, void *content, HashTable *table )
   4.117 - { unsigned int hashIdx;
   4.118 -   HashEntry* hashEntry;
   4.119 -
   4.120 -   hashEntry = getEntryFromTable( key, table );
   4.121 -   if( hashEntry == NULL )
   4.122 -    { hashIdx = hashThisKey( key, table->tableSz );
   4.123 -      hashEntry = (HashEntry*) VMS__malloc( sizeof( HashEntry ) );
   4.124 -            if( hashEntry == NULL )  return 0;
   4.125 -      hashEntry->key = VMS__malloc( sizeof(hashkey_t) );
   4.126 -            if( hashEntry->key == NULL ) return 0;
   4.127 -      memcpy( hashEntry->key, key, sizeof(hashkey_t) );
   4.128 -      hashEntry->next = (table->entries)[hashIdx];
   4.129 -      (table->entries)[hashIdx] = hashEntry;
   4.130 -      table->numEntries += 1;
   4.131 -      if( table->tableSz < table->numEntries ) doubleTableSize( table );
   4.132 -    }
   4.133 -   else
   4.134 -    { (*(table->freeEntryContentFn))( hashEntry->content );
   4.135 -    }
   4.136 -   hashEntry->content = content;
   4.137 -   return 1;
   4.138 - }
   4.139 -
   4.140 - int
   4.141 -putEntryIntoTable( HashEntry *entry, HashTable *table )
   4.142 - { unsigned int hashIdx;
   4.143 -   HashEntry* testEntry;
   4.144 -
   4.145 -   testEntry = getEntryFromTable( entry->key, table );
   4.146 -   if( testEntry == NULL )
   4.147 -    { hashIdx = hashThisKey( entry->key, table->tableSz );
   4.148 -      entry->next = (table->entries)[hashIdx];
   4.149 -      (table->entries)[hashIdx] = entry;
   4.150 -      table->numEntries += 1;
   4.151 -      if( table->tableSz < table->numEntries ) doubleTableSize( table );
   4.152 -    }
   4.153 -   else
   4.154 -    { (*(table->freeEntryContentFn))( testEntry->content );
   4.155 -         //being lazy -- will create bug in code that relies on having ptr to
   4.156 -         // elem given to insert into table!
   4.157 -      testEntry->content = entry->content;
   4.158 -      entry->content = NULL;
   4.159 -      freeHashEntryButNotContent( entry );
   4.160 -    }
   4.161 -   return 1;
   4.162 - }
   4.163 -
   4.164 -/*Better version
   4.165 - */
   4.166 - void
   4.167 -untested_putEntryIntoTable( HashEntry *entry, HashTable * table )
   4.168 - { HashEntry *testEntry, *prevEntry = NULL;
   4.169 -    unsigned int
   4.170 -   hashIndex = hashThisKey( entry->key, table->tableSz );
   4.171 -   
   4.172 -   testEntry = table->entries[ hashIndex ];
   4.173 -   for( ; testEntry != NULL; testEntry = testEntry->next )
   4.174 -    { if( memcmp( testEntry->key, entry->key, sizeof(hashkey_t)) == 0 )
   4.175 -       { if( prevEntry == NULL )
   4.176 -          { table->entries[hashIndex] = entry;
   4.177 -            entry->next = testEntry->next;
   4.178 -          }
   4.179 -         else
   4.180 -          { prevEntry->next = entry;
   4.181 -            entry->next = testEntry->next;
   4.182 -          }
   4.183 -         freeHashEntryUsing( testEntry, table ); //frees content too!
   4.184 -         return;
   4.185 -       }
   4.186 -    }
   4.187 -      //wasn't found, so insert
   4.188 -   entry->next = table->entries[hashIndex];
   4.189 -   table->entries[hashIndex] = entry;
   4.190 - }
   4.191 -
   4.192 -
   4.193 -
   4.194 - bool8
   4.195 -deleteEntryFromTable( char *key, HashTable *table )
   4.196 - { HashEntry  *hashEntry;
   4.197 -   HashEntry **addrOfHashEntryPtr;
   4.198 -   unsigned int hashIndex;
   4.199 -
   4.200 -   hashIndex = hashThisKey( key, table->tableSz );
   4.201 -   addrOfHashEntryPtr = &( table->entries[ hashIndex ] );
   4.202 -   hashEntry = *addrOfHashEntryPtr;
   4.203 -   while( hashEntry != NULL )
   4.204 -    { if( memcmp( hashEntry->key, key, sizeof(hashkey_t) ) == 0 )
   4.205 -       {
   4.206 -         *addrOfHashEntryPtr = hashEntry->next;
   4.207 -         //TODO: Free the contents of entry?
   4.208 -         freeHashEntryButNotContent( hashEntry );
   4.209 -         table->numEntries -= 1;
   4.210 -         return TRUE;
   4.211 -       }
   4.212 -      addrOfHashEntryPtr = &( hashEntry->next );
   4.213 -      hashEntry = *addrOfHashEntryPtr;
   4.214 -    }
   4.215 -   return FALSE;
   4.216 - }
   4.217 - 
   4.218 -void
   4.219 -freeHashTable( HashTable *table )
   4.220 - { int i;
   4.221 -   HashEntry *hashEntry, *temp, **entries;
   4.222 -
   4.223 -   entries = table->entries;
   4.224 -   for( i=0; i < table->tableSz; i++ )
   4.225 -    { if( entries[i] != NULL )
   4.226 -       { hashEntry = entries[i];
   4.227 -         while( hashEntry != NULL )
   4.228 -          {
   4.229 -            temp = hashEntry->next;
   4.230 -            freeHashEntryUsing( hashEntry, table );
   4.231 -            hashEntry = temp;
   4.232 -          }
   4.233 -       }
   4.234 -    }
   4.235 - }
   4.236 -
   4.237 -void
   4.238 -freeHashEntryUsing( HashEntry *entry, HashTable *table )
   4.239 - {
   4.240 -   if( entry->content != NULL )
   4.241 -      (*(table->freeEntryContentFn))( entry->content );
   4.242 -   VMS__free( entry->key ); //was VMS__malloc'd above, so free it
   4.243 -   VMS__free( entry );
   4.244 - }
   4.245 -
   4.246 -void
   4.247 -freeHashEntryButNotContent( HashEntry *entry )
   4.248 - {
   4.249 -   VMS__free( entry->key ); //was VMS__malloc'd above, so free it
   4.250 -   VMS__free( entry );
   4.251 - }
   4.252 -
   4.253 +/*
   4.254 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
   4.255 + *  Licensed under GNU General Public License version 2
   4.256 + *
   4.257 + *
   4.258 + * Author: seanhalle@yahoo.com
   4.259 + */
   4.260 +
   4.261 +#include "PrivateHash.h"
   4.262 +
   4.263 +
   4.264 + HashTable *
   4.265 +makeHashTable( int numHashSlots, FreeEntryContentFnPtr freeFn )
   4.266 + { HashTable * retTable;
   4.267 +   retTable = malloc( sizeof( HashTable ) );
   4.268 +
   4.269 +   retTable->freeEntryContentFn = freeFn;
   4.270 +   
   4.271 +   retTable->entries    = malloc( numHashSlots * sizeof(HashEntry *) );
   4.272 +   retTable->numEntries = 0;
   4.273 +   retTable->tableSz    = numHashSlots;
   4.274 +
   4.275 +   nullOutTablesArray( retTable );
   4.276 +
   4.277 +   return retTable;
   4.278 + }
   4.279 +
   4.280 + void
   4.281 +doubleTableSize( HashTable *table )
   4.282 + { int i, oldTableSz, newTableSz;
   4.283 +   HashEntry *entry, *nextEntry, **oldEntries, **newEntries;
   4.284 +
   4.285 +   oldTableSz = table->tableSz;
   4.286 +   oldEntries = table->entries;
   4.287 +
   4.288 +   newTableSz = 2 * oldTableSz + 1;
   4.289 +   newEntries = malloc( newTableSz * sizeof(HashEntry *) );
   4.290 +
   4.291 +   table->tableSz    = newTableSz;
   4.292 +   table->entries    = newEntries;
   4.293 +   table->numEntries = 0; //about to add them all back!
   4.294 +
   4.295 +      // move all the entries from old to new
   4.296 +   for( i=0; i < oldTableSz; i++ )
   4.297 +    { if( oldEntries[i] != NULL )
   4.298 +       { entry = oldEntries[i];
   4.299 +         while( entry != NULL )
   4.300 +          { nextEntry = entry->next;
   4.301 +            entry->next = NULL;
   4.302 +            putEntryIntoTable( entry, table ); //does not allocate anything
   4.303 +            entry = nextEntry;
   4.304 +          }
   4.305 +       }
   4.306 +    }
   4.307 + }
   4.308 +
   4.309 +void
   4.310 +nullOutTablesArray( HashTable *table )
   4.311 + { int i, tableSz;
   4.312 +   tableSz = table->tableSz;
   4.313 +   HashEntry ** entries = table->entries;
   4.314 +   for( i = 0; i < tableSz; i++ )
   4.315 +      entries[ i ] = NULL;
   4.316 + }
   4.317 +
   4.318 +unsigned int
   4.319 +hashThisKey( char* s, int hashSz )
   4.320 + { unsigned int h = 0;
   4.321 +   unsigned int i;
   4.322 +   hashkey_t* key = (hashkey_t*)s;
   4.323 +
   4.324 +   for(i=0 ; i<sizeof(hashkey_t); i++ )
   4.325 +      h = key->hashable[i] + h*31;
   4.326 +   return h % hashSz;
   4.327 + }
   4.328 +
   4.329 +/*Need this to be separated out, for use in both getParam and putParam
   4.330 + */
   4.331 +HashEntry *
   4.332 +getEntryFromTable( char *key, HashTable * table )
   4.333 + {  unsigned int
   4.334 +   hashIndex = hashThisKey( key, table->tableSz );
   4.335 +    HashEntry*
   4.336 +   hashEntry = table->entries[ hashIndex ];
   4.337 +   for( ; hashEntry != NULL; hashEntry = hashEntry->next )
   4.338 +    {
   4.339 +       if( memcmp( hashEntry->key, key, sizeof(hashkey_t) ) == 0 )
   4.340 +           return hashEntry;
   4.341 +    }
   4.342 +   return NULL;
   4.343 + }
   4.344 +
   4.345 +void *
   4.346 +getValueFromTable( char *key, HashTable * table )
   4.347 + { HashEntry *entry;
   4.348 +   entry = getEntryFromTable( key, table );
   4.349 +   if( entry == NULL ) return NULL;
   4.350 +
   4.351 +   return entry->content;
   4.352 + }
   4.353 +
   4.354 +
   4.355 +/*If key already has a value, clobber the old one and replace it
   4.356 + */
   4.357 + int
   4.358 +addValueIntoTable( char* key, void *content, HashTable *table )
   4.359 + { unsigned int hashIdx;
   4.360 +   HashEntry* hashEntry;
   4.361 +
   4.362 +   hashEntry = getEntryFromTable( key, table );
   4.363 +   if( hashEntry == NULL )
   4.364 +    { hashIdx = hashThisKey( key, table->tableSz );
   4.365 +      hashEntry = (HashEntry*) malloc( sizeof( HashEntry ) );
   4.366 +            if( hashEntry == NULL )  return 0;
   4.367 +      hashEntry->key = malloc( sizeof(hashkey_t) );
   4.368 +            if( hashEntry->key == NULL ) return 0;
   4.369 +      memcpy( hashEntry->key, key, sizeof(hashkey_t) );
   4.370 +      hashEntry->next = (table->entries)[hashIdx];
   4.371 +      (table->entries)[hashIdx] = hashEntry;
   4.372 +      table->numEntries += 1;
   4.373 +      if( table->tableSz < table->numEntries ) doubleTableSize( table );
   4.374 +    }
   4.375 +   else
   4.376 +    { (*(table->freeEntryContentFn))( hashEntry->content );
   4.377 +    }
   4.378 +   hashEntry->content = content;
   4.379 +   return 1;
   4.380 + }
   4.381 +
   4.382 + int
   4.383 +putEntryIntoTable( HashEntry *entry, HashTable *table )
   4.384 + { unsigned int hashIdx;
   4.385 +   HashEntry* testEntry;
   4.386 +
   4.387 +   testEntry = getEntryFromTable( entry->key, table );
   4.388 +   if( testEntry == NULL )
   4.389 +    { hashIdx = hashThisKey( entry->key, table->tableSz );
   4.390 +      entry->next = (table->entries)[hashIdx];
   4.391 +      (table->entries)[hashIdx] = entry;
   4.392 +      table->numEntries += 1;
   4.393 +      if( table->tableSz < table->numEntries ) doubleTableSize( table );
   4.394 +    }
   4.395 +   else
   4.396 +    { (*(table->freeEntryContentFn))( testEntry->content );
   4.397 +         //being lazy -- will create bug in code that relies on having ptr to
   4.398 +         // elem given to insert into table!
   4.399 +      testEntry->content = entry->content;
   4.400 +      entry->content = NULL;
   4.401 +      freeHashEntryButNotContent( entry );
   4.402 +    }
   4.403 +   return 1;
   4.404 + }
   4.405 +
   4.406 +/*Better version
   4.407 + */
   4.408 + void
   4.409 +untested_putEntryIntoTable( HashEntry *entry, HashTable * table )
   4.410 + { HashEntry *testEntry, *prevEntry = NULL;
   4.411 +    unsigned int
   4.412 +   hashIndex = hashThisKey( entry->key, table->tableSz );
   4.413 +   
   4.414 +   testEntry = table->entries[ hashIndex ];
   4.415 +   for( ; testEntry != NULL; testEntry = testEntry->next )
   4.416 +    { if( memcmp( testEntry->key, entry->key, sizeof(hashkey_t)) == 0 )
   4.417 +       { if( prevEntry == NULL )
   4.418 +          { table->entries[hashIndex] = entry;
   4.419 +            entry->next = testEntry->next;
   4.420 +          }
   4.421 +         else
   4.422 +          { prevEntry->next = entry;
   4.423 +            entry->next = testEntry->next;
   4.424 +          }
   4.425 +         freeHashEntryUsing( testEntry, table ); //frees content too!
   4.426 +         return;
   4.427 +       }
   4.428 +    }
   4.429 +      //wasn't found, so insert
   4.430 +   entry->next = table->entries[hashIndex];
   4.431 +   table->entries[hashIndex] = entry;
   4.432 + }
   4.433 +
   4.434 +
   4.435 +
   4.436 + bool8
   4.437 +deleteEntryFromTable( char *key, HashTable *table )
   4.438 + { HashEntry  *hashEntry;
   4.439 +   HashEntry **addrOfHashEntryPtr;
   4.440 +   unsigned int hashIndex;
   4.441 +
   4.442 +   hashIndex = hashThisKey( key, table->tableSz );
   4.443 +   addrOfHashEntryPtr = &( table->entries[ hashIndex ] );
   4.444 +   hashEntry = *addrOfHashEntryPtr;
   4.445 +   while( hashEntry != NULL )
   4.446 +    { if( memcmp( hashEntry->key, key, sizeof(hashkey_t) ) == 0 )
   4.447 +       {
   4.448 +         *addrOfHashEntryPtr = hashEntry->next;
   4.449 +         //TODO: Free the contents of entry?
   4.450 +         freeHashEntryButNotContent( hashEntry );
   4.451 +         table->numEntries -= 1;
   4.452 +         return TRUE;
   4.453 +       }
   4.454 +      addrOfHashEntryPtr = &( hashEntry->next );
   4.455 +      hashEntry = *addrOfHashEntryPtr;
   4.456 +    }
   4.457 +   return FALSE;
   4.458 + }
   4.459 + 
   4.460 +void
   4.461 +freeHashTable( HashTable *table )
   4.462 + { int i;
   4.463 +   HashEntry *hashEntry, *temp, **entries;
   4.464 +
   4.465 +   entries = table->entries;
   4.466 +   for( i=0; i < table->tableSz; i++ )
   4.467 +    { if( entries[i] != NULL )
   4.468 +       { hashEntry = entries[i];
   4.469 +         while( hashEntry != NULL )
   4.470 +          {
   4.471 +            temp = hashEntry->next;
   4.472 +            freeHashEntryUsing( hashEntry, table );
   4.473 +            hashEntry = temp;
   4.474 +          }
   4.475 +       }
   4.476 +    }
   4.477 + }
   4.478 +
   4.479 +void
   4.480 +freeHashEntryUsing( HashEntry *entry, HashTable *table )
   4.481 + {
   4.482 +   if( entry->content != NULL )
   4.483 +      (*(table->freeEntryContentFn))( entry->content );
   4.484 +   free( entry->key ); //was malloc'd above, so free it
   4.485 +   free( entry );
   4.486 + }
   4.487 +
   4.488 +void
   4.489 +freeHashEntryButNotContent( HashEntry *entry )
   4.490 + {
   4.491 +   free( entry->key ); //was malloc'd above, so free it
   4.492 +   free( entry );
   4.493 + }
   4.494 +

     5.1 --- a/PrivateHash.h	Thu Feb 09 15:49:46 2012 +0100
     5.2 +++ b/PrivateHash.h	Sat Feb 11 18:00:56 2012 -0800
     5.3 @@ -1,70 +1,74 @@
     5.4 -/*
     5.5 - *  Copyright 2009 OpenSourceStewardshipFoundation.org
     5.6 - *  Licensed under GNU General Public License version 2
     5.7 - *
     5.8 - * Author: seanhalle@yahoo.com
     5.9 - */
    5.10 -
    5.11 -#ifndef _PRIVATE_HASH_H
    5.12 -#define	_PRIVATE_HASH_H
    5.13 -
    5.14 -#include "../../VMS_Implementations/VMS_impl/VMS_primitive_data_types.h"
    5.15 -
    5.16 -#define TRUE     1
    5.17 -#define FALSE    0
    5.18 -
    5.19 -union hashkey_t{
    5.20 -    char hashable[8];
    5.21 -    int  parts[2];
    5.22 -};
    5.23 -
    5.24 -typedef union hashkey_t hashkey_t;
    5.25 -
    5.26 -#define DEFAULT_HASHSIZE 1 << 10
    5.27 -
    5.28 -typedef struct _HashEntry HashEntry;
    5.29 -
    5.30 -struct _HashEntry
    5.31 - {
    5.32 -   char       *key;
    5.33 -   void       *content;
    5.34 -   HashEntry  *next;
    5.35 - };
    5.36 -
    5.37 -typedef void (*FreeEntryContentFnPtr)    ( void * );
    5.38 -
    5.39 -typedef struct
    5.40 - { int tableSz;
    5.41 -   int numEntries;
    5.42 -   HashEntry* *entries;
    5.43 -   FreeEntryContentFnPtr freeEntryContentFn;
    5.44 - }
    5.45 -HashTable;
    5.46 -
    5.47 -
    5.48 -//===========================================================================
    5.49 -//   Public functions
    5.50 -HashTable   *makeHashTable( int numHashSlots, FreeEntryContentFnPtr freeFn );
    5.51 -
    5.52 -int          putEntryIntoTable( HashEntry *entry, HashTable *table);
    5.53 -int          addValueIntoTable( char* key, void *value, HashTable *table);
    5.54 -HashEntry   *getEntryFromTable( char *key, HashTable *table );
    5.55 -void        *getValueFromTable( char *key, HashTable *table );
    5.56 -
    5.57 -bool8        deleteEntryFromTable( char *key, HashTable *table );
    5.58 -bool8        deleteThisEntryFromTable( HashEntry *entry, HashTable *table );
    5.59 -bool8        deleteEntrysValueInTable( char *key, HashTable *table );
    5.60 -bool8        deleteEntryFromTableAndFreeValue( char *key, HashTable *table );
    5.61 -void         freeHashTable( HashTable *table );
    5.62 -//char        *paramBagToString( ParamBag * bag )
    5.63 -
    5.64 -//===========================================================================
    5.65 -//   Internal functions
    5.66 -void         freeHashEntryUsing( HashEntry *entry, HashTable *table );
    5.67 -unsigned int hashThisKey( char *s, int hashSz );
    5.68 -void         nullOutTablesArray( HashTable *table );
    5.69 -void         doubleTableSize( HashTable *table );
    5.70 -void         freeHashEntryButNotContent( HashEntry *entry );
    5.71 -
    5.72 -#endif	/* _PRIVATE_HASH_H */
    5.73 -
    5.74 +/*
    5.75 + *  Copyright 2009 OpenSourceStewardshipFoundation.org
    5.76 + *  Licensed under GNU General Public License version 2
    5.77 + *
    5.78 + * Author: seanhalle@yahoo.com
    5.79 + */
    5.80 +
    5.81 +#ifndef _PRIVATE_HASH_H
    5.82 +#define	_PRIVATE_HASH_H
    5.83 +
    5.84 +
    5.85 +#include <stdio.h>
    5.86 +#include <string.h>
    5.87 +#include <errno.h>
    5.88 +#include <stdlib.h>
    5.89 +
    5.90 +#define TRUE     1
    5.91 +#define FALSE    0
    5.92 +
    5.93 +union hashkey_t{
    5.94 +    char hashable[8];
    5.95 +    int  parts[2];
    5.96 +};
    5.97 +
    5.98 +typedef union hashkey_t hashkey_t;
    5.99 +
   5.100 +#define DEFAULT_HASHSIZE 1 << 10
   5.101 +
   5.102 +typedef struct _HashEntry HashEntry;
   5.103 +
   5.104 +struct _HashEntry
   5.105 + {
   5.106 +   char       *key;
   5.107 +   void       *content;
   5.108 +   HashEntry  *next;
   5.109 + };
   5.110 +
   5.111 +typedef void (*FreeEntryContentFnPtr)    ( void * );
   5.112 +
   5.113 +typedef struct
   5.114 + { int tableSz;
   5.115 +   int numEntries;
   5.116 +   HashEntry* *entries;
   5.117 +   FreeEntryContentFnPtr freeEntryContentFn;
   5.118 + }
   5.119 +HashTable;
   5.120 +
   5.121 +
   5.122 +//===========================================================================
   5.123 +//   Public functions
   5.124 +HashTable   *makeHashTable( int numHashSlots, FreeEntryContentFnPtr freeFn );
   5.125 +
   5.126 +int          putEntryIntoTable( HashEntry *entry, HashTable *table);
   5.127 +int          addValueIntoTable( char* key, void *value, HashTable *table);
   5.128 +HashEntry   *getEntryFromTable( char *key, HashTable *table );
   5.129 +void        *getValueFromTable( char *key, HashTable *table );
   5.130 +
   5.131 +bool8        deleteEntryFromTable( char *key, HashTable *table );
   5.132 +bool8        deleteThisEntryFromTable( HashEntry *entry, HashTable *table );
   5.133 +bool8        deleteEntrysValueInTable( char *key, HashTable *table );
   5.134 +bool8        deleteEntryFromTableAndFreeValue( char *key, HashTable *table );
   5.135 +void         freeHashTable( HashTable *table );
   5.136 +//char        *paramBagToString( ParamBag * bag )
   5.137 +
   5.138 +//===========================================================================
   5.139 +//   Internal functions
   5.140 +void         freeHashEntryUsing( HashEntry *entry, HashTable *table );
   5.141 +unsigned int hashThisKey( char *s, int hashSz );
   5.142 +void         nullOutTablesArray( HashTable *table );
   5.143 +void         doubleTableSize( HashTable *table );
   5.144 +void         freeHashEntryButNotContent( HashEntry *entry );
   5.145 +
   5.146 +#endif	/* _PRIVATE_HASH_H */
   5.147 +