Return to bttest.c CVS log

Up to [Research Unix] / researchv10no / libcbt

Annotation of researchv10no/libcbt/bttest.c, revision 1.1

1.1     ! root        1: #include "stdio.h"
        !             2: #include "cbt.h"
        !             3: extern char *malloc();
        !             4: extern bfile *bopen();
        !             5: extern mbuf bkey();
        !             6: extern long lseek();
        !             7: 
        !             8: char *onearg();
        !             9: mbuf key, value;
        !            10: bfile *it;
        !            11: #define OPEN   1
        !            12: #define CLOSE  2
        !            13: #define SEEK   3
        !            14: #define FIRST  4
        !            15: #define NEXT   5
        !            16: #define WRITE  6
        !            17: #define BT     7
        !            18: #define LEV    8
        !            19: #define NODE   9
        !            20: #define KEY    10
        !            21: #define FLUSH  11
        !            22: #define COMMIT 12
        !            23: #define SHELL  13
        !            24: #define DELETE 14
        !            25: #define START  15
        !            26: #define CHECK  16
        !            27: struct cmd
        !            28: {      int cmt, cln;
        !            29:        char *ccm;
        !            30: } cmnd[] =
        !            31: {      {OPEN, 4, "open"},
        !            32:        {CLOSE, 5, "close"},
        !            33:        {SHELL, 1, "!"},
        !            34:        {DELETE, 6, "delete"},
        !            35:        {SEEK, 4, "seek"},
        !            36:        {FIRST, 5, "first"},
        !            37:        {NEXT, 4, "next"},
        !            38:        {NEXT, 4, "read"},
        !            39:        {WRITE, 5, "write"},
        !            40:        {CHECK, 5, "check"},
        !            41:        {BT, 2, "bt"},
        !            42:        {LEV, 3, "lev"},
        !            43:        {NODE, 4, "node"},
        !            44:        {KEY, 3, "key"},
        !            45:        {FLUSH, 5, "flush"},
        !            46:        {COMMIT, 6, "commit"},
        !            47:        {START, 5, "start"},
        !            48:        {START, 7, "trstart"},
        !            49:        {0, 0, 0}
        !            50: };
        !            51: char line[128];
        !            52: char ndbuf[512];
        !            53: main()
        !            54: {
        !            55:        int n;
        !            56:        char *s, *p;
        !            57:        key.mdata = malloc(200);
        !            58:        value.mdata = malloc(200);
        !            59:        for(;;) {
        !            60:                for(n = 0; n < sizeof(line); n++)
        !            61:                        line[n] = 0;
        !            62:                (void) fgets(line, sizeof(line), stdin);
        !            63:                if(feof(stdin)) break;
        !            64:                switch(cmtp(line)) {
        !            65:                default:
        !            66:                        printf("?\n");
        !            67:                        break;
        !            68:                case CLOSE:
        !            69:                        bclose(it);
        !            70:                        break;
        !            71:                case SHELL:
        !            72:                        (void) system(line);
        !            73:                        printf("!\n");
        !            74:                        break;
        !            75:                case START:
        !            76:        /*              printf("%d\n", trstart()); */
        !            77:                        break;
        !            78:                case COMMIT:
        !            79:        /*              btcommit(); */
        !            80:                        break;
        !            81:                case FLUSH:
        !            82:                        bflush(it);
        !            83:                        break;
        !            84:                case OPEN:
        !            85:                        s = onearg(line);
        !            86:                        it = bopen(s, 2);
        !            87:                        if(it == NULL || errno)
        !            88:                        {       perror(s);
        !            89:                        }
        !            90:                        break;
        !            91:                case DELETE:
        !            92:                        s = onearg(line);
        !            93:                        if(s[strlen(s)-1] == '\n')
        !            94:                                s[strlen(s)-1] = 0;
        !            95:                        todatum(s, &key);
        !            96:                        printf("%d\n", bdelete(it, key));
        !            97:                        break;
        !            98:                case SEEK:
        !            99:                        s = onearg(line);
        !           100:                        if(s[strlen(s)-1] == '\n')
        !           101:                                s[strlen(s)-1] = 0;
        !           102:                        todatum(s, &key);
        !           103:                        printf("%d\n", bseek(it, key));
        !           104:                        break;
        !           105:                case FIRST:
        !           106:                        printf("%d\n", bfirst(it));
        !           107:                        break;
        !           108:                case NEXT:
        !           109:                        printf("%d - ", bread(it, &key, &value));
        !           110:                        prbuf(value);
        !           111:                        printf(" | ");
        !           112:                        prbuf(key);
        !           113:                        putchar('\n');
        !           114:                        break;
        !           115:                case WRITE:
        !           116:                        twoarg(line, &s, &p);
        !           117:                        todatum(s, &key);
        !           118:                        todatum(p, &value);
        !           119:                        printf("%d\n", bwrite(it, key, value));
        !           120:                        break;
        !           121:                case BT:
        !           122:                        prbt(it);
        !           123:                        break;
        !           124:                case LEV:
        !           125:                        (void) sscanf(line, "%d", &n);
        !           126:                        if(n < 0 || n > it->height)
        !           127:                        {       printf("out of range\n");
        !           128:                                break;
        !           129:                        }
        !           130:                        tprnode(it->path[n]);
        !           131:                        break;
        !           132:                case NODE:
        !           133:                        (void) sscanf(line, "%d", &n);
        !           134:                        (void) lseek(it->tfd, (long)n*NDSZ, 0);
        !           135:                        (void) read(it->tfd, ndbuf, NDSZ);
        !           136:                        tprnode((hdr *)ndbuf);
        !           137:                        break;
        !           138:                case CHECK:
        !           139:                        (void) sscanf(line, "%d", &n);
        !           140:                        (void) lseek(it->tfd, (long)n * NDSZ, 0);
        !           141:                        (void) read(it->tfd, ndbuf, NDSZ);
        !           142:                        checknode((hdr *)ndbuf);
        !           143:                        break;
        !           144:                case KEY:
        !           145:                        printf("%d ", breclen(it));
        !           146:                        prbuf(bkey(it));
        !           147:                        putchar('\n');
        !           148:                        break;
        !           149:                }
        !           150:        }
        !           151:        exit(0);
        !           152: }
        !           153: cmtp(s) char *s;
        !           154: {      struct cmd *p;
        !           155:        int i;
        !           156:        for(p=cmnd; p->cln != 0; p++)
        !           157:                if(strncmp(s, p->ccm, p->cln) == 0)
        !           158:                {       for(i=0; i<p->cln; i++)
        !           159:                                line[i] =' ';
        !           160:                        return(p->cmt);
        !           161:                }
        !           162:        return(-1);
        !           163: }
        !           164: char *onearg(s) char *s;
        !           165: {      char *p, *q;
        !           166:        for(p=s; *p == ' '; p++);
        !           167:        for(q=p; *q && *q!='\n'; q++);
        !           168:        *q = 0;
        !           169:        return(p);
        !           170: }
        !           171: todatum(s, k) char *s; mbuf *k;
        !           172: {      int i;
        !           173:        k->mlen = strlen(s);
        !           174:        if(s[k->mlen - 1] == '\n')
        !           175:                k->mlen--;
        !           176:        for(i=0; i<k->mlen; i++)
        !           177:                k->mdata[i] = s[i];
        !           178: }
        !           179: twoarg(a, b, c) char *a, **b, **c;
        !           180: {      char *p, *q;
        !           181:        for(; *a==' '; a++);
        !           182:        for(p=a; *p && *p!='\t'; p++);
        !           183:        *p++ = 0;
        !           184:        for(q=p; *q && *q!='\n'; q++);
        !           185:        *q = 0;
        !           186:        *b = a;
        !           187:        *c = p;
        !           188: }
        !           189: prbuf(a) mbuf a;
        !           190: {      int i;
        !           191:        printf("%d:", a.mlen);
        !           192:        for(i=0; i<a.mlen; i++)
        !           193:                putchar(a.mdata[i]);
        !           194: }
        !           195: prbt(a) bfile *a;
        !           196: {      int i;
        !           197:        printf("ht %d adv %d rdw %d flags ", a->height, a->advnc,
        !           198:                a->rdwrt);
        !           199:        for(i = 0; i <= MXHT; i++)
        !           200:                printf(" %d", a->flag[i]);
        !           201:        putchar('\n');
        !           202:        printf("nodes ");
        !           203:        for(i = 0; i <= MXHT; i++)
        !           204:                printf(" %d", a->loc[i]);
        !           205:        putchar('\n');
        !           206:        printf("rdkey #%d:", a->rdptr.rnum);
        !           207:        printf(":\n");
        !           208: }
        !           209: tprnode(a) hdr *a;
        !           210: {      int i;
        !           211:        dkey *q;
        !           212:        prhdr(a);
        !           213:        q = (dkey *)(a+1);
        !           214:        for(i = 0; i < a->kcnt; i++) {
        !           215:                if(a->hlev == 0)
        !           216:                        prlfa(lfadr(a, i));
        !           217:                else prnda(ndadr(a, i));
        !           218:                prkey(q);
        !           219:                q = (dkey *)((char *)q + q->dlen);
        !           220:        }
        !           221:        if(a->hlev)
        !           222:                prnda(ndadr(a, i));
        !           223:        putchar('\n');
        !           224: }
        !           225: checknode(a)
        !           226: hdr *a;
        !           227: {      int i;
        !           228:        char *p;
        !           229:        for(i = 0, p = (char *)(a + 1); i < a->kcnt; i++)
        !           230:                p += *p;
        !           231:        i = p - (char *)a + nfree(a) + sizeof(trailer);
        !           232:        if(a->hlev)
        !           233:                i += (a->kcnt + 1) * sizeof(ndaddr);
        !           234:        else if(!treeonly(it))
        !           235:                i += a->kcnt * sizeof(lfaddr);
        !           236:        if(i == NDSZ) {
        !           237:                printf("ok\n");
        !           238:                return;
        !           239:        }
        !           240:        printf("nfree should be %d not %d\n", NDSZ - i + nfree(a),
        !           241:                nfree(a));
        !           242: }
        !           243: prhdr(a) hdr *a;
        !           244: {
        !           245:        printf("stamp %ld kcnt %d type %d lev %d free %d\n",
        !           246:                a->hstamp, a->kcnt, a->htype, a->hlev, nfree(a));
        !           247: }
        !           248: prlfa(a) lfaddr *a;
        !           249: {
        !           250:        if(treeonly(it))
        !           251:                printf("\t");
        !           252:        else
        !           253:                printf("%ld %u\t", a->lloc, a->llen);
        !           254: }
        !           255: prnda(a) ndaddr *a;
        !           256: {
        !           257:        printf("%u\t", *a);
        !           258: }
        !           259: prkey(b) dkey *b;
        !           260: {      int i;
        !           261:        for(i = 0; i < b->dcom; i++)
        !           262:                putchar(' ');
        !           263:        for(i = 0; i < b->dlen - DKEYSZ; i++)
        !           264:                putchar(b->dkey[i]);
        !           265:        putchar('\n');
        !           266: }

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