Return to bdelete.c CVS log

Up to [Research Unix] / researchv10no / cmd / btree / gbt

Annotation of researchv10no/cmd/btree/gbt/bdelete.c, revision 1.1

1.1     ! root        1: #include "cbt.h"
        !             2: #include "pr.h"
        !             3: 
        !             4: extern bfile *curbf;
        !             5: bdelete(bf, key) bfile *bf; mbuf key;
        !             6: {      dkey *dold, *dnew;
        !             7:        hdr *b;
        !             8:        int svlen, dellen;
        !             9:        char *ffree;
        !            10: 
        !            11:        if(bf == NULL)
        !            12:                return(EOF);
        !            13:        if(notran(bf))
        !            14:                return(EOF);
        !            15:        if(!bf->rdwrt) {
        !            16:                errno = BNOWRITE;
        !            17:                return(EOF);
        !            18:        }
        !            19:        if(bseek(bf, key) != FOUND)
        !            20:                return(NOTFOUND);
        !            21:        b = bf->path[0];
        !            22:        dold = bf->rdptr.rptr;
        !            23:        if(bf->rdptr.rnum + 1 >= b->kcnt) {
        !            24:                nfree(b) += dold->dlen + (treeonly(bf)? 0: sizeof(lfaddr));
        !            25:                --b->kcnt;
        !            26:                mustwrite(bf, 0) = 1;
        !            27:                if(b->hlev == 0 && b->kcnt <= 0 || b->hlev > 0 && b->kcnt < 0) {
        !            28:                        mustwrite(bf, 0) = 0;
        !            29:                        ndelete(1, key);
        !            30:                }
        !            31:                if(b->kcnt < 0)
        !            32:                        b->kcnt = 0;
        !            33:                (void) bseek(bf, key);
        !            34:                return(FOUND);
        !            35:        }
        !            36: 
        !            37:        if(treeonly(bf))
        !            38:                ffree = (char *)&nfree(b) - nfree(b);
        !            39:        else
        !            40:                ffree = (char *)lfadr(b, b->kcnt - 1) - nfree(b);
        !            41:        svlen = dold->dlen;
        !            42:        dnew = (dkey *)((char *)dold + dold->dlen);
        !            43:        if(dnew->dcom <= dold->dcom) {
        !            44:                mvgbt((char *)dold, (char *)dnew, ffree - (char *)dnew);
        !            45:                if(!treeonly(bf))
        !            46:                        rmlfadr(b, bf->rdptr.rnum);
        !            47:                b->kcnt--;
        !            48:                mustwrite(bf, 0) = 1;
        !            49:                nfree(b) += svlen + (treeonly(bf)? 0: sizeof(lfaddr));
        !            50:                (void) bseek(bf, key);
        !            51:                return(FOUND);
        !            52:        }
        !            53:        dellen = dnew->dcom - dold->dcom;
        !            54:        /* writing over dold */
        !            55:        dold->dlen = dnew->dlen + dellen;
        !            56:        mvgbt(dold->dkey + dellen, dnew->dkey, ffree - dnew->dkey);
        !            57:        if(!treeonly(bf))
        !            58:                rmlfadr(b, bf->rdptr.rnum);
        !            59:        b->kcnt--;
        !            60:        mustwrite(bf, 0) = 1;
        !            61:        nfree(b) += svlen - dellen + (treeonly(bf)? 0: sizeof(lfaddr));
        !            62:        (void) bseek(bf, key);
        !            63:        return(FOUND);
        !            64: }
        !            65: rmlfadr(b, n) hdr *b; unsigned int n;
        !            66: {
        !            67:        mvgbt((char *)lfadr(b, b->kcnt - 2), (char *)lfadr(b, b->kcnt - 1),
        !            68:                (int)sizeof(lfaddr) * (b->kcnt - 1 - n));
        !            69: }
        !            70: rmndadr(b, n) hdr *b; unsigned short n;
        !            71: {
        !            72:        mvgbt((char *)ndadr(b, b->kcnt - 1), (char *)ndadr(b, b->kcnt),
        !            73:                (int)sizeof(ndaddr) * (b->kcnt - n));
        !            74: }
        !            75: ndelete(lev, key) mbuf key;
        !            76: {      hdr *b;
        !            77:        int svlen, dellen;
        !            78:        unsigned short n;
        !            79:        private x;
        !            80:        char *ffree;
        !            81:        dkey *dold, *dnew;
        !            82:        if(lev > curbf->height) {
        !            83:                b = curbf->path[curbf->height];
        !            84:                b->hlev = 0;
        !            85:                curbf->height = 0;
        !            86:                mustwrite(curbf, 0) = 1;
        !            87:                curbf->loc[0] = 0;
        !            88:                nfree(b) = NDSZ - sizeof(hdr) - sizeof(trailer);
        !            89:                b->kcnt = 0;
        !            90:                mvgbt((char *)curbf->path[0], (char *)b, NDSZ);
        !            91:                return;
        !            92:        }
        !            93:        b = curbf->path[lev];
        !            94:        n = xscan(b, key, &x);
        !            95:        if(x.match == EOF) {
        !            96:                if(b->kcnt <= 0) {
        !            97:                        mustwrite(curbf, lev) = 0;
        !            98:                        ndelete(lev+1, key);
        !            99:                        return;
        !           100:                }
        !           101:                b->kcnt--;
        !           102:                nfree(b) += sizeof(ndaddr) + x.d->dlen;
        !           103:                mustwrite(curbf, lev) = 1;
        !           104:                return;
        !           105:        }
        !           106:        dold = x.d;
        !           107:        dnew = (dkey *)((char *)dold + dold->dlen);
        !           108:        ffree = (char *)ndadr(b, b->kcnt) - nfree(b);
        !           109:        svlen = dold->dlen;
        !           110:        if(n + 1 >= b->kcnt || dnew->dcom <= dold->dcom) {
        !           111:                mvgbt((char *)dold, (char *)dnew, ffree - (char *)dnew);
        !           112:                rmndadr(b, n);
        !           113:                b->kcnt--;
        !           114:                mustwrite(curbf, lev) = 1;
        !           115:                nfree(b) += sizeof(ndaddr) + svlen;
        !           116:                return;
        !           117:        }
        !           118:        dellen = dnew->dcom - dold->dcom;
        !           119:        /* writing over dold */
        !           120:        dold->dlen = dnew->dlen + dellen;
        !           121:        mvgbt(dold->dkey + dellen, dnew->dkey, ffree - dnew->dkey);
        !           122:        rmndadr(b, n);
        !           123:        b->kcnt--;
        !           124:        mustwrite(curbf, lev) = 1;
        !           125:        nfree(b) += sizeof(ndaddr) + svlen - dellen;
        !           126: }
        !           127: static struct D { struct D *a; char *b;} VER = {&VER,"\n82/10/9:bdelete.c\n"};
        !           128: /*1101110100011001*/

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.