home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume40 / ddb / patch01 / Patch01
Encoding:
Text File  |  1993-11-26  |  19.3 KB  |  974 lines
  1. *** ../ddb.old/Makefile    Thu Nov 18 00:08:26 1993
  2. --- Makefile    Wed Nov 17 23:53:07 1993
  3. ***************
  4. *** 1,5 ****
  5.   OPT=-O
  6. ! CFLAGS=$(OPT) -I.
  7.   CDBS=hash.c list.c queue.c stack.c binary.c bit.c
  8.   CSRCS=new.c $(CDBS)
  9.   COBJS=$(CSRCS:.c=.o)
  10. --- 1,5 ----
  11.   OPT=-O
  12. ! CFLAGS=$(OPT)
  13.   CDBS=hash.c list.c queue.c stack.c binary.c bit.c
  14.   CSRCS=new.c $(CDBS)
  15.   COBJS=$(CSRCS:.c=.o)
  16. *** ../ddb.old/binary.c    Thu Nov 18 00:08:27 1993
  17. --- binary.c    Thu Nov 18 00:01:03 1993
  18. ***************
  19. *** 21,27 ****
  20.   #include <stdlib.h>
  21.   #include <string.h>
  22.   #include <sys/types.h>
  23. ! #include <ddb.h>
  24.   
  25.   #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  26.   
  27. --- 21,28 ----
  28.   #include <stdlib.h>
  29.   #include <string.h>
  30.   #include <sys/types.h>
  31. ! #include <errno.h>
  32. ! #include "ddb.h"
  33.   
  34.   #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  35.   
  36. ***************
  37. *** 48,53 ****
  38. --- 49,56 ----
  39.   
  40.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  41.   
  42. + extern int    errno;
  43. + 
  44.   int
  45.   ddb_memcmp(const DATUM *dp1, const DATUM *dp2)
  46.   {
  47. ***************
  48. *** 65,71 ****
  49.   static int
  50.   validbd(int bd)
  51.   {
  52. !     return binary && bd < maxbinaries && binary[bd].used;
  53.   }
  54.   
  55.   static int
  56. --- 68,78 ----
  57.   static int
  58.   validbd(int bd)
  59.   {
  60. !     int    valid = binary && bd < maxbinaries && binary[bd].used;
  61. ! 
  62. !     if (!valid)
  63. !         errno = EBADF;
  64. !     return valid;
  65.   }
  66.   
  67.   static int
  68. ***************
  69. *** 77,82 ****
  70. --- 84,90 ----
  71.       case DDB_DUPLICATE:
  72.           return 1;
  73.       default:
  74. +         errno = EINVAL;
  75.           return 0;
  76.       }
  77.   }
  78. ***************
  79. *** 167,172 ****
  80. --- 175,181 ----
  81.               bp->left = bp_new;
  82.           } else /* DDB_INSERT */ {
  83.               bfree(bp_new);
  84. +             errno = EEXIST;
  85.               return -1;
  86.           }
  87.       } else
  88. ***************
  89. *** 191,198 ****
  90.       if (bp = find(bd, key, cmp, NULL))
  91.   #endif
  92.           return &bp->data;
  93. !     else
  94.           return NULL;
  95.   }
  96.   
  97.   int
  98. --- 200,209 ----
  99.       if (bp = find(bd, key, cmp, NULL))
  100.   #endif
  101.           return &bp->data;
  102. !     else {
  103. !         errno = ENOENT;
  104.           return NULL;
  105. +     }
  106.   }
  107.   
  108.   int
  109. ***************
  110. *** 206,212 ****
  111.   #endif
  112.   
  113.       if (!validbd(bd))
  114. !         return NULL;
  115.       if (!cmp)
  116.           cmp = ddb_memcmp;
  117.   
  118. --- 217,223 ----
  119.   #endif
  120.   
  121.       if (!validbd(bd))
  122. !         return -1;
  123.       if (!cmp)
  124.           cmp = ddb_memcmp;
  125.   
  126. ***************
  127. *** 254,261 ****
  128.               free(bp);
  129.           }
  130.           return 0;
  131. !     } else
  132.           return -1;
  133.   }
  134.   
  135.   static void
  136. --- 265,274 ----
  137.               free(bp);
  138.           }
  139.           return 0;
  140. !     } else {
  141. !         errno = ENOENT;
  142.           return -1;
  143. +     }
  144.   }
  145.   
  146.   static void
  147. ***************
  148. *** 385,422 ****
  149.   {
  150.       if (validbd(bd))
  151.           recurse(binary[bd].root, f, order);
  152. - }
  153. - 
  154. - DATUM *
  155. - ddb_blargestkey(int bd)
  156. - {
  157. -     BELEM    *bp;
  158. - 
  159. -     if (!validbd(bd))
  160. -         return NULL;
  161. - 
  162. -     if (bp = binary[bd].root) {
  163. -         while (bp->right)
  164. -             bp = bp->right;
  165. -         return &bp->key;
  166. -     } else
  167. -         return NULL;
  168. - }
  169. - 
  170. - DATUM *
  171. - ddb_bsmallestkey(int bd)
  172. - {
  173. -     BELEM    *bp;
  174. - 
  175. -     if (!validbd(bd))
  176. -         return NULL;
  177. - 
  178. -     if (bp = binary[bd].root) {
  179. -         while (bp->left)
  180. -             bp = bp->left;
  181. -         return &bp->key;
  182. -     } else
  183. -         return NULL;
  184.   }
  185.   
  186.   #ifdef DEBUG
  187. --- 398,403 ----
  188. *** ../ddb.old/bit.c    Thu Nov 18 00:08:27 1993
  189. --- bit.c    Thu Nov 18 00:07:35 1993
  190. ***************
  191. *** 20,26 ****
  192.   #include <string.h>
  193.   #include <limits.h>
  194.   #include <sys/types.h>
  195. ! #include <ddb.h>
  196.   
  197.   #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  198.   
  199. --- 20,27 ----
  200.   #include <string.h>
  201.   #include <limits.h>
  202.   #include <sys/types.h>
  203. ! #include <errno.h>
  204. ! #include "ddb.h"
  205.   
  206.   #define MIN(a,b)    ((a) < (b) ? (a) : (b))
  207.   
  208. ***************
  209. *** 42,54 ****
  210.   static BIT    *vector = NULL;
  211.   static int    maxvectors = 0;
  212.   
  213. ! #define CHECK_MAXBIT    1
  214.   
  215.   static int
  216. ! validbd(int bd, unsigned long bit, int check)
  217.   {
  218. !     return vector && bd < maxvectors && vector[bd].used
  219. !       && (check != CHECK_MAXBIT || bit <= vector[bd].maxbit);
  220.   }
  221.   
  222.   static int
  223. --- 43,58 ----
  224.   static BIT    *vector = NULL;
  225.   static int    maxvectors = 0;
  226.   
  227. ! extern int    errno;
  228.   
  229.   static int
  230. ! validbd(int bd)
  231.   {
  232. !     int    valid = vector && bd < maxvectors && vector[bd].used;
  233. ! 
  234. !     if (!valid)
  235. !         errno = EBADF;
  236. !     return valid;
  237.   }
  238.   
  239.   static int
  240. ***************
  241. *** 60,65 ****
  242. --- 64,70 ----
  243.       case DDB_DUPLICATE:
  244.           return 1;
  245.       default:
  246. +         errno = EINVAL;
  247.           return 0;
  248.       }
  249.   }
  250. ***************
  251. *** 71,78 ****
  252.       unsigned long    nints1, nints2;
  253.       unsigned long    bit;
  254.   
  255. !     if (maxbit > (unsigned long)LONG_MAX)
  256.           return -1;
  257.   
  258.       nints1 = vector[bd].maxbit / WORD_BIT + 1;
  259.       nints2 = maxbit / WORD_BIT + 1;
  260. --- 76,85 ----
  261.       unsigned long    nints1, nints2;
  262.       unsigned long    bit;
  263.   
  264. !     if (maxbit > (unsigned long)LONG_MAX) {
  265. !         errno = EDOM;
  266.           return -1;
  267. +     }
  268.   
  269.       nints1 = vector[bd].maxbit / WORD_BIT + 1;
  270.       nints2 = maxbit / WORD_BIT + 1;
  271. ***************
  272. *** 94,100 ****
  273.   int
  274.   ddb_bitwrite(int bd, unsigned long bit, int mode)
  275.   {
  276. !     if (!validbd(bd, bit, !CHECK_MAXBIT) || !validmode(mode))
  277.           return -1;
  278.       if (bit > vector[bd].maxbit && enlarge(bd, bit) == -1)
  279.           return -1;
  280. --- 101,107 ----
  281.   int
  282.   ddb_bitwrite(int bd, unsigned long bit, int mode)
  283.   {
  284. !     if (!validbd(bd) || !validmode(mode))
  285.           return -1;
  286.       if (bit > vector[bd].maxbit && enlarge(bd, bit) == -1)
  287.           return -1;
  288. ***************
  289. *** 101,108 ****
  290.   
  291.       if (!isset(vector[bd].bits, bit))
  292.           setbit(vector[bd].bits, bit);
  293. !     else if (mode & DDB_INSERT)
  294.           return -1;
  295.   
  296.       return 0;
  297.   }
  298. --- 108,117 ----
  299.   
  300.       if (!isset(vector[bd].bits, bit))
  301.           setbit(vector[bd].bits, bit);
  302. !     else if (mode & DDB_INSERT) {
  303. !         errno = EEXIST;
  304.           return -1;
  305. +     }
  306.   
  307.       return 0;
  308.   }
  309. ***************
  310. *** 110,140 ****
  311.   int
  312.   ddb_bitread(int bd, unsigned long bit)
  313.   {
  314. !     if (!validbd(bd, bit, !CHECK_MAXBIT))
  315.           return -1;
  316.   
  317. !     if (bit > vector[bd].maxbit)
  318.           return 0;
  319. -     return isset(vector[bd].bits, bit) != 0;
  320.   }
  321.   
  322.   int
  323.   ddb_bitdelete(int bd, unsigned long bit)
  324.   {
  325. !     if (!validbd(bd, bit, CHECK_MAXBIT))
  326.           return -1;
  327. ! 
  328. !     if (isset(vector[bd].bits, bit)) {
  329.           clrbit(vector[bd].bits, bit);
  330.           return 0;
  331. !     } else
  332. !         return -1;
  333.   }
  334.   
  335.   int
  336.   ddb_bitclose(int bd)
  337.   {
  338. !     if (!validbd(bd, 0, !CHECK_MAXBIT))
  339.           return -1;
  340.   
  341.       vector[bd].used = 0;
  342. --- 119,152 ----
  343.   int
  344.   ddb_bitread(int bd, unsigned long bit)
  345.   {
  346. !     if (!validbd(bd))
  347.           return -1;
  348.   
  349. !     if (bit > vector[bd].maxbit || !isset(vector[bd].bits, bit)) {
  350. !         errno = ENOENT;
  351. !         return -1;
  352. !     } else
  353.           return 0;
  354.   }
  355.   
  356.   int
  357.   ddb_bitdelete(int bd, unsigned long bit)
  358.   {
  359. !     if (!validbd(bd))
  360.           return -1;
  361. !     if (bit > vector[bd].maxbit || !isset(vector[bd].bits, bit)) {
  362. !         errno = ENOENT;
  363. !         return -1;
  364. !     } else {
  365.           clrbit(vector[bd].bits, bit);
  366.           return 0;
  367. !     }
  368.   }
  369.   
  370.   int
  371.   ddb_bitclose(int bd)
  372.   {
  373. !     if (!validbd(bd))
  374.           return -1;
  375.   
  376.       vector[bd].used = 0;
  377. ***************
  378. *** 147,153 ****
  379.   int
  380.   ddb_bitset(int bd, int on)
  381.   {
  382. !     if (!validbd(bd, 0, !CHECK_MAXBIT))
  383.           return -1;
  384.   
  385.       (void)memset(vector[bd].bits, on ? ~0 : '\0',
  386. --- 159,165 ----
  387.   int
  388.   ddb_bitset(int bd, int on)
  389.   {
  390. !     if (!validbd(bd))
  391.           return -1;
  392.   
  393.       (void)memset(vector[bd].bits, on ? ~0 : '\0',
  394. ***************
  395. *** 164,171 ****
  396.       int        j;
  397.       BIT        *vtmp;
  398.   
  399. !     if (maxbit > (unsigned long)LONG_MAX)
  400.           return -1;
  401.   
  402.       for (i = 0; i < maxvectors && vector[i].used; i++)
  403.           ;
  404. --- 176,185 ----
  405.       int        j;
  406.       BIT        *vtmp;
  407.   
  408. !     if (maxbit > (unsigned long)LONG_MAX) {
  409. !         errno = EDOM;
  410.           return -1;
  411. +     }
  412.   
  413.       for (i = 0; i < maxvectors && vector[i].used; i++)
  414.           ;
  415. ***************
  416. *** 243,250 ****
  417.   {
  418.       unsigned long    index;
  419.   
  420. !     if (!validbd(bd, 0, !CHECK_MAXBIT) || (index = findword(vector[bd].bits,
  421. !       0, vector[bd].maxbit / WORD_BIT, 0)) == -1)
  422.           return -1;
  423.       else
  424.           return vector[bd].lastbit = findlowset(vector[bd].bits[index],
  425. --- 257,264 ----
  426.   {
  427.       unsigned long    index;
  428.   
  429. !     if (!validbd(bd) || (index = findword(vector[bd].bits, 0,
  430. !       vector[bd].maxbit / WORD_BIT, 0)) == -1)
  431.           return -1;
  432.       else
  433.           return vector[bd].lastbit = findlowset(vector[bd].bits[index],
  434. ***************
  435. *** 259,265 ****
  436.       unsigned int    mask;
  437.       unsigned long    index;
  438.   
  439. !     if (!validbd(bd, 0, !CHECK_MAXBIT))
  440.           return -1;
  441.       mask = wordmask(vector[bd].lastbit % WORD_BIT);
  442.       if ((index = findword(vector[bd].bits, vector[bd].lastbit / WORD_BIT,
  443. --- 273,279 ----
  444.       unsigned int    mask;
  445.       unsigned long    index;
  446.   
  447. !     if (!validbd(bd))
  448.           return -1;
  449.       mask = wordmask(vector[bd].lastbit % WORD_BIT);
  450.       if ((index = findword(vector[bd].bits, vector[bd].lastbit / WORD_BIT,
  451. *** ../ddb.old/ddb.3    Thu Nov 18 00:08:27 1993
  452. --- ddb.3    Wed Nov 17 23:53:08 1993
  453. ***************
  454. *** 126,145 ****
  455.   .BR write(\|)
  456.   functions use to add to the databases.
  457.   Must include only one of the following values:
  458. ! .IP DDB_INSERT
  459.   Insert the pair only if the key is not currently in the database.
  460. ! .IP DDB_REPLACE
  461.   Add the pair to the database.
  462.   If the key is already in the database, delete that entry.
  463. ! .IP DDB_DUPLICATE
  464.   Add the pair to the database.
  465.   If the key is already in the database, do not delete that entry.
  466. ! 
  467.   For the
  468.   .BR ddb_lwrite(\|)
  469. ! function, the value
  470. ! .IR DDB_TAIL
  471. ! can be inclusively OR'ed into
  472.   .IR flag
  473.   to specify writing at the tail of the list.
  474.   .IP \fIf\fP
  475. --- 126,145 ----
  476.   .BR write(\|)
  477.   functions use to add to the databases.
  478.   Must include only one of the following values:
  479. ! .RS
  480. ! .IP DDB_INSERT 14
  481.   Insert the pair only if the key is not currently in the database.
  482. ! .IP DDB_REPLACE 14
  483.   Add the pair to the database.
  484.   If the key is already in the database, delete that entry.
  485. ! .IP DDB_DUPLICATE 14
  486.   Add the pair to the database.
  487.   If the key is already in the database, do not delete that entry.
  488. ! .RE
  489. ! .IP
  490.   For the
  491.   .BR ddb_lwrite(\|)
  492. ! function, the value DDB_TAIL can be inclusively OR'ed into
  493.   .IR flag
  494.   to specify writing at the tail of the list.
  495.   .IP \fIf\fP
  496. ***************
  497. *** 229,240 ****
  498.   functions.
  499.   .LP
  500.   Functions returning type pointer\-to\-DATUM return NULL on failure.
  501. ! .SH NOTES
  502. ! All of the
  503.   .BR read(\|)
  504. ! functions except
  505. ! .BR ddb_bitread(\|)
  506. ! return pointers to memory which should be freed when unneeded.
  507.   .LP
  508.   Altering a database and then calling a
  509.   .BR next(\|)
  510. --- 229,329 ----
  511.   functions.
  512.   .LP
  513.   Functions returning type pointer\-to\-DATUM return NULL on failure.
  514. ! .SH ERRORS
  515. ! .LP
  516. ! If an
  517. ! .BR open(\|)
  518. ! function fails, errno will be set to one of the following values:
  519. ! .IP [ENOMEM] 9
  520. ! Sufficient memory could not be allocated.
  521. ! .IP [EDOM] 9
  522. ! .BR ddb_bitopen(\|)
  523. ! has been called with
  524. ! .IR maxbit
  525. ! larger than LONG_MAX.
  526. ! .LP
  527. ! If a
  528. ! .BR close(\|)
  529. ! function fails, errno will be set to
  530. ! .IP [EBADF] 9
  531. ! The
  532. ! .IR dbd
  533. ! argument is not a valid database descriptor.
  534. ! .LP
  535. ! If a
  536.   .BR read(\|)
  537. ! function fails, errno may be set to one of the following values:
  538. ! .IP [EBADF] 9
  539. ! The
  540. ! .IR dbd
  541. ! argument is not a valid database descriptor.
  542. ! .IP [ENOENT] 9
  543. ! The
  544. ! .IR key
  545. ! argument does not specify an entry in the database.
  546. ! .LP
  547. ! Errno is not changed when the relevant database is empty
  548. ! and
  549. ! .BR ddb_lread(\|)
  550. ! is called with
  551. ! .IR key
  552. ! NULL or
  553. ! .BR ddb_qread(\|)
  554. ! or
  555. ! .BR ddb_sread(\|)
  556. ! are called.
  557. ! .LP
  558. ! If a
  559. ! .BR write(\|)
  560. ! function fails, errno will be set to one of the following values:
  561. ! .IP [EBADF] 9
  562. ! The
  563. ! .IR dbd
  564. ! argument is not a valid database descriptor.
  565. ! .IP [EINVAL] 9
  566. ! The
  567. ! .IR flag
  568. ! argument is not valid.
  569. ! .IP [EEXIST] 9
  570. ! The entry indicated by
  571. ! .IR key
  572. ! is already present in the database and DDB_INSERT was specified.
  573. ! .IP [ENOMEM] 9
  574. ! Sufficient memory could not be allocated.
  575. ! .IP [EDOM] 9
  576. ! .BR ddb_bitwrite(\|)
  577. ! has been called with
  578. ! .IR bit
  579. ! larger than LONG_MAX.
  580. ! .LP
  581. ! If a
  582. ! .BR delete(\|)
  583. ! function fails, errno will be set to one of the following values:
  584. ! .IP [EBADF] 9
  585. ! The
  586. ! .IR dbd
  587. ! argument is not a valid database descriptor.
  588. ! .IP [ENOENT] 9
  589. ! The
  590. ! .IR key
  591. ! argument does not specify an entry in the database.
  592. ! .LP
  593. ! When the
  594. ! .BR first(\|)
  595. ! and
  596. ! .BR next(\|)
  597. ! functions fail because the all of the entries in a database have
  598. ! been returned, errno is not changed.
  599. ! However, they can fail with errno set to
  600. ! .IP [EBADF] 9
  601. ! The
  602. ! .IR dbd
  603. ! argument is not a valid database descriptor.
  604. ! .SH NOTES
  605. ! The
  606. ! .BR ddb_qread(\|)
  607. ! function
  608. ! returns a pointer to memory which should be freed when unneeded.
  609.   .LP
  610.   Altering a database and then calling a
  611.   .BR next(\|)
  612. *** ../ddb.old/ddb.h    Thu Nov 18 00:08:27 1993
  613. --- ddb.h    Wed Nov 17 23:53:08 1993
  614. ***************
  615. *** 46,53 ****
  616.   extern DATUM    *ddb_bfirst(int);
  617.   extern DATUM    *ddb_bnext(int);
  618.   extern void    ddb_bfunc(int, void (*)(const DATUM *, const DATUM *), int);
  619. - extern DATUM    *ddb_blargestkey(int);
  620. - extern DATUM    *ddb_bsmallestkey(int);
  621.   #ifdef DEBUG
  622.   extern void    ddb_bdump(int, void (*)(const DATUM *), void (*)(const DATUM *),
  623.             int);
  624. --- 46,51 ----
  625. ***************
  626. *** 61,68 ****
  627.   extern int    ddb_bitread(int, unsigned long);
  628.   extern long    ddb_bitfirst(int);
  629.   extern long    ddb_bitnext(int);
  630. - extern long    ddb_bitlargestkey(int);
  631. - extern long    ddb_bitsmallestkey(int);
  632.   extern int    ddb_bitset(int, int);
  633.   #ifdef DEBUG
  634.   extern void    ddb_bitdump(int);
  635. --- 59,64 ----
  636. *** ../ddb.old/hash.c    Thu Nov 18 00:08:28 1993
  637. --- hash.c    Wed Nov 17 23:53:08 1993
  638. ***************
  639. *** 19,25 ****
  640.   #include <stdlib.h>
  641.   #include <string.h>
  642.   #include <sys/types.h>
  643. ! #include <ddb.h>
  644.   
  645.   typedef struct hashent {
  646.       DATUM        key;
  647. --- 19,26 ----
  648.   #include <stdlib.h>
  649.   #include <string.h>
  650.   #include <sys/types.h>
  651. ! #include <errno.h>
  652. ! #include "ddb.h"
  653.   
  654.   typedef struct hashent {
  655.       DATUM        key;
  656. ***************
  657. *** 46,51 ****
  658. --- 47,54 ----
  659.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  660.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  661.   
  662. + extern int    errno;
  663. + 
  664.   static size_t
  665.   def_hash(const char *key, size_t keysize, size_t nbuckets)
  666.   {
  667. ***************
  668. *** 60,66 ****
  669.   static int
  670.   validhd(int hd)
  671.   {
  672. !     return hashtable && hd < maxtables && hashtable[hd].used;
  673.   }
  674.   
  675.   static DATUM *
  676. --- 63,73 ----
  677.   static int
  678.   validhd(int hd)
  679.   {
  680. !     int    valid =  hashtable && hd < maxtables && hashtable[hd].used;
  681. ! 
  682. !     if (!valid)
  683. !         errno = EBADF;
  684. !     return valid;
  685.   }
  686.   
  687.   static DATUM *
  688. ***************
  689. *** 88,100 ****
  690.           }
  691.   
  692.       if (action == H_READ)
  693. !         return ptr ? &ptr->data : NULL;
  694.   
  695. !     if (ptr && action == DDB_INSERT)
  696.           return NULL;
  697.   
  698. !     if (!ptr && action == H_DELETE)
  699.           return NULL;
  700.   
  701.       if (ptr && action != DDB_DUPLICATE) {    /* H_DELETE || DDB_REPLACE */
  702.           free(ptr->data.addr);
  703. --- 95,116 ----
  704.           }
  705.   
  706.       if (action == H_READ)
  707. !         if (ptr)
  708. !             return &ptr->data;
  709. !         else {
  710. !             errno = ENOENT;
  711. !             return NULL;
  712. !         }
  713.   
  714. !     if (ptr && action == DDB_INSERT) {
  715. !         errno = EEXIST;
  716.           return NULL;
  717. +     }
  718.   
  719. !     if (!ptr && action == H_DELETE) {
  720. !         errno = ENOENT;
  721.           return NULL;
  722. +     }
  723.   
  724.       if (ptr && action != DDB_DUPLICATE) {    /* H_DELETE || DDB_REPLACE */
  725.           free(ptr->data.addr);
  726. ***************
  727. *** 140,148 ****
  728.   ddb_hwrite(int hd, const DATUM *key, const DATUM *data, ddb_cmp_t cmp, int mode,
  729.     ddb_hash_t hash)
  730.   {
  731. !     if (mode != DDB_INSERT && mode != DDB_REPLACE && mode != DDB_DUPLICATE)
  732.           return -1;
  733. !     else if (hashop(hd, mode, key, data, cmp, hash))
  734.           return 0;
  735.       else
  736.           return -1;
  737. --- 156,166 ----
  738.   ddb_hwrite(int hd, const DATUM *key, const DATUM *data, ddb_cmp_t cmp, int mode,
  739.     ddb_hash_t hash)
  740.   {
  741. !     if (mode != DDB_INSERT && mode != DDB_REPLACE
  742. !       && mode != DDB_DUPLICATE) {
  743. !         errno = EINVAL;
  744.           return -1;
  745. !     } else if (hashop(hd, mode, key, data, cmp, hash))
  746.           return 0;
  747.       else
  748.           return -1;
  749. *** ../ddb.old/list.c    Thu Nov 18 00:08:28 1993
  750. --- list.c    Wed Nov 17 23:53:08 1993
  751. ***************
  752. *** 19,25 ****
  753.   #include <stdlib.h>
  754.   #include <string.h>
  755.   #include <sys/types.h>
  756. ! #include <ddb.h>
  757.   
  758.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  759.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  760. --- 19,26 ----
  761.   #include <stdlib.h>
  762.   #include <string.h>
  763.   #include <sys/types.h>
  764. ! #include <errno.h>
  765. ! #include "ddb.h"
  766.   
  767.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  768.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  769. ***************
  770. *** 38,47 ****
  771.   static LIST    *list = NULL;
  772.   static int    maxlists = 0;
  773.   
  774.   static int
  775.   validld(int ld)
  776.   {
  777. !     return list && ld < maxlists && list[ld].used;
  778.   }
  779.   
  780.   static int
  781. --- 39,54 ----
  782.   static LIST    *list = NULL;
  783.   static int    maxlists = 0;
  784.   
  785. + extern int    errno;
  786. + 
  787.   static int
  788.   validld(int ld)
  789.   {
  790. !     int    valid = list && ld < maxlists && list[ld].used;
  791. ! 
  792. !     if (!valid)
  793. !         errno = EBADF;
  794. !     return valid;
  795.   }
  796.   
  797.   static int
  798. ***************
  799. *** 53,58 ****
  800. --- 60,66 ----
  801.       case DDB_DUPLICATE:
  802.           return 1;
  803.       default:
  804. +         errno = EINVAL;
  805.           return 0;
  806.       }
  807.   }
  808. ***************
  809. *** 99,107 ****
  810.           if (mode & DDB_TAIL)
  811.               (void)find(ld, NULL, cmp, &le_prev);
  812.       } else if (le = find(ld, key, cmp, NULL))
  813. !         if (mode & DDB_INSERT)
  814.               return -1;
  815. !         else /* DDB_REPLACE */ {
  816.               free(le->key.addr);
  817.               free(le->data.addr);
  818.               le->key = le_new->key;
  819. --- 107,116 ----
  820.           if (mode & DDB_TAIL)
  821.               (void)find(ld, NULL, cmp, &le_prev);
  822.       } else if (le = find(ld, key, cmp, NULL))
  823. !         if (mode & DDB_INSERT) {
  824. !             errno = EEXIST;
  825.               return -1;
  826. !         } else /* DDB_REPLACE */ {
  827.               free(le->key.addr);
  828.               free(le->data.addr);
  829.               le->key = le_new->key;
  830. ***************
  831. *** 144,149 ****
  832. --- 153,159 ----
  833.       if (le = find(ld, key, cmp, NULL))
  834.           return &le->data;
  835.   
  836. +     errno = ENOENT;
  837.       return NULL;
  838.   }
  839.   
  840. ***************
  841. *** 173,178 ****
  842. --- 183,189 ----
  843.           return 0;
  844.       }
  845.   
  846. +     errno = ENOENT;
  847.       return -1;
  848.   }
  849.   
  850. *** ../ddb.old/new.c    Thu Nov 18 00:08:28 1993
  851. --- new.c    Wed Nov 17 23:53:08 1993
  852. ***************
  853. *** 19,25 ****
  854.   #include <stdlib.h>
  855.   #include <sys/types.h>
  856.   #include <string.h>
  857. ! #include <ddb.h>
  858.   
  859.   void *
  860.   ddb_new(const DATUM *key, const DATUM *data, size_t size)
  861. --- 19,25 ----
  862.   #include <stdlib.h>
  863.   #include <sys/types.h>
  864.   #include <string.h>
  865. ! #include "ddb.h"
  866.   
  867.   void *
  868.   ddb_new(const DATUM *key, const DATUM *data, size_t size)
  869. *** ../ddb.old/patchlevel.h    Thu Nov 18 00:08:28 1993
  870. --- patchlevel.h    Wed Nov 17 23:53:09 1993
  871. ***************
  872. *** 1 ****
  873. ! #define PATCHLEVEL    0
  874. --- 1 ----
  875. ! #define PATCHLEVEL    1
  876. *** ../ddb.old/queue.c    Thu Nov 18 00:08:28 1993
  877. --- queue.c    Wed Nov 17 23:53:09 1993
  878. ***************
  879. *** 18,24 ****
  880.   #include <stdio.h>
  881.   #include <stdlib.h>
  882.   #include <sys/types.h>
  883. ! #include <ddb.h>
  884.   
  885.   typedef struct qent {
  886.       DATUM        data;
  887. --- 18,25 ----
  888.   #include <stdio.h>
  889.   #include <stdlib.h>
  890.   #include <sys/types.h>
  891. ! #include <errno.h>
  892. ! #include "ddb.h"
  893.   
  894.   typedef struct qent {
  895.       DATUM        data;
  896. ***************
  897. *** 35,44 ****
  898.   
  899.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  900.   
  901.   static int
  902.   validqd(int qd)
  903.   {
  904. !     return queue && qd < maxqueues && queue[qd].used;
  905.   }
  906.   
  907.   int
  908. --- 36,51 ----
  909.   
  910.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  911.   
  912. + extern int    errno;
  913. + 
  914.   static int
  915.   validqd(int qd)
  916.   {
  917. !     int    valid = queue && qd < maxqueues && queue[qd].used;
  918. ! 
  919. !     if (!valid)
  920. !         errno = EBADF;
  921. !     return valid;
  922.   }
  923.   
  924.   int
  925. *** ../ddb.old/stack.c    Thu Nov 18 00:08:29 1993
  926. --- stack.c    Wed Nov 17 23:53:09 1993
  927. ***************
  928. *** 18,24 ****
  929.   #include <stdio.h>
  930.   #include <stdlib.h>
  931.   #include <sys/types.h>
  932. ! #include <ddb.h>
  933.   
  934.   typedef struct {
  935.       int    used;
  936. --- 18,25 ----
  937.   #include <stdio.h>
  938.   #include <stdlib.h>
  939.   #include <sys/types.h>
  940. ! #include <errno.h>
  941. ! #include "ddb.h"
  942.   
  943.   typedef struct {
  944.       int    used;
  945. ***************
  946. *** 31,40 ****
  947.   
  948.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  949.   
  950.   static int
  951.   validsd(int sd)
  952.   {
  953. !     return stack && sd < maxstacks && stack[sd].used;
  954.   }
  955.   
  956.   int
  957. --- 32,47 ----
  958.   
  959.   extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  960.   
  961. + extern int    errno;
  962. + 
  963.   static int
  964.   validsd(int sd)
  965.   {
  966. !     int    valid = stack && sd < maxstacks && stack[sd].used;
  967. ! 
  968. !     if (!valid)
  969. !         errno = EBADF;
  970. !     return valid;
  971.   }
  972.   
  973.   int
  974.