home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume42 / ddb / patch03 / Patch03
Encoding:
Text File  |  1994-05-06  |  11.0 KB  |  509 lines
  1. *** ../ddb.old/binary.c    Mon Mar 21 16:59:28 1994
  2. --- binary.c    Mon Jan 10 10:40:45 1994
  3. ***************
  4. *** 47,53 ****
  5.   static BINARY    *binary = NULL;
  6.   static int    maxbinaries = 0;
  7.   
  8. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  9.   
  10.   extern int    errno;
  11.   
  12. --- 47,53 ----
  13.   static BINARY    *binary = NULL;
  14.   static int    maxbinaries = 0;
  15.   
  16. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t, int);
  17.   
  18.   extern int    errno;
  19.   
  20. ***************
  21. *** 154,160 ****
  22.       BELEM    **prev;
  23.   
  24.       if (!validbd(bd) || !validmode(mode)
  25. !       || (bp_new = ddb_new(key, data, sizeof(*bp_new))) == NULL)
  26.           return -1;
  27.       if (!cmp)
  28.           cmp = ddb_memcmp;
  29. --- 154,160 ----
  30.       BELEM    **prev;
  31.   
  32.       if (!validbd(bd) || !validmode(mode)
  33. !       || (bp_new = ddb_new(key, data, sizeof(*bp_new), 1)) == NULL)
  34.           return -1;
  35.       if (!cmp)
  36.           cmp = ddb_memcmp;
  37. *** ../ddb.old/ddb.3    Mon Mar 21 16:59:28 1994
  38. --- ddb.3    Mon Feb 21 17:00:44 1994
  39. ***************
  40. *** 5,11 ****
  41.   .SH SYNOPSIS
  42.   .LP
  43.   .nf
  44. - .ft B
  45.   #include "ddb.h"
  46.   typedef struct {
  47.       void    *addr;
  48. --- 5,10 ----
  49. ***************
  50. *** 14,25 ****
  51.   .sp
  52.   typedef int    (*ddb_cmp_t)(const DATUM *key1, const DATUM *key2);
  53.   typedef size_t    (*ddb_hash_t)(const char *addr, size_t size, size_t buckets);
  54. - .ft
  55.   .fi
  56.   .LP
  57.   .nf
  58. ! .ft B
  59.   Binary Tree Interface
  60.   int    ddb_bopen(void);
  61.   int    ddb_bclose(int dbd);
  62.   int    ddb_bwrite(int dbd, const DATUM *key, const DATUM *data,
  63. --- 13,24 ----
  64.   .sp
  65.   typedef int    (*ddb_cmp_t)(const DATUM *key1, const DATUM *key2);
  66.   typedef size_t    (*ddb_hash_t)(const char *addr, size_t size, size_t buckets);
  67.   .fi
  68.   .LP
  69.   .nf
  70. ! .ft I
  71.   Binary Tree Interface
  72. + .ft
  73.   int    ddb_bopen(void);
  74.   int    ddb_bclose(int dbd);
  75.   int    ddb_bwrite(int dbd, const DATUM *key, const DATUM *data,
  76. ***************
  77. *** 30,41 ****
  78.   DATUM    *ddb_bnext(int dbd);
  79.   void    ddb_bfunc(int dbd, void (*f)(const DATUM *key, const DATUM *data),
  80.         int order);
  81. - .ft
  82.   .fi
  83.   .LP
  84.   .nf
  85. ! .ft B
  86.   Bit Vector Interface
  87.   int    ddb_bitopen(unsigned long maxbit);
  88.   int    ddb_bitclose(int dbd);
  89.   int    ddb_bitwrite(int dbd, unsigned long bit, int flag);
  90. --- 29,40 ----
  91.   DATUM    *ddb_bnext(int dbd);
  92.   void    ddb_bfunc(int dbd, void (*f)(const DATUM *key, const DATUM *data),
  93.         int order);
  94.   .fi
  95.   .LP
  96.   .nf
  97. ! .ft I
  98.   Bit Vector Interface
  99. + .ft
  100.   int    ddb_bitopen(unsigned long maxbit);
  101.   int    ddb_bitclose(int dbd);
  102.   int    ddb_bitwrite(int dbd, unsigned long bit, int flag);
  103. ***************
  104. *** 44,55 ****
  105.   long    ddb_bitfirst(int dbd);
  106.   long    ddb_bitnext(int dbd);
  107.   int    ddb_bitset(int dbd, int on);
  108. - .ft
  109.   .fi
  110.   .LP
  111.   .nf
  112. ! .ft B
  113.   Hash Table Interface
  114.   int    ddb_hopen(size_t buckets);
  115.   int    ddb_hclose(int dbd);
  116.   int    ddb_hwrite(int dbd, const DATUM *key, const DATUM *data,
  117. --- 43,54 ----
  118.   long    ddb_bitfirst(int dbd);
  119.   long    ddb_bitnext(int dbd);
  120.   int    ddb_bitset(int dbd, int on);
  121.   .fi
  122.   .LP
  123.   .nf
  124. ! .ft I
  125.   Hash Table Interface
  126. + .ft
  127.   int    ddb_hopen(size_t buckets);
  128.   int    ddb_hclose(int dbd);
  129.   int    ddb_hwrite(int dbd, const DATUM *key, const DATUM *data,
  130. ***************
  131. *** 60,71 ****
  132.         ddb_hash_t hash);
  133.   DATUM    *ddb_hfirst(int dbd);
  134.   DATUM    *ddb_hnext(int dbd);
  135. - .ft
  136.   .fi
  137.   .LP
  138.   .nf
  139. ! .ft B
  140.   Linked List Interface
  141.   int    ddb_lopen(void);
  142.   int    ddb_lclose(int dbd);
  143.   int    ddb_lwrite(int dbd, const DATUM *key, const DATUM *data,
  144. --- 59,70 ----
  145.         ddb_hash_t hash);
  146.   DATUM    *ddb_hfirst(int dbd);
  147.   DATUM    *ddb_hnext(int dbd);
  148.   .fi
  149.   .LP
  150.   .nf
  151. ! .ft I
  152.   Linked List Interface
  153. + .ft
  154.   int    ddb_lopen(void);
  155.   int    ddb_lclose(int dbd);
  156.   int    ddb_lwrite(int dbd, const DATUM *key, const DATUM *data,
  157. ***************
  158. *** 74,100 ****
  159.   DATUM    *ddb_lread(int dbd, const DATUM *key, ddb_cmp_t cmp);
  160.   DATUM    *ddb_lfirst(int dbd);
  161.   DATUM    *ddb_lnext(int dbd);
  162. - .ft
  163.   .fi
  164.   .LP
  165.   .nf
  166. ! .ft B
  167.   Queue Interface
  168.   int    ddb_qopen(void);
  169.   int    ddb_qclose(int dbd);
  170.   int    ddb_qwrite(int dbd, const DATUM *key);
  171.   DATUM    *ddb_qread(int dbd);
  172. - .ft
  173.   .fi
  174.   .LP
  175.   .nf
  176. ! .ft B
  177.   Stack Interface
  178.   int    ddb_sopen(void);
  179.   int    ddb_sclose(int dbd);
  180.   int    ddb_swrite(int dbd, const DATUM *key);
  181.   DATUM    *ddb_sread(int dbd);
  182. - .ft
  183.   .fi
  184.   .SH PARAMETERS
  185.   .IP \fIdbd\fP
  186. --- 73,98 ----
  187.   DATUM    *ddb_lread(int dbd, const DATUM *key, ddb_cmp_t cmp);
  188.   DATUM    *ddb_lfirst(int dbd);
  189.   DATUM    *ddb_lnext(int dbd);
  190.   .fi
  191.   .LP
  192.   .nf
  193. ! .ft I
  194.   Queue Interface
  195. + .ft
  196.   int    ddb_qopen(void);
  197.   int    ddb_qclose(int dbd);
  198.   int    ddb_qwrite(int dbd, const DATUM *key);
  199.   DATUM    *ddb_qread(int dbd);
  200.   .fi
  201.   .LP
  202.   .nf
  203. ! .ft I
  204.   Stack Interface
  205. + .ft
  206.   int    ddb_sopen(void);
  207.   int    ddb_sclose(int dbd);
  208.   int    ddb_swrite(int dbd, const DATUM *key);
  209.   DATUM    *ddb_sread(int dbd);
  210.   .fi
  211.   .SH PARAMETERS
  212.   .IP \fIdbd\fP
  213. ***************
  214. *** 209,216 ****
  215.   The
  216.   .BR close(\|) ,
  217.   .BR write(\|) ,
  218.   and
  219. ! .BR delete(\|)
  220.   functions return 0 on success and -1 otherwise.
  221.   .LP
  222.   The
  223. --- 207,215 ----
  224.   The
  225.   .BR close(\|) ,
  226.   .BR write(\|) ,
  227. + .BR delete(\|) ,
  228.   and
  229. ! .BR bitread(\|)
  230.   functions return 0 on success and -1 otherwise.
  231.   .LP
  232.   The
  233. ***************
  234. *** 229,234 ****
  235. --- 228,237 ----
  236.   functions.
  237.   .LP
  238.   Functions returning type pointer\-to\-DATUM return NULL on failure.
  239. + .LP
  240. + The
  241. + .BR bitset(\|)
  242. + function is used to either set or unset all bits.
  243.   .SH ERRORS
  244.   .LP
  245.   If an
  246. ***************
  247. *** 322,329 ****
  248.   .SH NOTES
  249.   The
  250.   .BR ddb_qread(\|)
  251. ! function
  252. ! returns a pointer to memory which should be freed when unneeded.
  253.   .LP
  254.   Altering a database and then calling a
  255.   .BR next(\|)
  256. --- 325,334 ----
  257.   .SH NOTES
  258.   The
  259.   .BR ddb_qread(\|)
  260. ! and
  261. ! .BR ddb_sread(\|)
  262. ! functions
  263. ! return pointers to memory which should be freed when unneeded.
  264.   .LP
  265.   Altering a database and then calling a
  266.   .BR next(\|)
  267. *** ../ddb.old/ddb.h    Mon Mar 21 16:59:29 1994
  268. --- ddb.h    Tue Jan 11 11:29:29 1994
  269. ***************
  270. *** 99,102 ****
  271. --- 99,120 ----
  272.   extern int    ddb_swrite(int, const DATUM *);
  273.   extern DATUM    *ddb_sread(int);
  274.   
  275. + #include <errno.h>
  276. + 
  277. + #ifndef EBADF
  278. + #define EBADF    1
  279. + #endif
  280. + #ifndef EDOM
  281. + #define EDOM    2
  282. + #endif
  283. + #ifndef EEXIST
  284. + #define EEXIST    3
  285. + #endif
  286. + #ifndef EINVAL
  287. + #define EINVAL    4
  288. + #endif
  289. + #ifndef ENOENT
  290. + #define ENOENT    5
  291. + #endif
  292. + 
  293.   #endif /* H_DDB */
  294. *** ../ddb.old/hash.c    Mon Mar 21 16:59:29 1994
  295. --- hash.c    Mon Jan 10 10:41:05 1994
  296. ***************
  297. *** 44,50 ****
  298.   static HASHTAB    *hashtable = NULL;
  299.   static int    maxtables = 0;
  300.   
  301. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  302.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  303.   
  304.   extern int    errno;
  305. --- 44,50 ----
  306.   static HASHTAB    *hashtable = NULL;
  307.   static int    maxtables = 0;
  308.   
  309. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t, int);
  310.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  311.   
  312.   extern int    errno;
  313. ***************
  314. *** 135,141 ****
  315.   
  316.       if (ptr && action == DDB_DUPLICATE) {
  317.           oldptr = ptr;
  318. !         if ((ptr = ddb_new(key, data, sizeof(*ptr))) == NULL)
  319.               return NULL;
  320.           ptr->next = oldptr->next;
  321.           oldptr->next = ptr;
  322. --- 135,141 ----
  323.   
  324.       if (ptr && action == DDB_DUPLICATE) {
  325.           oldptr = ptr;
  326. !         if ((ptr = ddb_new(key, data, sizeof(*ptr), 1)) == NULL)
  327.               return NULL;
  328.           ptr->next = oldptr->next;
  329.           oldptr->next = ptr;
  330. ***************
  331. *** 146,152 ****
  332.       if (oldptr)
  333.           oldptr = hashtable[hd].bucket[hashval];
  334.       if ((ptr = hashtable[hd].bucket[hashval]
  335. !       = ddb_new(key, data, sizeof(*ptr))) == NULL)
  336.           return NULL;
  337.       ptr->next = oldptr;
  338.       return &ptr->data;
  339. --- 146,152 ----
  340.       if (oldptr)
  341.           oldptr = hashtable[hd].bucket[hashval];
  342.       if ((ptr = hashtable[hd].bucket[hashval]
  343. !       = ddb_new(key, data, sizeof(*ptr), 1)) == NULL)
  344.           return NULL;
  345.       ptr->next = oldptr;
  346.       return &ptr->data;
  347. *** ../ddb.old/list.c    Mon Mar 21 16:59:33 1994
  348. --- list.c    Mon Jan 10 10:44:48 1994
  349. ***************
  350. *** 22,28 ****
  351.   #include <errno.h>
  352.   #include "ddb.h"
  353.   
  354. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  355.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  356.   
  357.   typedef struct lent {
  358. --- 22,28 ----
  359.   #include <errno.h>
  360.   #include "ddb.h"
  361.   
  362. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t, int);
  363.   extern int    ddb_memcmp(const DATUM *, const DATUM *);
  364.   
  365.   typedef struct lent {
  366. ***************
  367. *** 95,101 ****
  368.       LELEM    *le_new;
  369.   
  370.       if (!validld(ld) || !validmode(mode)
  371. !       || (le_new = ddb_new(key, data, sizeof(*le_new))) == NULL)
  372.           return -1;
  373.   
  374.       if (cmp == NULL)
  375. --- 95,101 ----
  376.       LELEM    *le_new;
  377.   
  378.       if (!validld(ld) || !validmode(mode)
  379. !       || (le_new = ddb_new(key, data, sizeof(*le_new), 1)) == NULL)
  380.           return -1;
  381.   
  382.       if (cmp == NULL)
  383. *** ../ddb.old/new.c    Mon Mar 21 16:59:33 1994
  384. --- new.c    Mon Jan 10 10:40:03 1994
  385. ***************
  386. *** 22,28 ****
  387.   #include "ddb.h"
  388.   
  389.   void *
  390. ! ddb_new(const DATUM *key, const DATUM *data, size_t size)
  391.   {
  392.       DATUM    (*ptr)[2];
  393.   
  394. --- 22,28 ----
  395.   #include "ddb.h"
  396.   
  397.   void *
  398. ! ddb_new(const DATUM *key, const DATUM *data, size_t size, int do_data)
  399.   {
  400.       DATUM    (*ptr)[2];
  401.   
  402. ***************
  403. *** 42,51 ****
  404.   
  405.       (void)memcpy((*ptr)[0].addr, key->addr, key->size);
  406.       (*ptr)[0].size = key->size;
  407. !     if (data) {
  408. !         (void)memcpy((*ptr)[1].addr, data->addr, data->size);
  409. !         (*ptr)[1].size = data->size;
  410. !     }
  411.   
  412.       return ptr;
  413.   }
  414. --- 42,56 ----
  415.   
  416.       (void)memcpy((*ptr)[0].addr, key->addr, key->size);
  417.       (*ptr)[0].size = key->size;
  418. ! 
  419. !     if (do_data)
  420. !         if (data) {
  421. !             (void)memcpy((*ptr)[1].addr, data->addr, data->size);
  422. !             (*ptr)[1].size = data->size;
  423. !         } else {
  424. !             (*ptr)[1].addr = NULL;
  425. !             (*ptr)[1].size = 0;
  426. !         }
  427.   
  428.       return ptr;
  429.   }
  430. *** ../ddb.old/patchlevel.h    Mon Mar 21 16:59:30 1994
  431. --- patchlevel.h    Mon Jan 17 16:06:48 1994
  432. ***************
  433. *** 1 ****
  434. ! #define PATCHLEVEL    1
  435. --- 1 ----
  436. ! #define PATCHLEVEL    3
  437. *** ../ddb.old/queue.c    Mon Mar 21 16:59:30 1994
  438. --- queue.c    Mon Jan 10 10:41:44 1994
  439. ***************
  440. *** 34,40 ****
  441.   static QUEUE    *queue = NULL;
  442.   static int    maxqueues = 0;
  443.   
  444. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  445.   
  446.   extern int    errno;
  447.   
  448. --- 34,40 ----
  449.   static QUEUE    *queue = NULL;
  450.   static int    maxqueues = 0;
  451.   
  452. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t, int);
  453.   
  454.   extern int    errno;
  455.   
  456. ***************
  457. *** 54,60 ****
  458.       QUEUE    *qp;
  459.       QELEM    *qe;
  460.   
  461. !     if (!validqd(qd) || (qe = ddb_new(data, NULL, sizeof(*qe))) == NULL)
  462.           return -1;
  463.   
  464.       qe->next = NULL;
  465. --- 54,60 ----
  466.       QUEUE    *qp;
  467.       QELEM    *qe;
  468.   
  469. !     if (!validqd(qd) || (qe = ddb_new(data, NULL, sizeof(*qe), 0)) == NULL)
  470.           return -1;
  471.   
  472.       qe->next = NULL;
  473. *** ../ddb.old/stack.c    Mon Mar 21 16:59:30 1994
  474. --- stack.c    Mon Jan 10 10:41:56 1994
  475. ***************
  476. *** 30,36 ****
  477.   static STACK    *stack = NULL;
  478.   static int    maxstacks = 0;
  479.   
  480. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t);
  481.   
  482.   extern int    errno;
  483.   
  484. --- 30,36 ----
  485.   static STACK    *stack = NULL;
  486.   static int    maxstacks = 0;
  487.   
  488. ! extern void    *ddb_new(const DATUM *, const DATUM *, size_t, int);
  489.   
  490.   extern int    errno;
  491.   
  492. ***************
  493. *** 52,58 ****
  494.       DATUM    *dp;
  495.   
  496.       sp = &stack[sd];
  497. !     if (!validsd(sd) || (dp = ddb_new(data, NULL, sizeof(*dp))) == NULL
  498.         || (stmp = realloc(sp->stack, (sp->top + 2) * sizeof(*sp->stack)))
  499.         == NULL)
  500.           return -1;
  501. --- 52,58 ----
  502.       DATUM    *dp;
  503.   
  504.       sp = &stack[sd];
  505. !     if (!validsd(sd) || (dp = ddb_new(data, NULL, sizeof(*dp), 0)) == NULL
  506.         || (stmp = realloc(sp->stack, (sp->top + 2) * sizeof(*sp->stack)))
  507.         == NULL)
  508.           return -1;
  509.