Return to pad.c CVS log

Up to [Research Unix] / researchv10no / cmd / p

Annotation of researchv10no/cmd/p/pad.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include "pad.h"
        !             3: 
        !             4: char *malloc();
        !             5: 
        !             6: #define        NPCBL   8       /* Number of entries in the circular list */
        !             7: 
        !             8: PAD *
        !             9: Pfopen(f, m)
        !            10: char *f, *m;
        !            11: {
        !            12:        int fd;
        !            13:        PAD *p;
        !            14: 
        !            15:        if (*m != 'r')  /* hack */
        !            16:                return (NULL);
        !            17:        if ((fd = open(f, 0)) < 0)
        !            18:                return (NULL);
        !            19:        if ((p = Pfdopen(fd)) == NULL)
        !            20:                close(fd);
        !            21:        return (p);
        !            22: }
        !            23: 
        !            24: PAD *
        !            25: Pfdopen(fd)
        !            26: int fd;
        !            27: {
        !            28:        register PAD *p;
        !            29:        register i;
        !            30: 
        !            31:        if ((p = (PAD *)malloc(sizeof(PAD))) == NULL)
        !            32:                return (NULL);
        !            33:        p->Pfile = fd;
        !            34:        p->Pcbl=(_PCBL *)malloc(NPCBL*sizeof(_PCBL));
        !            35:        if(p->Pcbl==NULL){
        !            36:                free((char *)p);
        !            37:                return (NULL);
        !            38:        }
        !            39:        p->Pcbb = p->Pcbl;
        !            40:        for(i=0; i<NPCBL; i++){
        !            41:                p->Pcbl[i].Pnextp = &p->Pcbl[(i+1)%NPCBL];
        !            42:                p->Pcbl[(i+1)%NPCBL].Pprevp = &p->Pcbl[i];
        !            43:                p->Pcbl[i].Pbase = NULL;
        !            44:                p->Pcbl[i].Phiwat = NULL;
        !            45:                p->Pcbl[i].Pptr = NULL;
        !            46:                p->Pcbl[i].Pcnt = 0;
        !            47:        }
        !            48:        return (p);
        !            49: }
        !            50: 
        !            51: int
        !            52: _Pfilbuf(p)
        !            53: register PAD *p;
        !            54: {
        !            55:        register _PCBL *pcbl;
        !            56: 
        !            57:        pcbl = p->Pcbl;
        !            58:        if (pcbl->Phiwat >= pcbl->Pbase + BUFSIZ) {
        !            59:                p->Pcbl = pcbl = pcbl->Pnextp;
        !            60:                if (pcbl->Pcnt <= 0)            /* stale data */
        !            61:                        pcbl->Phiwat = pcbl->Pbase;
        !            62:        }
        !            63:        if (pcbl->Pbase == NULL) {
        !            64:                if ((pcbl->Pbase = (char *) malloc(BUFSIZ)) == NULL) {
        !            65:                        fprintf(stderr, "pad: can't malloc\n"); /* ? */
        !            66:                        return (EOF);
        !            67:                }
        !            68:                pcbl->Phiwat = pcbl->Pbase;
        !            69:        }
        !            70:        if (pcbl->Pcnt <= 0) {
        !            71:                pcbl->Pptr = pcbl->Phiwat;
        !            72:                pcbl->Pcnt = read(p->Pfile, pcbl->Pptr, (pcbl->Pbase + BUFSIZ) - pcbl->Phiwat);
        !            73:                if (pcbl->Pcnt > 0)
        !            74:                        pcbl->Phiwat += pcbl->Pcnt;
        !            75:        }
        !            76:        if (--pcbl->Pcnt < 0) {
        !            77:                pcbl->Pcnt = 0;
        !            78:                return (EOF);
        !            79:        }
        !            80:        return (*pcbl->Pptr++);
        !            81: }
        !            82: 
        !            83: Pclose(p)
        !            84:        register PAD *p;
        !            85: {
        !            86:        register i;
        !            87: 
        !            88:        for(i=0; i<NPCBL; i++)
        !            89:                if (p->Pcbb[i].Pbase)
        !            90:                        free(p->Pcbb[i].Pbase);
        !            91:        free((char *)p->Pcbb);
        !            92:        close(p->Pfile);
        !            93:        free((char *)p);
        !            94: }
        !            95: 
        !            96: int
        !            97: Pbackc(p)
        !            98:        register PAD *p;
        !            99: {
        !           100:        register _PCBL *pcbl;
        !           101: 
        !           102:        pcbl=p->Pcbl;
        !           103:        if(pcbl->Pptr <= pcbl->Pbase){
        !           104:                pcbl=pcbl->Pprevp;              /* Only local... */
        !           105:                if(pcbl->Pptr <= pcbl->Pbase)
        !           106:                        return(EOF);
        !           107:                p->Pcbl=pcbl;                   /* ...until now */
        !           108:                pcbl->Pcnt = 0;
        !           109:        }
        !           110:        ++pcbl->Pcnt;
        !           111:        return(*--pcbl->Pptr);
        !           112: }

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