Return to bufs.c CVS log

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

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

1.1     ! root        1: #include "cbt.h"
        !             2: 
        !             3: typedef struct bhd {
        !             4:        struct bhd *next;
        !             5:        short fd;
        !             6:        long which;
        !             7:        char *where;
        !             8: } bhd;
        !             9: 
        !            10: enum {Nhash = 601, Max = 1000};
        !            11: bhd *bhds[Nhash], *bhfree;
        !            12: bhd bhpool[Max];
        !            13: int btptr;
        !            14: #define hash(a, b) ((b << 8) | a) % Nhash
        !            15: 
        !            16: btbufinit()
        !            17: {      int i;
        !            18:        char *p;
        !            19:        p = (char *) malloc(Max * NDSZ);
        !            20:        if(!p)
        !            21:                abort();
        !            22:        for(i = 1; i < Max; i++) {
        !            23:                bhpool[i-1].next = bhpool + i;
        !            24:                bhpool[i].where = p + NDSZ * i;
        !            25:        }
        !            26:        bhpool[0].where = p;
        !            27:        bhfree = bhpool + 0;
        !            28: }
        !            29: 
        !            30: btbufdone(fd)
        !            31: {      int i;
        !            32:        bhd *p, *q;
        !            33:        for(i = 0; i < Nhash; i++) {
        !            34:                p = bhds[i];
        !            35: loop:
        !            36:                if(!p)
        !            37:                        continue;
        !            38:                if(p->fd != fd) {
        !            39:                        p = p->next;
        !            40:                        goto loop;
        !            41:                }
        !            42:                lseek(p->fd, p->which*NDSZ, 0);
        !            43:                write(p->fd, p->where, NDSZ);   /* check these dammit */
        !            44:                q = p;
        !            45:                p = p->next;
        !            46:                q->next = bhfree;
        !            47:                goto loop;
        !            48:        }
        !            49: }
        !            50: 
        !            51: btbufwrt(fd, which, from)
        !            52: char *from;
        !            53: {      int n;
        !            54:        bhd *p;
        !            55:        n = hash(fd, which);
        !            56:        for(p = bhds[n]; p; p = p->next)
        !            57:                if(p->fd == fd && p->which == which) {
        !            58:                        btbcpy(p->where, from, NDSZ);
        !            59:                        return;
        !            60:                }
        !            61:        if(!bhfree)
        !            62:                btbuffree();
        !            63:        p = bhfree;
        !            64:        bhfree = p->next;
        !            65:        p->next = bhds[n];
        !            66:        bhds[n] = p;
        !            67:        p->fd = fd;
        !            68:        p->which = which;
        !            69:        btbcpy(p->where, from, NDSZ);
        !            70: }
        !            71: 
        !            72: btbuffree()
        !            73: {      bhd *p;
        !            74: loop:
        !            75:        if(btptr >= Max)
        !            76:                btptr = 0;
        !            77:        p = bhpool + btptr++;
        !            78:        if(!p->next)
        !            79:                goto loop;
        !            80:        bhfree = p->next;
        !            81:        p->next = bhfree->next;
        !            82:        bhfree->next = 0;
        !            83:        lseek(bhfree->fd, bhfree->which*NDSZ, 0);
        !            84:        write(bhfree->fd, bhfree->where, NDSZ); /* check this dammit */
        !            85: }
        !            86: 
        !            87: btbufread(fd, which, to)
        !            88: char *to;
        !            89: {      int n;
        !            90:        bhd *p;
        !            91:        static init;
        !            92:        if(!init++)
        !            93:                btbufinit();
        !            94:        n = hash(fd, which);
        !            95:        for(p = bhds[n]; p; p = p->next)
        !            96:                if(p->fd == fd && p->which == which) {
        !            97:                        btbcpy(to, p->where, NDSZ);
        !            98:                        return(0);
        !            99:                }
        !           100:        
        !           101:        if(!bhfree)
        !           102:                btbuffree();
        !           103:        p = bhfree;
        !           104:        bhfree = p->next;
        !           105:        p->next = bhds[n];
        !           106:        bhds[n] = p;
        !           107:        p->fd = fd;
        !           108:        p->which = which;
        !           109:        if(lseek(fd, which * NDSZ, 0) == -1)
        !           110:                return(EOF);
        !           111:        if(read(fd, p->where, NDSZ) != NDSZ)
        !           112:                return(EOF);
        !           113:        btbcpy(to, p->where, NDSZ);
        !           114:        return(0);
        !           115: }
        !           116: 
        !           117: btbcpy(to, from, sz)
        !           118: register int *to, *from, sz;
        !           119: {      register int cnt = sz/sizeof(int);
        !           120:        while(cnt-- > 0)
        !           121:                *to++ = *from++;
        !           122: }

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