home *** CD-ROM | disk | FTP | other *** search
/ Power-Programmierung / CD2.mdf / c / library / os2 / rcs / rcs56src / source / gdbm / pc-files / patches.os2 < prev    next >
Encoding:
Text File  |  1992-01-19  |  56.4 KB  |  1,996 lines
  1. diff -cb orig/bucket.c gdbm/bucket.c
  2. *** orig/bucket.c    Sun Jan 19 14:44:14 1992
  3. --- gdbm/bucket.c    Sun Jan 19 14:43:18 1992
  4. ***************
  5. *** 59,65 ****
  6.      is already in memory.  If not, a bucket may be tossed to read the new
  7.      bucket.  In any case, the requested bucket is make the "current" bucket
  8.      and dbf->bucket points to the correct bucket. */
  9. ! int
  10.   _gdbm_get_bucket (dbf, dir_index)
  11.        gdbm_file_info *dbf;
  12.        long dir_index;
  13. --- 59,65 ----
  14.      is already in memory.  If not, a bucket may be tossed to read the new
  15.      bucket.  In any case, the requested bucket is make the "current" bucket
  16.      and dbf->bucket points to the correct bucket. */
  17. ! void
  18.   _gdbm_get_bucket (dbf, dir_index)
  19.        gdbm_file_info *dbf;
  20.        long dir_index;
  21. ***************
  22. *** 114,120 ****
  23.   void
  24.   _gdbm_split_bucket (dbf, next_insert)
  25.        gdbm_file_info *dbf;
  26. !      int next_insert;
  27.   {
  28.     hash_bucket *bucket[2];     /* Pointers to the new buckets. */
  29.   
  30. --- 114,120 ----
  31.   void
  32.   _gdbm_split_bucket (dbf, next_insert)
  33.        gdbm_file_info *dbf;
  34. !      long next_insert;
  35.   {
  36.     hash_bucket *bucket[2];     /* Pointers to the new buckets. */
  37.   
  38. ***************
  39. *** 184,190 ****
  40.         dir_adr  = _gdbm_alloc (dbf, dir_size);
  41.         new_dir  = (long *) malloc (dir_size);
  42.         if (new_dir == NULL) _gdbm_fatal (dbf, "malloc error");
  43. !       for (index = 0; index < dbf->header->dir_size/sizeof (int); index++)
  44.           {
  45.             new_dir[2*index]   = dbf->dir[index];
  46.             new_dir[2*index+1] = dbf->dir[index];
  47. --- 184,190 ----
  48.         dir_adr  = _gdbm_alloc (dbf, dir_size);
  49.         new_dir  = (long *) malloc (dir_size);
  50.         if (new_dir == NULL) _gdbm_fatal (dbf, "malloc error");
  51. !       for (index = 0; index < dbf->header->dir_size/sizeof (long); index++)
  52.           {
  53.             new_dir[2*index]   = dbf->dir[index];
  54.             new_dir[2*index+1] = dbf->dir[index];
  55. ***************
  56. *** 209,216 ****
  57.         for (index = 0; index < dbf->header->bucket_elems; index++)
  58.       {
  59.         old_el = & (dbf->bucket->h_table[index]);
  60. !       select = (old_el->hash_value >> (31-new_bits)) & 1;
  61. !       elem_loc = old_el->hash_value % dbf->header->bucket_elems;
  62.         while (bucket[select]->h_table[elem_loc].hash_value != -1)
  63.           elem_loc = (elem_loc + 1) % dbf->header->bucket_elems;
  64.         bucket[select]->h_table[elem_loc] = *old_el;
  65. --- 209,216 ----
  66.         for (index = 0; index < dbf->header->bucket_elems; index++)
  67.       {
  68.         old_el = & (dbf->bucket->h_table[index]);
  69. !       select = (int) (old_el->hash_value >> (31-new_bits)) & 1;
  70. !       elem_loc = (int) (old_el->hash_value % dbf->header->bucket_elems);
  71.         while (bucket[select]->h_table[elem_loc].hash_value != -1)
  72.           elem_loc = (elem_loc + 1) % dbf->header->bucket_elems;
  73.         bucket[select]->h_table[elem_loc] = *old_el;
  74. ***************
  75. *** 260,266 ****
  76.         dbf->second_changed = TRUE;
  77.   
  78.         /* Update the cache! */
  79. !       dbf->bucket_dir = next_insert >> (31-dbf->header->dir_bits);
  80.   
  81.         /* Invalidate old cache entry. */
  82.         old_bucket.av_adr  = dbf->cache_entry->ca_adr;
  83. --- 260,266 ----
  84.         dbf->second_changed = TRUE;
  85.   
  86.         /* Update the cache! */
  87. !       dbf->bucket_dir = (int) (next_insert >> (31-dbf->header->dir_bits));
  88.   
  89.         /* Invalidate old cache entry. */
  90.         old_bucket.av_adr  = dbf->cache_entry->ca_adr;
  91. ***************
  92. *** 296,302 ****
  93.   
  94.   /* The only place where a bucket is written.  CA_ENTRY is the
  95.      cache entry containing the bucket to be written. */
  96. ! 
  97.   _gdbm_write_bucket (dbf, ca_entry)
  98.        gdbm_file_info *dbf;
  99.        cache_elem *ca_entry;
  100. --- 296,302 ----
  101.   
  102.   /* The only place where a bucket is written.  CA_ENTRY is the
  103.      cache entry containing the bucket to be written. */
  104. ! void
  105.   _gdbm_write_bucket (dbf, ca_entry)
  106.        gdbm_file_info *dbf;
  107.        cache_elem *ca_entry;
  108. diff -cb orig/dbm.h gdbm/dbm.h
  109. *** orig/dbm.h    Sun Jan 19 14:44:14 1992
  110. --- gdbm/dbm.h    Thu May 23 19:26:30 1991
  111. ***************
  112. *** 34,55 ****
  113.         } datum;
  114.   
  115.   
  116. - /* These are the routines in dbm. */
  117.   
  118. ! extern int    dbminit ();
  119.   
  120.   extern datum    fetch ();
  121. - 
  122.   extern int    store ();
  123. - 
  124.   extern int    delete ();
  125. - 
  126. - extern int    delete ();
  127. - 
  128.   extern datum    firstkey ();
  129. - 
  130.   extern datum    nextkey ();
  131. ! 
  132. ! /* To make some versions work we need the following define. */
  133. ! 
  134. ! #define dbmclose()
  135. --- 34,56 ----
  136.         } datum;
  137.   
  138.   
  139.   
  140. ! /* To make some versions work we need the following define. */
  141.   
  142. + #define dbmclose()
  143. + /* These are the routines in dbm. */
  144. + #ifdef __STDC__
  145. + extern  int dbminit (char *file);
  146. + extern datum fetch(datum key);
  147. + extern int store (datum key, datum content);
  148. + extern int delete (datum key);
  149. + extern datum firstkey (void);
  150. + extern datum nextkey (datum key);
  151. + #else /* not __STDC__ */
  152. + extern int    dbminit ();
  153.   extern datum    fetch ();
  154.   extern int    store ();
  155.   extern int    delete ();
  156.   extern datum    firstkey ();
  157.   extern datum    nextkey ();
  158. ! #endif /* not __STDC__ */
  159. diff -cb orig/dbminit.c gdbm/dbminit.c
  160. *** orig/dbminit.c    Sun Jan 19 14:44:14 1992
  161. --- gdbm/dbminit.c    Sun Jan 19 14:43:18 1992
  162. ***************
  163. *** 87,93 ****
  164. --- 87,97 ----
  165.     if (stat (dir_file, &dir_stat) == 0)
  166.       {
  167.         if (dir_stat.st_size == 0)
  168. + #ifdef OS2
  169. +         if ( 0 /* open (dir_file, O_RDWR|O_TRUNC, S_IREAD|S_IWRITE) < 0 */ )
  170. + #else /* not OS2 */
  171.       if (unlink (dir_file) != 0 || link (pag_file, dir_file) != 0)
  172. + #endif /* not OS2 */
  173.         {
  174.           gdbm_errno = GDBM_FILE_OPEN_ERROR;
  175.           gdbm_close (_gdbm_file);
  176. ***************
  177. *** 98,104 ****
  178. --- 102,112 ----
  179.       {
  180.         /* Since we can't stat it, we assume it is not there and try
  181.            to link the dir_file to the pag_file. */
  182. + #ifdef OS2
  183. +       if ( 0 /* open (dir_file, O_RDWR|O_CREAT, S_IREAD|S_IWRITE) < 0 */ )
  184. + #else /* not OS2 */
  185.         if (link (pag_file, dir_file) != 0)
  186. + #endif /* not OS2 */
  187.       {
  188.         gdbm_errno = GDBM_FILE_OPEN_ERROR;
  189.         gdbm_close (_gdbm_file);
  190. diff -cb orig/dbmopen.c gdbm/dbmopen.c
  191. *** orig/dbmopen.c    Sun Jan 19 14:44:16 1992
  192. --- gdbm/dbmopen.c    Sun Jan 19 14:43:18 1992
  193. ***************
  194. *** 105,111 ****
  195. --- 105,115 ----
  196.     if (stat (dir_file, &dir_stat) == 0)
  197.       {
  198.         if (dir_stat.st_size == 0)
  199. + #ifdef OS2
  200. +         if ( 0 /* open (dir_file, O_RDWR|O_TRUNC, S_IREAD|S_IWRITE) < 0 */ )
  201. + #else /* not OS2 */
  202.       if (unlink (dir_file) != 0 || link (pag_file, dir_file) != 0)
  203. + #endif /* not OS2 */
  204.         {
  205.           gdbm_errno = GDBM_FILE_OPEN_ERROR;
  206.           gdbm_close (temp_dbf);
  207. ***************
  208. *** 116,122 ****
  209. --- 120,130 ----
  210.       {
  211.         /* Since we can't stat it, we assume it is not there and try
  212.            to link the dir_file to the pag_file. */
  213. + #ifdef OS2
  214. +       if ( 0 /* open (dir_file, O_RDWR|O_CREAT, S_IREAD|S_IWRITE) < 0 */ )
  215. + #else /* not OS2 */
  216.         if (link (pag_file, dir_file) != 0)
  217. + #endif /* not OS2 */
  218.       {
  219.         gdbm_errno = GDBM_FILE_OPEN_ERROR;
  220.         gdbm_close (temp_dbf);
  221. diff -cb orig/extern.h gdbm/extern.h
  222. *** orig/extern.h    Sun Jan 19 14:44:18 1992
  223. --- gdbm/extern.h    Thu May 23 19:26:52 1991
  224. ***************
  225. *** 37,53 ****
  226.   
  227.   
  228.   /* External routines used. */
  229. ! 
  230.   extern gdbm_file_info *gdbm_open ();
  231. - 
  232.   extern datum gdbm_fetch ();
  233. - 
  234.   extern datum gdbm_firstkey ();
  235. - 
  236.   extern datum gdbm_nextkey ();
  237. - 
  238.   extern int gdbm_delete ();
  239. - 
  240.   extern int gdbm_store ();
  241.   
  242.   extern void gdbm_close ();
  243. --- 37,56 ----
  244.   
  245.   
  246.   /* External routines used. */
  247. ! #ifdef __STDC__
  248. ! extern gdbm_file_info *gdbm_open (char *file, int block_size, int read_write, int mode, void (*fatal_func)());
  249. ! extern datum gdbm_fetch (gdbm_file_info *dbf, datum key);
  250. ! extern datum gdbm_firstkey (gdbm_file_info *dbf);
  251. ! extern datum gdbm_nextkey (gdbm_file_info *dbf, datum key);
  252. ! extern int gdbm_delete (gdbm_file_info *dbf, datum key);
  253. ! extern int gdbm_reorganize (gdbm_file_info *dbf);
  254. ! #else /* not __STDC__ */
  255.   extern gdbm_file_info *gdbm_open ();
  256.   extern datum gdbm_fetch ();
  257.   extern datum gdbm_firstkey ();
  258.   extern datum gdbm_nextkey ();
  259.   extern int gdbm_delete ();
  260.   extern int gdbm_store ();
  261. + #endif /* not __STDC__ */
  262.   
  263.   extern void gdbm_close ();
  264. diff -cb orig/falloc.c gdbm/falloc.c
  265. *** orig/falloc.c    Sun Jan 19 14:44:18 1992
  266. --- gdbm/falloc.c    Sun Jan 19 14:43:18 1992
  267. ***************
  268. *** 33,43 ****
  269. --- 33,51 ----
  270.   /* The forward definitions for this file.  See the functions for
  271.      the definition of the function. */
  272.   
  273. + #ifdef __STDC__
  274. + static avail_elem get_elem (int size, avail_elem *av_table, int *av_count);
  275. + static avail_elem get_block (int size, gdbm_file_info *dbf);
  276. + static void push_avail_block (gdbm_file_info *dbf);
  277. + static void pop_avail_block (gdbm_file_info *dbf);
  278. + static void adjust_bucket_avail (gdbm_file_info *dbf);
  279. + #else /* not __STDC__ */
  280.   static avail_elem get_elem ();
  281.   static avail_elem get_block ();
  282.   static push_avail_block ();
  283.   static pop_avail_block ();
  284.   static adjust_bucket_avail ();
  285. + #endif /* not __STDC__ */
  286.   
  287.   /* Allocate space in the file DBF for a block NUM_BYTES in length.  Return
  288.      the file address of the start of the block.
  289. ***************
  290. *** 100,105 ****
  291. --- 108,114 ----
  292.      avail structure.  The value TRUE is returned if there were errors.  If no
  293.      errors occured, the value FALSE is returned. */
  294.   
  295. + int
  296.   _gdbm_free (dbf, file_adr, num_bytes)
  297.        gdbm_file_info *dbf;
  298.        long file_adr;
  299. ***************
  300. *** 109,115 ****
  301.   
  302.     /* Is it too small to worry about? */
  303.     if (num_bytes <= IGNORE_SIZE)
  304. !     return;
  305.   
  306.     /* Initialize the avail element. */
  307.     temp.av_size = num_bytes;
  308. --- 118,124 ----
  309.   
  310.     /* Is it too small to worry about? */
  311.     if (num_bytes <= IGNORE_SIZE)
  312. !     return TRUE;        /* is that correct (was "return;")? -tho */
  313.   
  314.     /* Initialize the avail element. */
  315.     temp.av_size = num_bytes;
  316. ***************
  317. *** 148,154 ****
  318.       adjust_bucket_avail (dbf);
  319.   
  320.     /* All work is done. */
  321. !   return;
  322.   }
  323.   
  324.   
  325. --- 157,163 ----
  326.       adjust_bucket_avail (dbf);
  327.   
  328.     /* All work is done. */
  329. !   return TRUE;            /* is that correct (was "return;")? -tho */
  330.   }
  331.   
  332.   
  333. ***************
  334. *** 159,165 ****
  335.   /* Gets the avail block at the top of the stack and loads it into the
  336.      active avail block.  It does a "free" for itself! */
  337.   
  338. ! static
  339.   pop_avail_block (dbf)
  340.        gdbm_file_info *dbf;
  341.   {
  342. --- 168,174 ----
  343.   /* Gets the avail block at the top of the stack and loads it into the
  344.      active avail block.  It does a "free" for itself! */
  345.   
  346. ! static void
  347.   pop_avail_block (dbf)
  348.        gdbm_file_info *dbf;
  349.   {
  350. ***************
  351. *** 189,201 ****
  352.   
  353.   /* Splits the header avail block and pushes half onto the avail stack. */
  354.   
  355. ! static
  356.   push_avail_block (dbf)
  357.        gdbm_file_info *dbf;
  358.   {
  359.     int  num_bytes;
  360.     int  av_size;
  361. !   int  av_adr;
  362.     int  index;
  363.     long file_pos;
  364.     avail_block *temp;
  365. --- 198,210 ----
  366.   
  367.   /* Splits the header avail block and pushes half onto the avail stack. */
  368.   
  369. ! static void
  370.   push_avail_block (dbf)
  371.        gdbm_file_info *dbf;
  372.   {
  373.     int  num_bytes;
  374.     int  av_size;
  375. !   long av_adr;
  376.     int  index;
  377.     long file_pos;
  378.     avail_block *temp;
  379. ***************
  380. *** 216,221 ****
  381. --- 225,237 ----
  382.   
  383.     /* Split the header block. */
  384.     temp = (avail_block *) alloca (av_size);
  385. + #ifdef OS2
  386. +   if (temp == (avail_block *) 0)
  387. +     {
  388. +       fprintf (stderr, "Error: alloca() failed in gdbm (%s).\n", __FILE__);
  389. +       exit (-2);
  390. +     }
  391. + #endif /* OS2 */
  392.     /* Set the size to be correct AFTER the pop_avail_block. */
  393.     temp->size = dbf->header->avail.size;
  394.     temp->count = 0;
  395. ***************
  396. *** 293,298 ****
  397. --- 309,315 ----
  398.   /* This routine inserts a single NEW_EL into the AV_TABLE block in
  399.      sorted order. This routine does no I/O. */
  400.   
  401. + int
  402.   _gdbm_put_av_elem (new_el, av_table, av_count)
  403.        avail_elem new_el;
  404.        avail_elem av_table[];
  405. ***************
  406. *** 366,372 ****
  407.   
  408.   /*  When the header already needs writing, we can make sure the current
  409.       bucket has its avail block as close to 1/2 full as possible. */
  410. ! static
  411.   adjust_bucket_avail (dbf)
  412.        gdbm_file_info *dbf;
  413.   {
  414. --- 383,389 ----
  415.   
  416.   /*  When the header already needs writing, we can make sure the current
  417.       bucket has its avail block as close to 1/2 full as possible. */
  418. ! static void
  419.   adjust_bucket_avail (dbf)
  420.        gdbm_file_info *dbf;
  421.   {
  422. diff -cb orig/findkey.c gdbm/findkey.c
  423. *** orig/findkey.c    Sun Jan 19 14:44:20 1992
  424. --- gdbm/findkey.c    Sun Jan 19 14:43:18 1992
  425. ***************
  426. *** 100,106 ****
  427.   
  428.     /* Compute hash value and load proper bucket.  */
  429.     *new_hash_val = _gdbm_hash (key);
  430. !   _gdbm_get_bucket (dbf, *new_hash_val>> (31-dbf->header->dir_bits));
  431.   
  432.     /* Is the element the last one found for this bucket? */
  433.     if (*new_hash_val == dbf->cache_entry->ca_data.hash_val
  434. --- 100,106 ----
  435.   
  436.     /* Compute hash value and load proper bucket.  */
  437.     *new_hash_val = _gdbm_hash (key);
  438. !   _gdbm_get_bucket (dbf, (int) (*new_hash_val>> (31-dbf->header->dir_bits)));
  439.   
  440.     /* Is the element the last one found for this bucket? */
  441.     if (*new_hash_val == dbf->cache_entry->ca_data.hash_val
  442. ***************
  443. *** 114,120 ****
  444.       }
  445.   
  446.     /* It is not the cached value, search for element in the bucket. */
  447. !   elem_loc = *new_hash_val % dbf->header->bucket_elems;
  448.     home_loc = elem_loc;
  449.     bucket_hash_val = dbf->bucket->h_table[elem_loc].hash_value;
  450.     while (bucket_hash_val != -1)
  451. --- 114,120 ----
  452.       }
  453.   
  454.     /* It is not the cached value, search for element in the bucket. */
  455. !   elem_loc = (int) (*new_hash_val % dbf->header->bucket_elems);
  456.     home_loc = elem_loc;
  457.     bucket_hash_val = dbf->bucket->h_table[elem_loc].hash_value;
  458.     while (bucket_hash_val != -1)
  459. diff -cb orig/gdbm.proto gdbm/gdbm.proto
  460. *** orig/gdbm.proto    Sun Jan 19 14:44:20 1992
  461. --- gdbm/gdbm.proto    Thu May 23 21:57:34 1991
  462. ***************
  463. *** 53,72 ****
  464.   
  465.   /* These are the routines! */
  466.   
  467.   extern GDBM_FILE gdbm_open ();
  468. - 
  469.   extern void     gdbm_close ();
  470. - 
  471.   extern datum     gdbm_fetch ();
  472. - 
  473.   extern int     gdbm_store ();
  474. - 
  475.   extern int     gdbm_delete ();
  476. - 
  477.   extern datum     gdbm_firstkey ();
  478. - 
  479.   extern datum     gdbm_nextkey ();
  480. - 
  481.   extern int     gdbm_reorganize ();
  482. ! 
  483. ! 
  484. --- 53,74 ----
  485.   
  486.   /* These are the routines! */
  487.   
  488. + #ifdef __STDC__
  489. + extern GDBM_FILE gdbm_open (char *, int, int, int, void (*) ());
  490. + extern void     gdbm_close (gdbm_file_info *);
  491. + extern datum     gdbm_fetch (gdbm_file_info *, datum);
  492. + extern int     gdbm_store (gdbm_file_info *, datum, datum, int);
  493. + extern int     gdbm_delete (gdbm_file_info *, datum);
  494. + extern datum     gdbm_firstkey (gdbm_file_info *);
  495. + extern datum     gdbm_nextkey (gdbm_file_info *, datum);
  496. + extern int     gdbm_reorganize (gdbm_file_info *);
  497. + #else
  498.   extern GDBM_FILE gdbm_open ();
  499.   extern void     gdbm_close ();
  500.   extern datum     gdbm_fetch ();
  501.   extern int     gdbm_store ();
  502.   extern int     gdbm_delete ();
  503.   extern datum     gdbm_firstkey ();
  504.   extern datum     gdbm_nextkey ();
  505.   extern int     gdbm_reorganize ();
  506. ! #endif
  507. diff -cb orig/gdbmdefs.h gdbm/gdbmdefs.h
  508. *** orig/gdbmdefs.h    Sun Jan 19 14:44:22 1992
  509. --- gdbm/gdbmdefs.h    Sun Jan 19 14:37:08 1992
  510. ***************
  511. *** 26,36 ****
  512. --- 26,43 ----
  513.           phone:  (206) 676-3035
  514.   *************************************************************************/
  515.   
  516. + #ifdef __STDC__
  517. + #include <stdio.h>
  518. + #include <stdlib.h>
  519. + #include <string.h>
  520. + #endif /*not __STDC__ */
  521.   
  522.   /* Include the standard include files needed for gdbm. */
  523.   #include <stdio.h>
  524.   #include <sys/types.h>
  525. + #ifndef OS2
  526.   #include <sys/file.h>
  527. + #endif
  528.   #include <sys/stat.h>
  529.   #include "gdbmconst.h"
  530.   #include "systems.h"
  531. ***************
  532. *** 198,200 ****
  533. --- 205,247 ----
  534.         } gdbm_file_info;
  535.   
  536.   
  537. + #ifdef __STDC__
  538. + extern void gdbm_close (gdbm_file_info *dbf);
  539. + extern int gdbm_delete (gdbm_file_info *dbf, datum key);
  540. + extern datum gdbm_fetch (gdbm_file_info *dbf, datum key);
  541. + extern gdbm_file_info *gdbm_open (char *file, int block_size, int read_write, int mode, void (*fatal_func)());
  542. + extern int gdbm_reorganize (gdbm_file_info *dbf);
  543. + extern datum gdbm_firstkey (gdbm_file_info *dbf);
  544. + extern datum gdbm_nextkey (gdbm_file_info *dbf, datum key);
  545. + extern int gdbm_store (gdbm_file_info *dbf, datum key, datum content, int flags);
  546. + 
  547. + extern void _gdbm_new_bucket (gdbm_file_info *dbf, hash_bucket *bucket, int bits);
  548. + extern void _gdbm_get_bucket (gdbm_file_info *dbf, long dir_index);
  549. + extern void _gdbm_split_bucket (gdbm_file_info *dbf, long next_insert);
  550. + extern void _gdbm_write_bucket (gdbm_file_info *dbf, cache_elem *ca_entry);
  551. + extern long _gdbm_alloc (gdbm_file_info *dbf, int num_bytes);
  552. + extern int _gdbm_free (gdbm_file_info *dbf, long file_adr, int num_bytes);
  553. + extern int _gdbm_put_av_elem (avail_elem new_el, avail_elem *av_table, int *av_count);
  554. + extern char *_gdbm_read_entry (gdbm_file_info *dbf, int elem_loc);
  555. + extern int _gdbm_findkey (gdbm_file_info *dbf, datum key, char **dptr, long *new_hash_val);
  556. + extern long _gdbm_hash (datum key);
  557. + extern void _gdbm_end_update (gdbm_file_info *dbf);
  558. + extern void _gdbm_fatal (gdbm_file_info *dbf, char *val);
  559. + 
  560. + extern  int dbminit (char *file);
  561. + extern datum fetch(datum key);
  562. + extern int store (datum key, datum content);
  563. + extern int delete (datum key);
  564. + extern datum firstkey (void);
  565. + extern datum nextkey (datum key);
  566. + 
  567. + extern gdbm_file_info *dbm_open (char *file, int flags, int mode);
  568. + extern void dbm_close (gdbm_file_info *dbf);
  569. + extern datum dbm_fetch (gdbm_file_info *dbf, datum key);
  570. + extern int dbm_store (gdbm_file_info *dbf, datum key, datum content, int flags);
  571. + extern int dbm_delete (gdbm_file_info *dbf, datum key);
  572. + extern datum dbm_firstkey (gdbm_file_info *dbf);
  573. + extern datum dbm_nextkey (gdbm_file_info *dbf);
  574. + extern int dbm_dirfno (gdbm_file_info *dbf);
  575. + extern int dbm_pagfno (gdbm_file_info *dbf);
  576. + #endif /* __STDC__ */
  577. diff -cb orig/gdbmdelete.c gdbm/gdbmdelete.c
  578. *** orig/gdbmdelete.c    Sun Jan 19 14:44:22 1992
  579. --- gdbm/gdbmdelete.c    Sun Jan 19 14:43:18 1992
  580. ***************
  581. *** 79,86 ****
  582.     while (elem_loc != last_loc
  583.        && dbf->bucket->h_table[elem_loc].hash_value != -1)
  584.       {
  585. !       home = dbf->bucket->h_table[elem_loc].hash_value
  586. !          % dbf->header->bucket_elems;
  587.         if ( (last_loc < elem_loc && (home <= last_loc || home > elem_loc))
  588.         || (last_loc > elem_loc && home <= last_loc && home > elem_loc))
  589.   
  590. --- 79,86 ----
  591.     while (elem_loc != last_loc
  592.        && dbf->bucket->h_table[elem_loc].hash_value != -1)
  593.       {
  594. !       home = (int) (dbf->bucket->h_table[elem_loc].hash_value
  595. !             % dbf->header->bucket_elems);
  596.         if ( (last_loc < elem_loc && (home <= last_loc || home > elem_loc))
  597.         || (last_loc > elem_loc && home <= last_loc && home > elem_loc))
  598.   
  599. diff -cb orig/gdbmopen.c gdbm/gdbmopen.c
  600. *** orig/gdbmopen.c    Sun Jan 19 14:44:24 1992
  601. --- gdbm/gdbmopen.c    Sun Jan 19 14:43:20 1992
  602. ***************
  603. *** 110,130 ****
  604.     need_trunc = FALSE;
  605.     if (read_write == GDBM_READER)
  606.       {
  607. !       dbf->desc = open (dbf->name, O_RDONLY, 0);
  608.       }
  609.     else if (read_write == GDBM_WRITER)
  610.       {
  611. !       dbf->desc = open (dbf->name, O_RDWR, 0);
  612.       }
  613.     else if (read_write == GDBM_NEWDB)
  614.       {
  615. !       dbf->desc = open (dbf->name, O_RDWR|O_CREAT, mode);
  616.         read_write = GDBM_WRITER;
  617.         need_trunc = TRUE;
  618.       }
  619.     else
  620.       {
  621. !       dbf->desc = open (dbf->name, O_RDWR|O_CREAT, mode);
  622.         read_write = GDBM_WRITER;
  623.       }
  624.     if (dbf->desc < 0)
  625. --- 110,130 ----
  626.     need_trunc = FALSE;
  627.     if (read_write == GDBM_READER)
  628.       {
  629. !       dbf->desc = open (dbf->name, O_RDONLY|O_BINARY, 0);
  630.       }
  631.     else if (read_write == GDBM_WRITER)
  632.       {
  633. !       dbf->desc = open (dbf->name, O_RDWR|O_BINARY, 0);
  634.       }
  635.     else if (read_write == GDBM_NEWDB)
  636.       {
  637. !       dbf->desc = open (dbf->name, O_RDWR|O_CREAT|O_BINARY, mode);
  638.         read_write = GDBM_WRITER;
  639.         need_trunc = TRUE;
  640.       }
  641.     else
  642.       {
  643. !       dbf->desc = open (dbf->name, O_RDWR|O_CREAT|O_BINARY, mode);
  644.         read_write = GDBM_WRITER;
  645.       }
  646.     if (dbf->desc < 0)
  647. ***************
  648. *** 206,212 ****
  649.         dbf->header->block_size = file_block_size;
  650.   
  651.         /* Create the initial hash table directory.  */
  652. !       dbf->header->dir_size = 8 * sizeof (int);
  653.         dbf->header->dir_bits = 3;
  654.         while (dbf->header->dir_size < dbf->header->block_size)
  655.       {
  656. --- 206,212 ----
  657.         dbf->header->block_size = file_block_size;
  658.   
  659.         /* Create the initial hash table directory.  */
  660. !       dbf->header->dir_size = 8 * sizeof (long);
  661.         dbf->header->dir_bits = 3;
  662.         while (dbf->header->dir_size < dbf->header->block_size)
  663.       {
  664. ***************
  665. *** 223,229 ****
  666.       }
  667.   
  668.         /* Allocate the space for the directory. */
  669. !       dbf->dir = (int *) malloc (dbf->header->dir_size);
  670.         if (dbf->dir == NULL)
  671.       {
  672.         gdbm_close (dbf);
  673. --- 223,229 ----
  674.       }
  675.   
  676.         /* Allocate the space for the directory. */
  677. !       dbf->dir = (long *) malloc (dbf->header->dir_size);
  678.         if (dbf->dir == NULL)
  679.       {
  680.         gdbm_close (dbf);
  681. ***************
  682. *** 250,256 ****
  683.         dbf->bucket->bucket_avail[0].av_size = dbf->header->block_size;
  684.   
  685.         /* Set table entries to point to hash buckets. */
  686. !       for (index = 0; index < dbf->header->dir_size / sizeof (int); index++)
  687.       dbf->dir[index] = 2*dbf->header->block_size;
  688.   
  689.         /* Initialize the active avail block. */
  690. --- 250,256 ----
  691.         dbf->bucket->bucket_avail[0].av_size = dbf->header->block_size;
  692.   
  693.         /* Set table entries to point to hash buckets. */
  694. !       for (index = 0; index < dbf->header->dir_size / sizeof (long); index++)
  695.       dbf->dir[index] = 2*dbf->header->block_size;
  696.   
  697.         /* Initialize the active avail block. */
  698. ***************
  699. *** 310,316 ****
  700.       }
  701.   
  702.         /* Is the magic number good? */
  703. !       if (partial_header.header_magic != 0x13579ace)
  704.       {
  705.         gdbm_close (dbf);
  706.         gdbm_errno = GDBM_BAD_MAGIC_NUMBER;
  707. --- 310,316 ----
  708.       }
  709.   
  710.         /* Is the magic number good? */
  711. !       if (partial_header.header_magic != 0x13579ACEL)
  712.       {
  713.         gdbm_close (dbf);
  714.         gdbm_errno = GDBM_BAD_MAGIC_NUMBER;
  715. ***************
  716. *** 336,342 ****
  717.       }
  718.   
  719.         /* Allocate space for the hash table directory.  */
  720. !       dbf->dir = (int *) malloc (dbf->header->dir_size);
  721.         if (dbf->dir == NULL)
  722.       {
  723.         gdbm_close (dbf);
  724. --- 336,342 ----
  725.       }
  726.   
  727.         /* Allocate space for the hash table directory.  */
  728. !       dbf->dir = (long *) malloc (dbf->header->dir_size);
  729.         if (dbf->dir == NULL)
  730.       {
  731.         gdbm_close (dbf);
  732. diff -cb orig/gdbmreorg.c gdbm/gdbmreorg.c
  733. *** orig/gdbmreorg.c    Sun Jan 19 14:44:26 1992
  734. --- gdbm/gdbmreorg.c    Sun Jan 19 14:43:20 1992
  735. ***************
  736. *** 74,79 ****
  737. --- 74,80 ----
  738.     gdbm_file_info *new_dbf;        /* The new file. */
  739.     char *new_name;            /* A temporary name. */
  740.     int  len;                /* Used in new_name construction. */
  741. +   int new_desc;                /* Used to avoid walking file desc */
  742.     datum key, nextkey, data;        /* For the sequential sweep. */
  743.     struct stat fileinfo;            /* Information about the file. */
  744.     int  index;                /* Use in moving the bucket cache. */
  745. ***************
  746. *** 131,139 ****
  747.             gdbm_close (new_dbf);
  748.             gdbm_errno = GDBM_REORGANIZE_FAILED;
  749.             unlink (new_name);
  750.             return -1;
  751. -         };
  752.        }
  753.         else
  754.        {
  755.         /* ERROR! Abort and don't finish reorganize. */
  756. --- 132,141 ----
  757.             gdbm_close (new_dbf);
  758.             gdbm_errno = GDBM_REORGANIZE_FAILED;
  759.             unlink (new_name);
  760. +           free(new_name);
  761.             return -1;
  762.           }
  763. +      }
  764.         else
  765.        {
  766.         /* ERROR! Abort and don't finish reorganize. */
  767. ***************
  768. *** 140,164 ****
  769.         gdbm_close (new_dbf);
  770.         gdbm_errno = GDBM_REORGANIZE_FAILED;
  771.         unlink (new_name);
  772.         return -1;
  773.        }
  774.         nextkey = gdbm_nextkey (dbf, key);
  775.         free (key.dptr);
  776.         key = nextkey;
  777.       }
  778.   
  779.       /* Move the new file to old name. */
  780.   
  781.     if (rename (new_name, dbf->name) != 0)
  782.       {
  783.         gdbm_errno = GDBM_REORGANIZE_FAILED;
  784.         gdbm_close (new_dbf);
  785.         return -1;
  786.       }
  787.   
  788.     /* Fix up DBF to have the correct information for the new file. */
  789.     UNLOCK_FILE(dbf);
  790. !   close (dbf->desc);
  791.     free (dbf->header);
  792.     free (dbf->dir);
  793.     for (index = 0; index < CACHE_SIZE; index++)
  794. --- 142,186 ----
  795.         gdbm_close (new_dbf);
  796.         gdbm_errno = GDBM_REORGANIZE_FAILED;
  797.         unlink (new_name);
  798. +       free(new_name);
  799.         return -1;
  800.        }
  801.         nextkey = gdbm_nextkey (dbf, key);
  802.         free (key.dptr);
  803. +       free (data.dptr);
  804.         key = nextkey;
  805.       }
  806.   
  807.       /* Move the new file to old name. */
  808.   
  809. + #ifdef OS2
  810. +   if (close (new_dbf->desc)
  811. +       || unlink (dbf->name)
  812. +       || rename (new_name, dbf->name)
  813. +       || (new_dbf->desc = open (dbf->name, O_RDWR|O_BINARY)) < 0)
  814. + #else /* not OS2 */
  815.     if (rename (new_name, dbf->name) != 0)
  816. + #endif /* not OS2 */
  817.       {
  818.         gdbm_errno = GDBM_REORGANIZE_FAILED;
  819.         gdbm_close (new_dbf);
  820. +       unlink (new_name);
  821. +       free(new_name);
  822.         return -1;
  823.       }
  824.   
  825.     /* Fix up DBF to have the correct information for the new file. */
  826.     UNLOCK_FILE(dbf);
  827. !   /* close (dbf->desc); */
  828. !   if ((new_desc = dup2(new_dbf->desc, dbf->desc)) < 0)
  829. !     {
  830. !       gdbm_close(new_dbf);
  831. !       gdbm_errno = GDBM_REORGANIZE_FAILED;
  832. !       unlink (new_name);
  833. !       free(new_name);
  834. !       return -1;
  835. !     }
  836. !   dbf->desc = new_desc;
  837.     free (dbf->header);
  838.     free (dbf->dir);
  839.     for (index = 0; index < CACHE_SIZE; index++)
  840. ***************
  841. *** 169,180 ****
  842.       free (dbf->bucket_cache[index].ca_data.dptr);
  843.       }
  844.   
  845. !   dbf->desc           = new_dbf->desc;
  846.     dbf->header         = new_dbf->header;
  847.     dbf->dir            = new_dbf->dir;
  848.     dbf->bucket         = new_dbf->bucket;
  849.     dbf->bucket_dir     = new_dbf->bucket_dir;
  850. !   dbf->cache_entry    = new_dbf->cache_entry;
  851.     dbf->last_read      = new_dbf->last_read;
  852.     for (index = 0; index < CACHE_SIZE; index++)
  853.       dbf->bucket_cache[index] = new_dbf->bucket_cache[index];
  854. --- 191,203 ----
  855.       free (dbf->bucket_cache[index].ca_data.dptr);
  856.       }
  857.   
  858. !   /* dbf->desc           = new_dbf->desc; */
  859.     dbf->header         = new_dbf->header;
  860.     dbf->dir            = new_dbf->dir;
  861.     dbf->bucket         = new_dbf->bucket;
  862.     dbf->bucket_dir     = new_dbf->bucket_dir;
  863. !   /* dbf->cache_entry    = new_dbf->cache_entry; */
  864. !   dbf->cache_entry    = &dbf->bucket_cache[new_dbf->last_read];
  865.     dbf->last_read      = new_dbf->last_read;
  866.     for (index = 0; index < CACHE_SIZE; index++)
  867.       dbf->bucket_cache[index] = new_dbf->bucket_cache[index];
  868. ***************
  869. *** 187,192 ****
  870. --- 210,217 ----
  871.   
  872.     /* Make sure the new database is all on disk. */
  873.     fsync (dbf->desc);
  874. + 
  875. +   free(new_name);
  876.   
  877.     return 0;
  878.   }
  879. diff -cb orig/gdbmseq.c gdbm/gdbmseq.c
  880. *** orig/gdbmseq.c    Sun Jan 19 14:44:26 1992
  881. --- gdbm/gdbmseq.c    Thu May 23 19:54:52 1991
  882. ***************
  883. *** 30,35 ****
  884. --- 30,41 ----
  885.   
  886.   #include "gdbmdefs.h"
  887.   
  888. + 
  889. + #ifdef __STDC__
  890. + static void get_next_key (gdbm_file_info *dbf, int elem_loc, datum *return_val);
  891. + #endif /* not __STDC__ */
  892. + 
  893. + 
  894.   /* Special extern for this file. */
  895.   extern char *_gdbm_read_entry ();
  896.   
  897. ***************
  898. *** 60,71 ****
  899.   
  900.         /* Find the next bucket.  It is possible several entries in
  901.            the bucket directory point to the same bucket. */
  902. !       while (dbf->bucket_dir < dbf->header->dir_size / sizeof (int)
  903.            && dbf->cache_entry->ca_adr == dbf->dir[dbf->bucket_dir])
  904.           dbf->bucket_dir++;
  905.   
  906.         /* Check to see if there was a next bucket. */
  907. !       if (dbf->bucket_dir < dbf->header->dir_size / sizeof (int))
  908.           _gdbm_get_bucket (dbf, dbf->bucket_dir);
  909.         else
  910.           /* No next key, just return. */
  911. --- 66,77 ----
  912.   
  913.         /* Find the next bucket.  It is possible several entries in
  914.            the bucket directory point to the same bucket. */
  915. !       while (dbf->bucket_dir < dbf->header->dir_size / sizeof (long)
  916.            && dbf->cache_entry->ca_adr == dbf->dir[dbf->bucket_dir])
  917.           dbf->bucket_dir++;
  918.   
  919.         /* Check to see if there was a next bucket. */
  920. !       if (dbf->bucket_dir < dbf->header->dir_size / sizeof (long))
  921.           _gdbm_get_bucket (dbf, dbf->bucket_dir);
  922.         else
  923.           /* No next key, just return. */
  924. diff -cb orig/gdbmstore.c gdbm/gdbmstore.c
  925. *** orig/gdbmstore.c    Sun Jan 19 14:44:28 1992
  926. --- gdbm/gdbmstore.c    Sun Jan 19 14:43:20 1992
  927. ***************
  928. *** 123,129 ****
  929.       }
  930.   
  931.         /* Find space to insert into bucket and set elem_loc to that place. */
  932. !       elem_loc = new_hash_val % dbf->header->bucket_elems;
  933.         while (dbf->bucket->h_table[elem_loc].hash_value != -1)
  934.       {  elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; }
  935.   
  936. --- 123,129 ----
  937.       }
  938.   
  939.         /* Find space to insert into bucket and set elem_loc to that place. */
  940. !       elem_loc = (int) (new_hash_val % dbf->header->bucket_elems);
  941.         while (dbf->bucket->h_table[elem_loc].hash_value != -1)
  942.       {  elem_loc = (elem_loc + 1) % dbf->header->bucket_elems; }
  943.   
  944. ***************
  945. *** 142,147 ****
  946. --- 142,154 ----
  947.   
  948.     /* Prepare write_data. The key is written first.  */
  949.     write_data = (char *) alloca (key.dsize+content.dsize);
  950. + #ifdef OS2
  951. +   if (write_data == (char *) 0)
  952. +     {
  953. +       fprintf (stderr, "Error: alloca() failed in gdbm (%s).\n", __FILE__);
  954. +       exit (-2);
  955. +     }
  956. + #endif /* OS2 */
  957.     dst = write_data;
  958.     src = key.dptr;
  959.     for (cnt=0; cnt < key.dsize; cnt++)
  960. diff -cb orig/getopt.c gdbm/getopt.c
  961. *** orig/getopt.c    Sun Dec 09 23:59:50 1990
  962. --- gdbm/getopt.c    Sun Jan 19 14:43:20 1992
  963. ***************
  964. *** 15,26 ****
  965.      along with this program; if not, write to the Free Software
  966.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  967.   
  968. ! #if defined(__STDC__) || defined(MSDOS)
  969.   #define CONST const
  970.   #else
  971.   #define CONST
  972.   #endif
  973. ! #ifdef MSDOS
  974.   #define STDC_HEADERS
  975.   #endif
  976.   
  977. --- 15,26 ----
  978.      along with this program; if not, write to the Free Software
  979.      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  980.   
  981. ! #if defined(__STDC__) || defined(OS2)
  982.   #define CONST const
  983.   #else
  984.   #define CONST
  985.   #endif
  986. ! #ifdef OS2
  987.   #define STDC_HEADERS
  988.   #endif
  989.   
  990. ***************
  991. *** 47,53 ****
  992.   #ifdef sparc
  993.   #include <alloca.h>
  994.   #else
  995. ! #ifdef MSDOS
  996.   #include <malloc.h>
  997.   #else
  998.   char *alloca ();
  999. --- 47,53 ----
  1000.   #ifdef sparc
  1001.   #include <alloca.h>
  1002.   #else
  1003. ! #ifdef OS2
  1004.   #include <malloc.h>
  1005.   #else
  1006.   char *alloca ();
  1007. diff -cb orig/getopt.h gdbm/getopt.h
  1008. *** orig/getopt.h    Sun Oct 28 10:50:34 1990
  1009. --- gdbm/getopt.h    Sun Jan 19 14:37:08 1992
  1010. ***************
  1011. *** 73,79 ****
  1012.     int val;
  1013.   };
  1014.   
  1015. ! #if defined(__STDC__) || defined(MSDOS)
  1016.   extern const struct option *_getopt_long_options;
  1017.   #else
  1018.   extern struct option *_getopt_long_options;
  1019. --- 73,79 ----
  1020.     int val;
  1021.   };
  1022.   
  1023. ! #if defined(__STDC__) || defined(OS2)
  1024.   extern const struct option *_getopt_long_options;
  1025.   #else
  1026.   extern struct option *_getopt_long_options;
  1027. ***************
  1028. *** 90,96 ****
  1029.   
  1030.   extern int option_index;
  1031.   
  1032. ! #if defined(__STDC__) || defined(MSDOS)
  1033.   int getopt (int argc, char **argv, const char *shortopts);
  1034.   int getopt_long (int argc, char **argv, const char *shortopts,
  1035.            const struct option *longopts, int *longind);
  1036. --- 90,96 ----
  1037.   
  1038.   extern int option_index;
  1039.   
  1040. ! #if defined(__STDC__) || defined(OS2)
  1041.   int getopt (int argc, char **argv, const char *shortopts);
  1042.   int getopt_long (int argc, char **argv, const char *shortopts,
  1043.            const struct option *longopts, int *longind);
  1044. diff -cb orig/getopt1.c gdbm/getopt1.c
  1045. *** orig/getopt1.c    Sun Dec 09 23:59:50 1990
  1046. --- gdbm/getopt1.c    Sun Jan 19 14:43:20 1992
  1047. ***************
  1048. *** 17,23 ****
  1049.   
  1050.   #include "getopt.h"
  1051.   
  1052. ! #if defined(__STDC__) || defined(MSDOS)
  1053.   #define CONST const
  1054.   #else
  1055.   #define CONST
  1056. --- 17,23 ----
  1057.   
  1058.   #include "getopt.h"
  1059.   
  1060. ! #if defined(__STDC__) || defined(OS2)
  1061.   #define CONST const
  1062.   #else
  1063.   #define CONST
  1064. diff -cb orig/global.c gdbm/global.c
  1065. *** orig/global.c    Sun Jan 19 14:44:28 1992
  1066. --- gdbm/global.c    Sun Jan 19 14:43:20 1992
  1067. ***************
  1068. *** 41,44 ****
  1069.   char *_gdbm_fetch_val = NULL;    /* Used by fetch. */
  1070.   
  1071.   /* The dbm error number is placed in the variable GDBM_ERRNO. */
  1072. ! gdbm_error gdbm_errno;
  1073. --- 41,45 ----
  1074.   char *_gdbm_fetch_val = NULL;    /* Used by fetch. */
  1075.   
  1076.   /* The dbm error number is placed in the variable GDBM_ERRNO. */
  1077. ! /* won't go into library if not initialized!  */
  1078. ! gdbm_error gdbm_errno = GDBM_NO_ERROR;
  1079. diff -cb orig/ndbm.h gdbm/ndbm.h
  1080. *** orig/ndbm.h    Sun Jan 19 14:44:30 1992
  1081. --- gdbm/ndbm.h    Thu May 23 19:27:24 1991
  1082. ***************
  1083. *** 33,70 ****
  1084.   
  1085.   
  1086.   /* The data and key structure.  This structure is defined for compatibility. */
  1087.   typedef struct {
  1088.       char *dptr;
  1089.       int   dsize;
  1090.         } datum;
  1091.   
  1092. - 
  1093.   /* The file information header. This is good enough for most applications. */
  1094.   typedef struct {int dummy[10];} DBM;
  1095. ! 
  1096.   
  1097.   /* These are the routines (with some macros defining them!) */
  1098.   
  1099.   extern DBM     *dbm_open ();
  1100. - 
  1101.   extern void     dbm_close ();
  1102. - 
  1103.   extern datum     dbm_fetch ();
  1104. - 
  1105.   extern int     dbm_store ();
  1106. - 
  1107. - extern int     dbm_delete ();
  1108. - 
  1109.   extern int     dbm_delete ();
  1110. - 
  1111.   extern datum     dbm_firstkey ();
  1112. - 
  1113.   extern datum     dbm_nextkey ();
  1114.   
  1115.   #define         dbm_error(dbf)  0
  1116. - 
  1117.   #define         dbm_clearerr(dbf)
  1118.   
  1119. - extern int     dbm_dirfno ();
  1120.   
  1121. - extern int     dbm_pagfno ();
  1122. --- 33,79 ----
  1123.   
  1124.   
  1125.   /* The data and key structure.  This structure is defined for compatibility. */
  1126. + #ifdef __STDC__
  1127. + #include "gdbmdefs.h"
  1128. + #else /* not __STDC__ */
  1129.   typedef struct {
  1130.       char *dptr;
  1131.       int   dsize;
  1132.         } datum;
  1133. + #endif /* not __STDC__ */
  1134.   
  1135.   /* The file information header. This is good enough for most applications. */
  1136. + #ifdef __STDC__
  1137. + #define DBM gdbm_file_info
  1138. + #else /* not __STDC__ */
  1139.   typedef struct {int dummy[10];} DBM;
  1140. ! #endif /* not __STDC__ */
  1141.   
  1142.   /* These are the routines (with some macros defining them!) */
  1143.   
  1144. + #ifdef __STDC__
  1145. + extern DBM *dbm_open (char *file, int flags, int mode);
  1146. + extern void dbm_close (DBM *dbf);
  1147. + extern datum dbm_fetch (DBM *dbf, datum key);
  1148. + extern int dbm_store (DBM *dbf, datum key, datum content, int flags);
  1149. + extern int dbm_delete (DBM *dbf, datum key);
  1150. + extern datum dbm_firstkey (DBM *dbf);
  1151. + extern datum dbm_nextkey (DBM *dbf);
  1152. + extern int dbm_dirfno (DBM *dbf);
  1153. + extern int dbm_pagfno (DBM *dbf);
  1154. + #else /* not __STDC__ */
  1155.   extern DBM     *dbm_open ();
  1156.   extern void     dbm_close ();
  1157.   extern datum     dbm_fetch ();
  1158.   extern int     dbm_store ();
  1159.   extern int     dbm_delete ();
  1160.   extern datum     dbm_firstkey ();
  1161.   extern datum     dbm_nextkey ();
  1162. + extern int     dbm_dirfno ();
  1163. + extern int     dbm_pagfno ();
  1164. + #endif /* not __STDC__ */
  1165.   
  1166.   #define         dbm_error(dbf)  0
  1167.   #define         dbm_clearerr(dbf)
  1168.   
  1169.   
  1170. diff -cb orig/readme gdbm/readme
  1171. *** orig/readme    Sun Jan 19 14:44:32 1992
  1172. --- gdbm/readme    Thu May 23 21:55:46 1991
  1173. ***************
  1174. *** 1,3 ****
  1175. --- 1,26 ----
  1176. + /*
  1177. +  * MS-DOS port (c) 1990 by Thorsten Ohl, td12@@ddagsi3.bitnet
  1178. +  *
  1179. +  * To this port, the same copying conditions apply as to the
  1180. +  * original release.
  1181. +  *
  1182. +  * IMPORTANT:
  1183. +  * These files are not identical to the original GNU release!
  1184. +  * You should have received this code as patch to the official
  1185. +  * GNU release.
  1186. +  *
  1187. +  * MORE IMPORTANT:
  1188. +  * This port comes with ABSOLUTELY NO WARRANTY.
  1189. +  */
  1190. + 
  1191. + Note: This port was done for 1.4.
  1192. + I have applied a part of it to 1.5 and made some minor further changes
  1193. + 
  1194. + Kai Uwe Rommel
  1195. + rommel@lan.informatik.tu-muenchen.dbp.de
  1196. + -----------
  1197. + 
  1198. + 
  1199.   This is release 1.5 of GNU dbm.  Better documentation will be written
  1200.   soon.  For now, this file briefly describes the contents of this
  1201.   release and how to use it.
  1202. diff -cb orig/systems.h gdbm/systems.h
  1203. *** orig/systems.h    Sun Jan 19 14:44:32 1992
  1204. --- gdbm/systems.h    Sun Jan 19 14:37:08 1992
  1205. ***************
  1206. *** 27,33 ****
  1207.   
  1208.   *************************************************************************/
  1209.   
  1210. ! 
  1211.   
  1212.   /*         System V changes and defines.          */
  1213.   /**************************************************/
  1214. --- 27,37 ----
  1215.   
  1216.   *************************************************************************/
  1217.   
  1218. ! #ifdef OS2
  1219. ! #ifndef SYSV
  1220. ! #define SYSV
  1221. ! #endif
  1222. ! #endif
  1223.   
  1224.   /*         System V changes and defines.          */
  1225.   /**************************************************/
  1226. ***************
  1227. *** 35,45 ****
  1228. --- 39,59 ----
  1229.   #ifdef SYSV
  1230.   
  1231.   /* File seeking needs L_SET defined .*/
  1232. + #ifdef OS2
  1233. + #include <malloc.h>
  1234. + #include <io.h>
  1235. + #else /* not OS2 */
  1236.   #include <unistd.h>
  1237. + #endif /* not OS2 */
  1238.   #define L_SET SEEK_SET
  1239.   
  1240.   /* Some files need fcntl.h for locking. */
  1241.   #include <fcntl.h>
  1242. + #ifdef OS2
  1243. + #define UNLOCK_FILE(dbf)    /* later !!!  */
  1244. + #define READLOCK_FILE(dbf)    lock_val = 0;
  1245. + #define WRITELOCK_FILE(dbf)    lock_val = 0;
  1246. + #else /* not OS2 */
  1247.   #define UNLOCK_FILE(dbf) \
  1248.       {                    \
  1249.         struct flock flock;            \
  1250. ***************
  1251. *** 64,69 ****
  1252. --- 78,84 ----
  1253.         flock.l_start = flock.l_len = 0L;    \
  1254.         lock_val = fcntl (dbf->desc, F_SETLK, &flock);    \
  1255.       }
  1256. + #endif /* not OS2 */
  1257.   
  1258.   /* Send bcmp to the right place. */
  1259.   #include <memory.h>
  1260. ***************
  1261. *** 71,83 ****
  1262. --- 86,104 ----
  1263.   #define bcopy(d1, d2, n) memcpy(d2, d1, n)
  1264.   
  1265.   /* Sys V does not have fsync. */
  1266. + #ifdef OS2
  1267. + #define fsync(f)
  1268. + #else /* not OS2 */
  1269.   #define fsync(f) sync(); sync()
  1270. + #endif /* not OS2 */
  1271.   
  1272.   /* Stat does not have a st_blksize field. */
  1273.   #define STATBLKSIZE 512
  1274.   
  1275.   /* Does not have rename(). */
  1276. + #ifndef OS2
  1277.   #define NEED_RENAME
  1278. + #endif /* not OS2 */
  1279.   
  1280.   /* Get string definitions. */
  1281.   #include <string.h>
  1282. ***************
  1283. *** 92,98 ****
  1284.   /**************************************************/
  1285.   
  1286.   
  1287. ! 
  1288.   /* Alloca is builtin in gcc.  Use the builtin alloca if compiled with gcc. */
  1289.   #ifdef __GNUC__
  1290.   #define BUILTIN_ALLOCA
  1291. --- 113,119 ----
  1292.   /**************************************************/
  1293.   
  1294.   
  1295. ! #ifndef OS2
  1296.   /* Alloca is builtin in gcc.  Use the builtin alloca if compiled with gcc. */
  1297.   #ifdef __GNUC__
  1298.   #define BUILTIN_ALLOCA
  1299. ***************
  1300. *** 114,119 ****
  1301. --- 135,141 ----
  1302.   
  1303.   /* Malloc definition. */
  1304.   extern char *malloc();
  1305. + #endif /* not OS2 */
  1306.   
  1307.   /* String definitions. */
  1308.   #ifndef _HAVE_STRING
  1309. diff -cb orig/testdbm.c gdbm/testdbm.c
  1310. *** orig/testdbm.c    Sun Jan 19 14:44:34 1992
  1311. --- gdbm/testdbm.c    Sun Jan 19 14:43:20 1992
  1312. ***************
  1313. *** 30,41 ****
  1314. --- 30,48 ----
  1315.   
  1316.   #include <stdio.h>
  1317.   #include <sys/types.h>
  1318. + #ifndef OS2
  1319.   #include <sys/file.h>
  1320. + #endif /* not OS2 */
  1321.   #include <sys/stat.h>
  1322.   
  1323.   #define TRUE  1
  1324.   #define FALSE 0
  1325.   
  1326. + #ifdef __STDC__
  1327. + #include <stdlib.h>
  1328. + #include <string.h>
  1329. + #include "dbm.h"
  1330. + #else /* not __STDC__ */
  1331.   typedef struct {
  1332.     char *dptr;
  1333.     int   dsize;
  1334. ***************
  1335. *** 44,49 ****
  1336. --- 51,57 ----
  1337.   extern datum fetch ();
  1338.   extern datum firstkey ();
  1339.   extern datum nextkey ();
  1340. + #endif /* not __STDC__ */
  1341.   
  1342.   /* The test program allows one to call all the routines plus the hash function.
  1343.      The commands are single letter commands.  The user is prompted for all other
  1344. ***************
  1345. *** 50,61 ****
  1346.      information.  The commands are q (quit), f (fetch), s (store), d (delete),
  1347.      1 (firstkey), n (nextkey) and h (hash function). */
  1348.   
  1349.   main (argc, argv)
  1350.        int argc;
  1351.        char *argv[];
  1352.   {
  1353.   
  1354. !   char  cmd_ch;
  1355.   
  1356.     datum key_data;
  1357.     datum data_data;
  1358. --- 58,70 ----
  1359.      information.  The commands are q (quit), f (fetch), s (store), d (delete),
  1360.      1 (firstkey), n (nextkey) and h (hash function). */
  1361.   
  1362. + void
  1363.   main (argc, argv)
  1364.        int argc;
  1365.        char *argv[];
  1366.   {
  1367.   
  1368. !   int  cmd_ch;
  1369.   
  1370.     datum key_data;
  1371.     datum data_data;
  1372. diff -cb orig/testgdbm.c gdbm/testgdbm.c
  1373. *** orig/testgdbm.c    Sun Jan 19 14:44:38 1992
  1374. --- gdbm/testgdbm.c    Sun Jan 19 14:43:20 1992
  1375. ***************
  1376. *** 43,49 ****
  1377. --- 43,132 ----
  1378.   
  1379.   gdbm_file_info *gdbm_file;
  1380.   
  1381. + #ifdef __STDC__
  1382. + void _gdbm_print_bucket_cache (gdbm_file_info *dbf);
  1383. + static void print_bucket (hash_bucket *bucket, char *mesg);
  1384. + static void _gdbm_print_avail_list (gdbm_file_info *dbf);
  1385. + void main (int argc, char **argv);
  1386. + void usage (char *s);
  1387. + void gdbm_perror (char *msg);
  1388. + extern int getopt (int argc, char **argv, const char *shortopts);
  1389. + #endif /* __STDC__ */
  1390. + 
  1391. + 
  1392. + /* access GDBM_ERRNO.  [tho]  */
  1393. + 
  1394. + void
  1395. + gdbm_perror (char *msg)
  1396. + {
  1397. +   char *err_msg;
  1398. + 
  1399. +   switch (gdbm_errno)
  1400. +     {
  1401. +     case GDBM_NO_ERROR:
  1402. +       err_msg = "no error";
  1403. +       break;
  1404. +     case GDBM_MALLOC_ERROR:
  1405. +       err_msg = "can't malloc";
  1406. +       break;
  1407. +     case GDBM_BLOCK_SIZE_ERROR:
  1408. +       err_msg = "bad block size";
  1409. +       break;
  1410. +     case GDBM_FILE_OPEN_ERROR:
  1411. +       err_msg = "can't open file";
  1412. +       break;
  1413. +     case GDBM_FILE_WRITE_ERROR:
  1414. +       err_msg = "can't write file";
  1415. +       break;
  1416. +     case GDBM_FILE_SEEK_ERROR:
  1417. +       err_msg = "can't seek file";
  1418. +       break;
  1419. +     case GDBM_FILE_READ_ERROR:
  1420. +       err_msg = "can't read file";
  1421. +       break;
  1422. +     case GDBM_BAD_MAGIC_NUMBER:
  1423. +       err_msg = "bad magic number";
  1424. +       break;
  1425. +     case GDBM_EMPTY_DATABASE:
  1426. +       err_msg = "empty database";
  1427. +       break;
  1428. +     case GDBM_CANT_BE_READER:
  1429. +       err_msg = "can't be reader";
  1430. +       break;
  1431. +     case GDBM_CANT_BE_WRITER:
  1432. +       err_msg = "can't be writer";
  1433. +       break;
  1434. +     case GDBM_READER_CANT_DELETE:
  1435. +       err_msg = "can't delete";
  1436. +       break;
  1437. +     case GDBM_READER_CANT_STORE:
  1438. +       err_msg = "can't store";
  1439. +       break;
  1440. +     case GDBM_READER_CANT_REORGANIZE:
  1441. +       err_msg = "can't reorganize";
  1442. +       break;
  1443. +     case GDBM_UNKNOWN_UPDATE:
  1444. +       err_msg = "unkown update";
  1445. +       break;
  1446. +     case GDBM_ITEM_NOT_FOUND:
  1447. +       err_msg = "item not found";
  1448. +       break;
  1449. +     case GDBM_REORGANIZE_FAILED:
  1450. +       err_msg = "reorganization failed";
  1451. +       break;
  1452. +     case GDBM_CANNOT_REPLACE:
  1453. +       err_msg = "can't replace";
  1454. +       break;
  1455. +     default:
  1456. +       err_msg = "unknown error";
  1457. +     }
  1458. + 
  1459. +   fprintf (stderr, "%s (GDBM error: %s)\n", msg, err_msg);
  1460. + }
  1461. + 
  1462. + 
  1463.   /* Debug procedure to print the contents of the current hash bucket. */
  1464. + void
  1465.   print_bucket (bucket, mesg)
  1466.        hash_bucket *bucket;
  1467.        char *mesg;
  1468. ***************
  1469. *** 54,78 ****
  1470.        mesg, bucket->bucket_bits, bucket->count);
  1471.     printf ("     #    hash value     key size    data size     data adr  home\n");
  1472.     for (index = 0; index < gdbm_file->header->bucket_elems; index++)
  1473. !     printf ("  %4d  %12x  %11d  %11d  %11d %5d\n", index,
  1474.          bucket->h_table[index].hash_value,
  1475.          bucket->h_table[index].key_size,
  1476.          bucket->h_table[index].data_size,
  1477.          bucket->h_table[index].data_pointer,
  1478. !        bucket->h_table[index].hash_value % gdbm_file->header->bucket_elems);
  1479.   
  1480.     printf ("\nAvail count = %1d\n", bucket->av_count);
  1481.     printf ("Avail  adr     size\n");
  1482.     for (index = 0; index < bucket->av_count; index++)
  1483. !     printf ("%9d%9d\n", bucket->bucket_avail[index].av_adr,
  1484.                       bucket->bucket_avail[index].av_size);
  1485.   }
  1486.   
  1487.   
  1488.   _gdbm_print_avail_list (dbf)
  1489.        gdbm_file_info *dbf;
  1490.   {
  1491. !   int temp;
  1492.     int size;
  1493.     avail_block *av_stk;
  1494.   
  1495. --- 137,162 ----
  1496.        mesg, bucket->bucket_bits, bucket->count);
  1497.     printf ("     #    hash value     key size    data size     data adr  home\n");
  1498.     for (index = 0; index < gdbm_file->header->bucket_elems; index++)
  1499. !     printf ("  %4d  %12lx  %11d  %11d  %11ld %5d\n", index,
  1500.          bucket->h_table[index].hash_value,
  1501.          bucket->h_table[index].key_size,
  1502.          bucket->h_table[index].data_size,
  1503.          bucket->h_table[index].data_pointer,
  1504. !        (int) (bucket->h_table[index].hash_value % gdbm_file->header->bucket_elems));
  1505.   
  1506.     printf ("\nAvail count = %1d\n", bucket->av_count);
  1507.     printf ("Avail  adr     size\n");
  1508.     for (index = 0; index < bucket->av_count; index++)
  1509. !     printf ("%9ld%9d\n", bucket->bucket_avail[index].av_adr,
  1510.                       bucket->bucket_avail[index].av_size);
  1511.   }
  1512.   
  1513.   
  1514. + void
  1515.   _gdbm_print_avail_list (dbf)
  1516.        gdbm_file_info *dbf;
  1517.   {
  1518. !   long temp;
  1519.     int size;
  1520.     avail_block *av_stk;
  1521.   
  1522. ***************
  1523. *** 81,87 ****
  1524.         dbf->header->avail.size, dbf->header->avail.count);
  1525.     for (temp = 0; temp < dbf->header->avail.count; temp++)
  1526.       {
  1527. !       printf ("  %15d   %10d \n", dbf->header->avail.av_table[temp].av_size,
  1528.             dbf->header->avail.av_table[temp].av_adr);
  1529.       }
  1530.   
  1531. --- 165,171 ----
  1532.         dbf->header->avail.size, dbf->header->avail.count);
  1533.     for (temp = 0; temp < dbf->header->avail.count; temp++)
  1534.       {
  1535. !       printf ("  %15d   %10ld \n", dbf->header->avail.av_table[temp].av_size,
  1536.             dbf->header->avail.av_table[temp].av_adr);
  1537.       }
  1538.   
  1539. ***************
  1540. *** 90,95 ****
  1541. --- 174,186 ----
  1542.     size = ( ( (dbf->header->avail.size * sizeof (avail_elem)) >> 1)
  1543.         + sizeof (avail_block));
  1544.     av_stk = (avail_block *) alloca (size);
  1545. + #ifdef OS2
  1546. +   if (av_stk == (avail_block *) 0)
  1547. +     {
  1548. +       fprintf (stderr, "Error: alloca() failed in gdbm (%s).\n", __FILE__);
  1549. +       exit (-2);
  1550. +     }
  1551. + #endif /* OS2 */
  1552.   
  1553.     /* Print the stack. */
  1554.     while (FALSE)
  1555. ***************
  1556. *** 102,108 ****
  1557.             av_stk->size, av_stk->count);
  1558.         for (temp = 0; temp < av_stk->count; temp++)
  1559.       {
  1560. !       printf ("  %15d   %10d \n", av_stk->av_table[temp].av_size,
  1561.           av_stk->av_table[temp].av_adr);
  1562.       }
  1563.         temp = av_stk->next_block;
  1564. --- 193,199 ----
  1565.             av_stk->size, av_stk->count);
  1566.         for (temp = 0; temp < av_stk->count; temp++)
  1567.       {
  1568. !       printf ("  %15d   %10ld \n", av_stk->av_table[temp].av_size,
  1569.           av_stk->av_table[temp].av_adr);
  1570.       }
  1571.         temp = av_stk->next_block;
  1572. ***************
  1573. *** 109,115 ****
  1574.       }
  1575.   }
  1576.   
  1577. ! _gdbm_print_bucket_cache (dbf)
  1578.        gdbm_file_info *dbf;
  1579.   {
  1580.     int index;
  1581. --- 200,206 ----
  1582.       }
  1583.   }
  1584.   
  1585. ! void _gdbm_print_bucket_cache (dbf)
  1586.        gdbm_file_info *dbf;
  1587.   {
  1588.     int index;
  1589. ***************
  1590. *** 119,125 ****
  1591.     for (index=0; index < CACHE_SIZE; index++)
  1592.       {
  1593.         changed = dbf->bucket_cache[index].ca_changed;
  1594. !       printf ("  %5d:  %7d  %7s  %x\n",
  1595.             index,
  1596.             dbf->bucket_cache[index].ca_adr,
  1597.             (changed ? "True" : "False"),
  1598. --- 210,216 ----
  1599.     for (index=0; index < CACHE_SIZE; index++)
  1600.       {
  1601.         changed = dbf->bucket_cache[index].ca_changed;
  1602. !       printf ("  %5d:  %7ld  %7s  %lx\n",
  1603.             index,
  1604.             dbf->bucket_cache[index].ca_adr,
  1605.             (changed ? "True" : "False"),
  1606. ***************
  1607. *** 139,144 ****
  1608. --- 230,236 ----
  1609.      The commands are single letter commands.  The user is prompted for all other
  1610.      information.  See the help command (?) for a list of all commands. */
  1611.   
  1612. + void
  1613.   main (argc, argv)
  1614.        int argc;
  1615.        char *argv[];
  1616. ***************
  1617. *** 145,151 ****
  1618.   
  1619.   {
  1620.   
  1621. !   char  cmd_ch;
  1622.   
  1623.     datum key_data;
  1624.     datum data_data;
  1625. --- 237,244 ----
  1626.   
  1627.   {
  1628.   
  1629. !   int  cmd_ch;
  1630. !   int  opt;
  1631.   
  1632.     datum key_data;
  1633.     datum data_data;
  1634. ***************
  1635. *** 155,161 ****
  1636.     char data_line[1000];
  1637.   
  1638.     char done = FALSE;
  1639. -   char opt;
  1640.     char reader = FALSE;
  1641.     char newdb = FALSE;
  1642.   
  1643. --- 248,253 ----
  1644. ***************
  1645. *** 180,186 ****
  1646. --- 272,282 ----
  1647.       }
  1648.     else
  1649.       {
  1650. + #ifdef OS2
  1651. +       file_name = "junk.gdb";
  1652. + #else
  1653.         file_name = "junk.gdbm";
  1654. + #endif
  1655.       }
  1656.   
  1657.     /* Initialize variables. */
  1658. ***************
  1659. *** 195,204 ****
  1660.       gdbm_file = gdbm_open (file_name, 512, GDBM_WRCREAT, 00664, NULL);
  1661.     if (gdbm_file == NULL)
  1662.       {
  1663. !       if (gdbm_errno != GDBM_CANT_BE_WRITER)
  1664. !     printf ("gdbm_open failed.\n");
  1665. !       else
  1666. !     printf ("Can't open as a writer. \n");
  1667.         exit (2);
  1668.       }
  1669.   
  1670. --- 291,297 ----
  1671.       gdbm_file = gdbm_open (file_name, 512, GDBM_WRCREAT, 00664, NULL);
  1672.     if (gdbm_file == NULL)
  1673.       {
  1674. !       gdbm_perror ("gdbm_open failed");
  1675.         exit (2);
  1676.       }
  1677.   
  1678. ***************
  1679. *** 208,219 ****
  1680.     while (!done)
  1681.       {
  1682.         printf ("com -> ");
  1683. !       cmd_ch = getchar ();
  1684.         if (cmd_ch != '\n')
  1685.       {
  1686.         char temp;
  1687.         do
  1688. !           temp = getchar ();
  1689.         while (temp != '\n' && temp != EOF);
  1690.       }
  1691.         if (cmd_ch == EOF) cmd_ch = 'q';
  1692. --- 301,312 ----
  1693.     while (!done)
  1694.       {
  1695.         printf ("com -> ");
  1696. !       cmd_ch = (char) getchar ();
  1697.         if (cmd_ch != '\n')
  1698.       {
  1699.         char temp;
  1700.         do
  1701. !           temp = (char) getchar ();
  1702.         while (temp != '\n' && temp != EOF);
  1703.       }
  1704.         if (cmd_ch == EOF) cmd_ch = 'q';
  1705. ***************
  1706. *** 250,256 ****
  1707.         key_data.dptr = key_line;
  1708.         key_data.dsize = strlen (key_line)+1;
  1709.         if (gdbm_delete (gdbm_file, key_data) != 0)
  1710. !         printf ("Item not found or deleted\n");
  1711.         printf ("\n");
  1712.         key_data.dptr = NULL;
  1713.         break;
  1714. --- 343,349 ----
  1715.         key_data.dptr = key_line;
  1716.         key_data.dsize = strlen (key_line)+1;
  1717.         if (gdbm_delete (gdbm_file, key_data) != 0)
  1718. !         gdbm_perror ("Item not found or deleted");
  1719.         printf ("\n");
  1720.         key_data.dptr = NULL;
  1721.         break;
  1722. ***************
  1723. *** 289,295 ****
  1724.           }
  1725.         else
  1726.           {
  1727. !           printf ("No such item found.\n\n");
  1728.             key_data.dptr = NULL;
  1729.           }
  1730.         break;
  1731. --- 382,388 ----
  1732.           }
  1733.         else
  1734.           {
  1735. !           gdbm_perror ("No such item found");
  1736.             key_data.dptr = NULL;
  1737.           }
  1738.         break;
  1739. ***************
  1740. *** 308,314 ****
  1741.         gets (data_line);
  1742.         data_data.dsize = strlen (data_line)+1;
  1743.         if (gdbm_store (gdbm_file, key_data, data_data, GDBM_REPLACE) != 0)
  1744. !         printf ("Item not inserted. \n");
  1745.         printf ("\n");
  1746.         key_data.dptr = NULL;
  1747.         break;
  1748. --- 401,407 ----
  1749.         gets (data_line);
  1750.         data_data.dsize = strlen (data_line)+1;
  1751.         if (gdbm_store (gdbm_file, key_data, data_data, GDBM_REPLACE) != 0)
  1752. !         gdbm_perror ("Item not inserted");
  1753.         printf ("\n");
  1754.         key_data.dptr = NULL;
  1755.         break;
  1756. ***************
  1757. *** 324,330 ****
  1758.             free (return_data.dptr);
  1759.           }
  1760.         else
  1761. !         printf ("No such item found.\n\n");
  1762.         break;
  1763.   
  1764.       case '2':
  1765. --- 417,423 ----
  1766.             free (return_data.dptr);
  1767.           }
  1768.         else
  1769. !         gdbm_perror ("No such item found");
  1770.         break;
  1771.   
  1772.       case '2':
  1773. ***************
  1774. *** 339,345 ****
  1775.             free (return_data.dptr);
  1776.           }
  1777.         else
  1778. !         printf ("No such item found.\n\n");
  1779.         break;
  1780.   
  1781.   
  1782. --- 432,438 ----
  1783.             free (return_data.dptr);
  1784.           }
  1785.         else
  1786. !         gdbm_perror ("No such item found");
  1787.         break;
  1788.   
  1789.   
  1790. ***************
  1791. *** 347,353 ****
  1792.       case 'r':
  1793.         {
  1794.           if (gdbm_reorganize (gdbm_file))
  1795. !           printf ("Reorganization failed. \n\n");
  1796.           else
  1797.             printf ("Reorganization succeeded. \n\n");
  1798.         }
  1799. --- 440,446 ----
  1800.       case 'r':
  1801.         {
  1802.           if (gdbm_reorganize (gdbm_file))
  1803. !           gdbm_perror ("Reorganization failed");
  1804.           else
  1805.             printf ("Reorganization succeeded. \n\n");
  1806.         }
  1807. ***************
  1808. *** 369,375 ****
  1809.   
  1810.           if (temp >= gdbm_file->header->dir_size /4)
  1811.             {
  1812. !         printf ("Not a bucket. \n\n");
  1813.           break;
  1814.             }
  1815.           _gdbm_get_bucket (gdbm_file, temp);
  1816. --- 462,468 ----
  1817.   
  1818.           if (temp >= gdbm_file->header->dir_size /4)
  1819.             {
  1820. !         gdbm_perror ("Not a bucket");
  1821.           break;
  1822.             }
  1823.           _gdbm_get_bucket (gdbm_file, temp);
  1824. ***************
  1825. *** 379,385 ****
  1826.       case 'C':
  1827.         print_bucket (gdbm_file->bucket, "Current bucket");
  1828.         printf ("\n current directory entry = %d.\n", gdbm_file->bucket_dir);
  1829. !       printf (" current bucket address  = %d.\n\n",
  1830.             gdbm_file->cache_entry->ca_adr);
  1831.         break;
  1832.   
  1833. --- 472,478 ----
  1834.       case 'C':
  1835.         print_bucket (gdbm_file->bucket, "Current bucket");
  1836.         printf ("\n current directory entry = %d.\n", gdbm_file->bucket_dir);
  1837. !       printf (" current bucket address  = %ld.\n\n",
  1838.             gdbm_file->cache_entry->ca_adr);
  1839.         break;
  1840.   
  1841. ***************
  1842. *** 392,398 ****
  1843.   
  1844.           for (temp = 0; temp < gdbm_file->header->dir_size / 4; temp++)
  1845.             {
  1846. !         printf ("  %10d:  %12d\n", temp, gdbm_file->dir[temp]);
  1847.           if ( (temp+1) % 20 == 0 && isatty (0))
  1848.             {
  1849.               printf ("*** CR to continue: ");
  1850. --- 485,491 ----
  1851.   
  1852.           for (temp = 0; temp < gdbm_file->header->dir_size / 4; temp++)
  1853.             {
  1854. !         printf ("  %10d:  %12ld\n", temp, gdbm_file->dir[temp]);
  1855.           if ( (temp+1) % 20 == 0 && isatty (0))
  1856.             {
  1857.               printf ("*** CR to continue: ");
  1858. ***************
  1859. *** 406,418 ****
  1860.       case 'F':
  1861.         {
  1862.           printf ("\nFile Header: \n\n");
  1863. !         printf ("  table        = %d\n", gdbm_file->header->dir);
  1864.           printf ("  table size   = %d\n", gdbm_file->header->dir_size);
  1865.           printf ("  table bits   = %d\n", gdbm_file->header->dir_bits);
  1866.           printf ("  block size   = %d\n", gdbm_file->header->block_size);
  1867.           printf ("  bucket elems = %d\n", gdbm_file->header->bucket_elems);
  1868.           printf ("  bucket size  = %d\n", gdbm_file->header->bucket_size);
  1869. !         printf ("  header magic = %x\n", gdbm_file->header->header_magic);
  1870.           printf ("  next block   = %d\n", gdbm_file->header->next_block);
  1871.           printf ("  avail size   = %d\n", gdbm_file->header->avail.size);
  1872.           printf ("  avail count  = %d\n", gdbm_file->header->avail.count);
  1873. --- 499,511 ----
  1874.       case 'F':
  1875.         {
  1876.           printf ("\nFile Header: \n\n");
  1877. !         printf ("  table        = %ld\n", gdbm_file->header->dir);
  1878.           printf ("  table size   = %d\n", gdbm_file->header->dir_size);
  1879.           printf ("  table bits   = %d\n", gdbm_file->header->dir_bits);
  1880.           printf ("  block size   = %d\n", gdbm_file->header->block_size);
  1881.           printf ("  bucket elems = %d\n", gdbm_file->header->bucket_elems);
  1882.           printf ("  bucket size  = %d\n", gdbm_file->header->bucket_size);
  1883. !         printf ("  header magic = %lx\n", gdbm_file->header->header_magic);
  1884.           printf ("  next block   = %d\n", gdbm_file->header->next_block);
  1885.           printf ("  avail size   = %d\n", gdbm_file->header->avail.size);
  1886.           printf ("  avail count  = %d\n", gdbm_file->header->avail.count);
  1887. ***************
  1888. *** 427,433 ****
  1889.         gets (key_line);
  1890.         key_data.dptr = key_line;
  1891.         key_data.dsize = strlen (key_line)+1;
  1892. !       printf ("hash value = %x. \n\n", _gdbm_hash (key_data));
  1893.         key_data.dptr = NULL;
  1894.         break;
  1895.   
  1896. --- 520,526 ----
  1897.         gets (key_line);
  1898.         key_data.dptr = key_line;
  1899.         key_data.dsize = strlen (key_line)+1;
  1900. !       printf ("hash value = %lx. \n\n", _gdbm_hash (key_data));
  1901.         key_data.dptr = NULL;
  1902.         break;
  1903.   
  1904. diff -cb orig/testndbm.c gdbm/testndbm.c
  1905. *** orig/testndbm.c    Sun Jan 19 14:44:38 1992
  1906. --- gdbm/testndbm.c    Sun Jan 19 14:43:20 1992
  1907. ***************
  1908. *** 30,36 ****
  1909. --- 30,38 ----
  1910.   
  1911.   #include <stdio.h>
  1912.   #include <sys/types.h>
  1913. + #ifndef OS2
  1914.   #include <sys/file.h>
  1915. + #endif /* not OS2 */
  1916.   #include <sys/stat.h>
  1917.   #ifdef SYSV
  1918.   #include <fcntl.h>
  1919. ***************
  1920. *** 50,61 ****
  1921.      information.  The commands are q (quit), f (fetch), s (store), d (delete),
  1922.      1 (firstkey), n (nextkey) and h (hash function). */
  1923.   
  1924.   main (argc, argv)
  1925.        int argc;
  1926.        char *argv[];
  1927.   {
  1928.   
  1929. !   char  cmd_ch;
  1930.   
  1931.     datum key_data;
  1932.     datum data_data;
  1933. --- 52,64 ----
  1934.      information.  The commands are q (quit), f (fetch), s (store), d (delete),
  1935.      1 (firstkey), n (nextkey) and h (hash function). */
  1936.   
  1937. + void
  1938.   main (argc, argv)
  1939.        int argc;
  1940.        char *argv[];
  1941.   {
  1942.   
  1943. !   int  cmd_ch;
  1944.   
  1945.     datum key_data;
  1946.     datum data_data;
  1947. diff -cb orig/update.c gdbm/update.c
  1948. *** orig/update.c    Sun Jan 19 14:44:40 1992
  1949. --- gdbm/update.c    Thu May 23 20:01:20 1991
  1950. ***************
  1951. *** 31,39 ****
  1952.   #include "gdbmdefs.h"
  1953.   
  1954.   
  1955.   /* This procedure writes the header back to the file described by DBF. */
  1956.   
  1957. ! static
  1958.   write_header (dbf)
  1959.        gdbm_file_info *dbf;
  1960.   {
  1961. --- 31,44 ----
  1962.   #include "gdbmdefs.h"
  1963.   
  1964.   
  1965. + #ifdef __STDC__
  1966. + static void write_header (gdbm_file_info *dbf);
  1967. + #endif /* __STDC__ */
  1968. + 
  1969. + 
  1970.   /* This procedure writes the header back to the file described by DBF. */
  1971.   
  1972. ! static void
  1973.   write_header (dbf)
  1974.        gdbm_file_info *dbf;
  1975.   {
  1976. ***************
  1977. *** 53,58 ****
  1978. --- 58,64 ----
  1979.   
  1980.   /* After all changes have been made in memory, we now write them
  1981.      all to disk. */
  1982. + void
  1983.   _gdbm_end_update (dbf)
  1984.        gdbm_file_info *dbf;
  1985.   {
  1986. ***************
  1987. *** 103,108 ****
  1988. --- 109,115 ----
  1989.   
  1990.   /* If a fatal error is detected, come here and exit. VAL tells which fatal
  1991.      error occured. */
  1992. + void
  1993.   _gdbm_fatal (dbf, val)
  1994.        gdbm_file_info *dbf;
  1995.        char *val;
  1996.