home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume8 / sp / part01 / dbm.diffs < prev    next >
Encoding:
Text File  |  1987-02-19  |  2.7 KB  |  144 lines
  1. Index: dbm.c
  2. *** dbm.orig.c    Thu Nov 27 17:45:38 1986
  3. --- dbm.c    Thu Nov 27 18:13:11 1986
  4. ***************
  5. *** 6,16 ****
  6. --- 6,21 ----
  7.   #include    <sys/types.h>
  8.   #include    <sys/stat.h>
  9.   
  10. + static long dbm_access_oldb;
  11. + static getbit_oldb;
  12. + 
  13.   dbminit(file)
  14.   char *file;
  15.   {
  16.       struct stat statb;
  17.   
  18. +     dbm_access_oldb = -1;
  19. +     getbit_oldb = -1;
  20.       dbrdonly = 0;
  21.       strcpy(pagbuf, file);
  22.       strcat(pagbuf, ".pag");
  23. ***************
  24. *** 27,36 ****
  25.           dirf = open(pagbuf, 0);
  26.           dbrdonly = 1;
  27.       }
  28. !     if(pagf < 0 || dirf < 0) {
  29. !         printf("cannot open database %s\n", file);
  30.           return(-1);
  31. -     }
  32.       fstat(dirf, &statb);
  33.       maxbno = statb.st_size*BYTESIZ-1;
  34.       return(0);
  35. --- 32,39 ----
  36.           dirf = open(pagbuf, 0);
  37.           dbrdonly = 1;
  38.       }
  39. !     if(pagf < 0 || dirf < 0)
  40.           return(-1);
  41.       fstat(dirf, &statb);
  42.       maxbno = statb.st_size*BYTESIZ-1;
  43.       return(0);
  44. ***************
  45. *** 130,136 ****
  46. --- 133,143 ----
  47.       return (0);
  48.   
  49.   split:
  50. + #ifdef BUGFIX
  51. +     if(key.dsize+dat.dsize+3*sizeof(short) >= PBLKSIZ) {
  52. + #else
  53.       if(key.dsize+dat.dsize+2*sizeof(short) >= PBLKSIZ) {
  54. + #endif
  55.           printf("entry too big\n");
  56.           return (-1);
  57.       }
  58. ***************
  59. *** 226,232 ****
  60.   dbm_access(hash)
  61.   long hash;
  62.   {
  63. !     static long oldb = -1;
  64.   
  65.       for(hmask=0;; hmask=(hmask<<1)+1) {
  66.           blkno = hash & hmask;
  67. --- 233,239 ----
  68.   dbm_access(hash)
  69.   long hash;
  70.   {
  71. ! /***    static long oldb = -1;    ***/
  72.   
  73.       for(hmask=0;; hmask=(hmask<<1)+1) {
  74.           blkno = hash & hmask;
  75. ***************
  76. *** 234,245 ****
  77.           if(getbit() == 0)
  78.               break;
  79.       }
  80. !     if(blkno != oldb) {
  81.           clrbuf(pagbuf, PBLKSIZ);
  82.           lseek(pagf, blkno*PBLKSIZ, 0);
  83.           read(pagf, pagbuf, PBLKSIZ);
  84.           chkblk(pagbuf);
  85. !         oldb = blkno;
  86.       }
  87.   }
  88.   
  89. --- 241,252 ----
  90.           if(getbit() == 0)
  91.               break;
  92.       }
  93. !     if(blkno != dbm_access_oldb) {
  94.           clrbuf(pagbuf, PBLKSIZ);
  95.           lseek(pagf, blkno*PBLKSIZ, 0);
  96.           read(pagf, pagbuf, PBLKSIZ);
  97.           chkblk(pagbuf);
  98. !         dbm_access_oldb = blkno;
  99.       }
  100.   }
  101.   
  102. ***************
  103. *** 247,253 ****
  104.   {
  105.       long bn;
  106.       register b, i, n;
  107. !     static oldb = -1;
  108.   
  109.       if(bitno > maxbno)
  110.           return(0);
  111. --- 254,260 ----
  112.   {
  113.       long bn;
  114.       register b, i, n;
  115. ! /***    static oldb = -1;  ***/
  116.   
  117.       if(bitno > maxbno)
  118.           return(0);
  119. ***************
  120. *** 255,265 ****
  121.       bn = bitno / BYTESIZ;
  122.       i = bn % DBLKSIZ;
  123.       b = bn / DBLKSIZ;
  124. !     if(b != oldb) {
  125.           clrbuf(dirbuf, DBLKSIZ);
  126.           lseek(dirf, (long)b*DBLKSIZ, 0);
  127.           read(dirf, dirbuf, DBLKSIZ);
  128. !         oldb = b;
  129.       }
  130.       if(dirbuf[i] & (1<<n))
  131.           return(1);
  132. --- 262,272 ----
  133.       bn = bitno / BYTESIZ;
  134.       i = bn % DBLKSIZ;
  135.       b = bn / DBLKSIZ;
  136. !     if(b != getbit_oldb) {
  137.           clrbuf(dirbuf, DBLKSIZ);
  138.           lseek(dirf, (long)b*DBLKSIZ, 0);
  139.           read(dirf, dirbuf, DBLKSIZ);
  140. !         getbit_oldb = b;
  141.       }
  142.       if(dirbuf[i] & (1<<n))
  143.           return(1);
  144.