home *** CD-ROM | disk | FTP | other *** search
/ Education Sampler 1992 [NeXTSTEP] / Education_1992_Sampler.iso / Programming / c-runtime / dispatch / RCS / hash.h,v < prev    next >
Encoding:
Text File  |  1992-08-18  |  23.7 KB  |  722 lines
  1. head    0.10;
  2. access;
  3. symbols;
  4. locks; strict;
  5. comment    @ * @;
  6.  
  7.  
  8. 0.10
  9. date    92.08.18.04.46.58;    author dglattin;    state Exp;
  10. branches;
  11. next    0.9;
  12.  
  13. 0.9
  14. date    92.04.13.11.43.08;    author dennisg;    state Exp;
  15. branches;
  16. next    0.8;
  17.  
  18. 0.8
  19. date    91.12.10.12.05.28;    author dennisg;    state Exp;
  20. branches;
  21. next    0.7;
  22.  
  23. 0.7
  24. date    91.12.03.02.01.23;    author dennisg;    state Exp;
  25. branches;
  26. next    0.6;
  27.  
  28. 0.6
  29. date    91.11.24.01.20.02;    author dennisg;    state Exp;
  30. branches;
  31. next    0.5;
  32.  
  33. 0.5
  34. date    91.11.23.22.19.21;    author dennisg;    state Exp;
  35. branches;
  36. next    0.4;
  37.  
  38. 0.4
  39. date    91.11.21.22.25.19;    author dennisg;    state Exp;
  40. branches;
  41. next    0.3;
  42.  
  43. 0.3
  44. date    91.11.07.23.23.40;    author dennisg;    state Exp;
  45. branches;
  46. next    0.2;
  47.  
  48. 0.2
  49. date    91.11.07.22.30.54;    author dennisg;    state Exp;
  50. branches;
  51. next    0.1;
  52.  
  53. 0.1
  54. date    91.10.24.00.45.39;    author dennisg;    state Exp;
  55. branches;
  56. next    ;
  57.  
  58.  
  59. desc
  60. @This is the definition file for a hash table used within
  61. the Objective-C run-time system.
  62. Hash tables are used to cache class and meta class pointers.  
  63. They are also used to cache class and meta class methods.
  64. There are other uses of hash tables within the run-time.
  65. The hash table is very general purpose in nature.  
  66. @
  67.  
  68.  
  69. 0.10
  70. log
  71. @Saving a working version before release.
  72. @
  73. text
  74. @/* -*-c-*- */
  75.  
  76. /* Copyright (C) 1989, 1992 Free Software Foundation, Inc.
  77.  
  78. This file is part of GNU CC.
  79.  
  80. GNU CC is free software; you can redistribute it and/or modify
  81. it under the terms of the GNU General Public License as published by
  82. the Free Software Foundation; either version 2, or (at your option)
  83. any later version.
  84.  
  85. GNU CC is distributed in the hope that it will be useful,
  86. but WITHOUT ANY WARRANTY; without even the implied warranty of
  87. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  88. GNU General Public License for more details.
  89.  
  90. You should have received a copy of the GNU General Public License
  91. along with GNU CC; see the file COPYING.  If not, write to
  92. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  93.  
  94. /* As a special exception, if you link this library with files
  95.    compiled with GCC to produce an executable, this does not cause
  96.    the resulting executable to be covered by the GNU General Public License.
  97.    This exception does not however invalidate any other reasons why
  98.    the executable file might be covered by the GNU General Public License.  */
  99.  
  100. /* 
  101.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/dispatch.common/RCS/hash.h,v 0.9 1992/04/13 11:43:08 dennisg Exp dennisg $
  102.   $Author: dennisg $
  103.   $Date: 1992/04/13 11:43:08 $
  104.   $Log: hash.h,v $
  105.  * Revision 0.9  1992/04/13  11:43:08  dennisg
  106.  * Check in after array version of run-time works.
  107.  * Expect more changes as hash version and other changes are made.
  108.  *
  109.  * Revision 0.8  1991/12/10  12:05:28  dennisg
  110.  * Cleaned up file format for a distribution.
  111.  *
  112.  * Revision 0.7  1991/12/03  02:01:23  dennisg
  113.  * fixed assert macro.
  114.  * added memory allocation adjustment macro for hash size allocation.
  115.  *
  116.  * Revision 0.6  1991/11/24  01:20:02  dennisg
  117.  * changed shorts back to ints.
  118.  * the efficiency gained didn't out weight the grossness of the code.
  119.  *
  120.  * Revision 0.5  1991/11/23  22:19:21  dennisg
  121.  * converted some entries in the hash structure from ints to shorts.
  122.  * this was done to use a less expensive division instruction
  123.  * in the hashIndex () routine.
  124.  *
  125.  * Revision 0.4  1991/11/21  22:25:19  dennisg
  126.  * deleted hash mask information from hash struct.
  127.  * changed hashing algorithm.  those values are no longer needed.
  128.  *
  129.  * Revision 0.3  1991/11/07  23:23:40  dennisg
  130.  * implemented hash table expansion as suggested by rms.
  131.  *
  132.  * Revision 0.2  1991/11/07  22:30:54  dennisg
  133.  * added copyleft
  134.  *
  135.  * Revision 0.1  1991/10/24  00:45:39  dennisg
  136.  * Initial check in.  Preliminary development stage.
  137.  *
  138. */
  139.  
  140.  
  141. #ifndef _hash_INCLUDE_GNU
  142. #define _hash_INCLUDE_GNU
  143.  
  144.                                                 /* If someone is using a c++
  145.                                                   compiler then adjust the 
  146.                                                   types in the file back 
  147.                                                   to C. */
  148. #ifdef __cplusplus
  149. extern "C" {
  150. #endif
  151.  
  152. #include        <assert.h>
  153. #include  <sys/types.h>
  154.  
  155. #include        <mutex.h>
  156.  
  157. /*
  158.  * This data structure is used to hold items
  159.  *  stored in a hash table.  Each node holds 
  160.  *  a key/value pair.
  161.  *
  162.  * Items in the cache are really of type void*.
  163.  */
  164. typedef struct cache_node {
  165.   struct cache_node*  nextNode;                   /* Pointer to next entry on
  166.                                                     the list.  NULL indicates
  167.                                                     end of list. */
  168.   void*               theKey;                     /* Key used to locate the
  169.                                                     value.  Used to locate
  170.                                                     value when more than one
  171.                                                     key computes the same hash
  172.                                                     value. */
  173.   void*               theValue;                   /* Value stored for the
  174.                                                     key. */
  175. } CacheNode, *CacheNode_t;
  176.  
  177.  
  178. /*
  179.  * This data type is the function that computes a hash code given a key.
  180.  * Therefore, the key can be a pointer to anything and the function specific
  181.  * to the key type. 
  182.  *
  183.  * Unfortunately there is a mutual data structure reference problem with this
  184.  * typedef.  Therefore, to remove compiler warnings the functions passed to
  185.  * hash_new() will have to be casted to this type. 
  186.  */
  187. typedef u_int   (*HashFunc)(void*, void*);
  188.  
  189. /*
  190.  * This data type is the function that compares two hash keys and returns an
  191.  * integer greater than, equal to, or less than 0, according as the first
  192.  * parameter is lexico-graphically greater than, equal to, or less than the
  193.  * second. 
  194.  */
  195.  
  196. typedef int     (*CompareFunc)(void*, void*);
  197.  
  198.  
  199. /*
  200.  * This data structure is the cache.
  201.  *
  202.  * It must be passed to all of the hashing routines
  203.  *   (except for new).
  204.  */
  205. typedef struct cache {
  206.   /*
  207.    * Variables used to implement the
  208.    *  hash itself.
  209.    */
  210.   CacheNode_t  (* theNodeTable)[];                /* Pointer to an array of
  211.                                                     hash nodes. */
  212.   /*
  213.    * Variables used to track the size of the hash
  214.    *  table so to determine when to resize it.
  215.    */
  216.   u_int       sizeOfHash,                        /* Number of buckets 
  217.                                                     allocated for the hash
  218.                                                     table  (number of array
  219.                                                     entries allocated for
  220.                                                     "theNodeTable").  Must be
  221.                                                     a power of two. */
  222.               entriesInHash,                      /* Current number of entries
  223.                                                     in the hash table. */
  224.                                                         mask;                                                                                                                           /* Precomputed mask. */
  225.   /*
  226.    * Variables used to implement indexing
  227.    *  through the hash table.
  228.    */
  229.   u_int       lastBucket;                         /* Tracks which entry in the
  230.                                                     array where the last value
  231.                                                     was returned. */
  232.                                                                                                                                                                                                         /* Function used to compute
  233.                                                                                                                                                                                                                 a hash code given a key. 
  234.                                                                                                                                                                                                                 This function is specified 
  235.                                                                                                                                                                                                                 when the hash table is 
  236.                                                                                                                                                                                                                 created. */
  237.         HashFunc                hashFunc;
  238.                                                                                                                                                                                                         /* Function used to compare 
  239.                                                                                                                                                                                                                 two hash keys to determine
  240.                                                                                                                                                                                                                 if they are equal. */
  241.         CompareFunc     compareFunc;
  242. } Cache, *Cache_t;
  243.  
  244.  
  245.                                                 /* Prototypes for hash
  246.                                                   functions. */
  247.                                                 /* Allocate and initialize 
  248.                                                   a hash table. */ 
  249. Cache_t 
  250. hash_new (u_int sizeOfHash, HashFunc aHashFunc, CompareFunc aCompareFunc);
  251.                                                 /* Deallocate all of the
  252.                                                   hash nodes and the cache
  253.                                                   itself. */
  254. void 
  255. hash_delete (Cache_t theCache);
  256.                                                 /* Add the key/value pair
  257.                                                   to the hash table.  If the
  258.                                                   hash table reaches a 
  259.                                                   level of fullnes then
  260.                                                   it will be resized. 
  261.                                                    
  262.                                                   assert() if the key is 
  263.                                                   already in the hash. */
  264. void 
  265. hash_add (Cache_t* theCache, void* aKey, void* aValue);
  266.                                                 /* Remove the key/value pair
  267.                                                   from the hash table.  
  268.                                                   assert() if the key isn't 
  269.                                                   in the table. */
  270. void 
  271. hash_remove (Cache_t theCache, void* aKey);
  272.                                                 /* Used to index through the
  273.                                                   hash table.  Start with NULL
  274.                                                   to get the first entry.
  275.                                                   
  276.                                                   Successive calls pass the
  277.                                                   value returned previously.
  278.                                                   ** Don't modify the hash
  279.                                                   during this operation *** 
  280.                                                   
  281.                                                   Cache nodes are returned
  282.                                                   such that key or value can
  283.                                                   ber extracted. */
  284. CacheNode_t 
  285. hash_next (Cache_t theCache, CacheNode_t aCacheNode);
  286.  
  287.                                                                                                                                                                                                 /* Used to return a value from 
  288.                                                                                                                                                                                                         a hash table using a given 
  289.                                                                                                                                                                                                         key.  */
  290. void* 
  291. hash_value_for_key (Cache_t theCache, void* aKey);
  292.  
  293.  
  294. /************************************************
  295.  
  296.         Useful hashing functions.  
  297.         
  298.         Declared inline for your pleaseure. 
  299.         
  300. ************************************************/
  301.  
  302.                                                 /* Calculate a hash code by 
  303.                                                                                                                                                                                                         performing some manipulation 
  304.                                                                                                                                                                                                         of the key pointer. */
  305. static inline u_int 
  306. intHash(Cache_t theCache, void* aKey) {
  307.  
  308.  
  309.   assert(sizeof (u_int) == sizeof (aKey));
  310.  
  311.         return ((u_int)aKey >> (sizeof(void*) - 1)) & theCache->mask ;
  312. }
  313.  
  314.                                                 /* Calculate a hash code by 
  315.                                                                                                                                                                                                         iterating over a NULL 
  316.                                                                                                                                                                                                         terminate string. */
  317. static inline u_int 
  318. strHash(Cache_t theCache, void* aKey) {
  319.  
  320.         u_int   ret = 0;
  321.         u_int   ctr = 0;
  322.         
  323.         
  324.         while(*(char*)aKey) {
  325.                 ret ^= *(char*)aKey++ << ctr;
  326.                 ctr = (ctr + 1) % sizeof(void*);
  327.         }
  328.  
  329.         return ret & theCache->mask ;
  330. }
  331.  
  332.  
  333.                                                                                                                                                                                                 /* Compare two integers. */
  334. static inline int 
  335. intCmp(void* k1, void* k2) {
  336.  
  337.  
  338.         return !((int)k1 - (int)k2);
  339. }
  340.  
  341.  
  342.                                                                                                                                                                                                 /* Compare two strings. */
  343. static inline int 
  344. strCmp(void* k1, void* k2) {
  345.  
  346.  
  347.         return !strcmp( k1, k2 );
  348. }
  349.  
  350.  
  351. #ifdef __cplusplus
  352. }
  353. #endif
  354.  
  355. #endif
  356. @
  357.  
  358.  
  359. 0.9
  360. log
  361. @Check in after array version of run-time works.
  362. Expect more changes as hash version and other changes are made.
  363. @
  364. text
  365. @d1 28
  366. a28 24
  367. /* -*-c-*-
  368.  * This is a general purpose hash object.
  369.  *
  370.  * The hash object used throughout the run-time
  371.  *  is an integer hash.  The key and data is of type
  372.  *  void*.  The hashing function converts the key to
  373.  *  an integer and computes it hash value.
  374.  *
  375.  * Copyright  (C) 1991 Threaded Technologies Inc.
  376.  * 
  377.  * This program is free software; you can redistribute it and/or modify
  378.  * it under the terms of the GNU General Public License as published
  379.  * by the Free Software Foundation; either version 1, or any later version.
  380.  * 
  381.  * This program is distributed in the hope that it will be useful,
  382.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  383.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  384.  * General Public License for more details.
  385.  * 
  386.  * You should receive a copy of the GNU General Public License 
  387.  * along with this program; if not, write to the Free Software
  388.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  389.  * 
  390.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/hash/RCS/hash.h,v 0.8 1991/12/10 12:05:28 dennisg Exp dennisg $
  391. d30 1
  392. a30 1
  393.   $Date: 1991/12/10 12:05:28 $
  394. d32 4
  395. d79 1
  396. a79 1
  397. #include    <assert.h>
  398. d82 1
  399. a82 1
  400. #include    <mutex.h>
  401. d114 1
  402. a114 1
  403. typedef u_int    (*HashFunc)(void*, void*);
  404. d123 1
  405. a123 1
  406. typedef int    (*CompareFunc)(void*, void*);
  407. d151 1
  408. a151 1
  409.                             mask;                                                                /* Precomputed mask. */
  410. d159 10
  411. a168 10
  412.                                                                                                     /* Function used to compute
  413.                                                                                                         a hash code given a key. 
  414.                                                                                                         This function is specified 
  415.                                                                                                         when the hash table is 
  416.                                                                                                         created. */
  417.     HashFunc        hashFunc;
  418.                                                                                                     /* Function used to compare 
  419.                                                                                                         two hash keys to determine
  420.                                                                                                         if they are equal. */
  421.     CompareFunc    compareFunc;
  422. d214 3
  423. a216 3
  424.                                                                                                 /* Used to return a value from 
  425.                                                                                                     a hash table using a given 
  426.                                                                                                     key.  */
  427. d223 4
  428. a226 4
  429.     Useful hashing functions.  
  430.     
  431.     Declared inline for your pleaseure. 
  432.     
  433. d230 2
  434. a231 2
  435.                                                                                                     performing some manipulation 
  436.                                                                                                     of the key pointer. */
  437. d238 1
  438. a238 1
  439.     return ((u_int)aKey >> (sizeof(void*) - 1)) & theCache->mask ;
  440. d242 2
  441. a243 2
  442.                                                                                                     iterating over a NULL 
  443.                                                                                                     terminate string. */
  444. d247 8
  445. a254 8
  446.     u_int    ret = 0;
  447.     u_int    ctr = 0;
  448.     
  449.     
  450.     while(*(char*)aKey) {
  451.         ret ^= *(char*)aKey++ << ctr;
  452.         ctr = (ctr + 1) % sizeof(void*);
  453.     }
  454. d256 1
  455. a256 1
  456.     return ret & theCache->mask ;
  457. d260 1
  458. a260 1
  459.                                                                                                 /* Compare two integers. */
  460. d265 1
  461. a265 1
  462.     return !((int)k1 - (int)k2);
  463. d269 1
  464. a269 1
  465.                                                                                                 /* Compare two strings. */
  466. d274 1
  467. a274 1
  468.     return !strcmp( k1, k2 );
  469. @
  470.  
  471.  
  472. 0.8
  473. log
  474. @Cleaned up file format for a distribution.
  475. @
  476. text
  477. @d24 1
  478. a24 1
  479.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.7 1991/12/03 02:01:23 dennisg Exp dennisg $
  480. d26 1
  481. a26 1
  482.   $Date: 1991/12/03 02:01:23 $
  483. d28 3
  484. d71 1
  485. d74 1
  486. d98 21
  487. d141 3
  488. a143 2
  489.               entriesInHash;                      /* Current number of entries
  490.                                                     in ther hash table. */
  491. d151 10
  492. d167 3
  493. a169 3
  494.                                                   a hash table.  Hash table 
  495.                                                   size taken as a parameter. */ 
  496. Cache_t hash_new (u_int sizeOfHash);
  497. d173 2
  498. a174 1
  499. void hash_delete (Cache_t theCache);
  500. d183 2
  501. a184 1
  502. void hash_add (Cache_t* theCache, void* aKey, void* aValue);
  503. d189 2
  504. a190 1
  505. void hash_remove (Cache_t theCache, void* aKey);
  506. d203 65
  507. a267 1
  508. CacheNode_t hash_next (Cache_t theCache, CacheNode_t aCacheNode);
  509. @
  510.  
  511.  
  512. 0.7
  513. log
  514. @fixed assert macro.
  515. added memory allocation adjustment macro for hash size allocation.
  516. @
  517. text
  518. @d24 1
  519. a24 1
  520.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.6 1991/11/24 01:20:02 dennisg Exp dennisg $
  521. d26 1
  522. a26 1
  523.   $Date: 1991/11/24 01:20:02 $
  524. d28 4
  525. d105 4
  526. a108 4
  527.     /*
  528.      * Variables used to track the size of the hash
  529.      *    table so to determine when to resize it.
  530.      */
  531. d114 3
  532. a116 3
  533.                                                                                                         a power of two. */
  534.                             entriesInHash;                                            /* Current number of entries
  535.                                                                                                         in ther hash table. */
  536. d139 6
  537. a144 6
  538.                                                                                                     hash table reaches a 
  539.                                                                                                     level of fullnes then
  540.                                                                                                     it will be resized. 
  541.                                                                                                      
  542.                                                                                                     assert() if the key is 
  543.                                                                                                     already in the hash. */
  544. @
  545.  
  546.  
  547. 0.6
  548. log
  549. @changed shorts back to ints.
  550. the efficiency gained didn't out weight the grossness of the code.
  551. @
  552. text
  553. @d9 1
  554. a9 1
  555.  * Copyright (C) 1991 Threaded Technologies Inc.
  556. d24 1
  557. a24 1
  558.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.5 1991/11/23 22:19:21 dennisg Exp dennisg $
  559. d26 1
  560. a26 1
  561.   $Date: 1991/11/23 22:19:21 $
  562. d28 4
  563. d35 1
  564. a35 1
  565.  * in the hashIndex() routine.
  566. d92 1
  567. a92 1
  568.  *  (except for new).
  569. d99 1
  570. a99 1
  571.   CacheNode_t (* theNodeTable )[];                /* Pointer to an array of
  572. d105 1
  573. a105 1
  574.   u_int       sizeOfHash,                         /* Number of buckets 
  575. d107 1
  576. a107 1
  577.                                                     table (number of array
  578. d109 2
  579. a110 1
  580.                                                     "theNodeTable"). */
  581. d127 2
  582. a128 4
  583.                                                   size taken as a parameter. 
  584.                                                     A value of 0 is not 
  585.                                                   allowed. */ 
  586. Cache_t hash_new( u_int sizeOfHash );
  587. d132 1
  588. a132 1
  589. void hash_delete( Cache_t theCache );
  590. d141 1
  591. a141 1
  592. void hash_add( Cache_t* theCache, void* aKey, void* aValue );
  593. d146 1
  594. a146 1
  595. void hash_remove( Cache_t theCache, void* aKey );
  596. d159 1
  597. a159 1
  598. CacheNode_t hash_next( Cache_t theCache, CacheNode_t aCacheNode );
  599. @
  600.  
  601.  
  602. 0.5
  603. log
  604. @converted some entries in the hash structure from ints to shorts.
  605. this was done to use a less expensive division instruction
  606. in the hashIndex() routine.
  607. @
  608. text
  609. @d24 1
  610. a24 1
  611.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.4 1991/11/21 22:25:19 dennisg Exp dennisg $
  612. d26 1
  613. a26 1
  614.   $Date: 1991/11/21 22:25:19 $
  615. d28 5
  616. d101 1
  617. a101 1
  618.   u_short     sizeOfHash,                         /* Number of buckets 
  619. @
  620.  
  621.  
  622. 0.4
  623. log
  624. @deleted hash mask information from hash struct.
  625. changed hashing algorithm.  those values are no longer needed.
  626. @
  627. text
  628. @d24 1
  629. a24 1
  630.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.3 1991/11/07 23:23:40 dennisg Exp dennisg $
  631. d26 1
  632. a26 1
  633.   $Date: 1991/11/07 23:23:40 $
  634. d28 4
  635. d96 1
  636. a96 1
  637.   u_int       sizeOfHash,                         /* Number of buckets 
  638. a138 5
  639.                                                 /* Given key, return its 
  640.                                                   value.  Return NULL if the
  641.                                                   key/value pair isn't in
  642.                                                   the hash. */
  643. void* hash_value_for_key( Cache_t theCache, void* aKey );
  644. @
  645.  
  646.  
  647. 0.3
  648. log
  649. @implemented hash table expansion as suggested by rms.
  650. @
  651. text
  652. @d24 1
  653. a24 1
  654.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.2 1991/11/07 22:30:54 dennisg Exp dennisg $
  655. d26 1
  656. a26 1
  657.   $Date: 1991/11/07 22:30:54 $
  658. d28 3
  659. a98 12
  660.     /*
  661.      * Variables used to compute hash
  662.      *    values.
  663.      */
  664.   u_int       mask,                               /* The number of bits set 
  665.                                                                                                         in the mask that is
  666.                                                                                                         contained in the next 
  667.                                                                                                         member variable. */
  668.               numberOfMaskBits;                   /* Number of bits used for
  669.                                                     the mask.  Useful for 
  670.                                                     efficient hash value
  671.                                                     calculation. */
  672. @
  673.  
  674.  
  675. 0.2
  676. log
  677. @added copyleft
  678. @
  679. text
  680. @d24 1
  681. a24 1
  682.   $Header: /usr/user/dennis_glatting/ObjC/c-runtime/lib/RCS/hash.h,v 0.1 1991/10/24 00:45:39 dennisg Exp dennisg $
  683. d26 1
  684. a26 1
  685.   $Date: 1991/10/24 00:45:39 $
  686. d28 3
  687. d85 5
  688. a89 1
  689.   u_int       numberOfBuckets,                    /* Number of buckets 
  690. d93 11
  691. a103 6
  692.                                                     "theCache"). */
  693.               mask,                               /* Mask used when computing
  694.                                                     a hash value.  The number
  695.                                                     of bits set in the mask
  696.                                                     is contained in the next
  697.                                                     member variable. */
  698. d125 1
  699. a125 1
  700. Cache_t hash_new( u_int numberOfBuckets );
  701. d131 8
  702. a138 4
  703.                                                   to the hash table.  assert()
  704.                                                   if the key is already in
  705.                                                   the hash. */
  706. void hash_add( Cache_t theCache, void* aKey, void* aValue );
  707. @
  708.  
  709.  
  710. 0.1
  711. log
  712. @Initial check in.  Preliminary development stage.
  713. @
  714. text
  715. @d9 22
  716. a30 4
  717.   $Header$
  718.   $Author$
  719.   $Date$
  720.   $Log$
  721. @
  722.