Return to pad.c CVS log

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

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

1.1     ! root        1: #include <stdio.h>
        !             2: #include "pad.h"
        !             3: #define        NPCBL   8       /* Number of entries in the circular list */
        !             4: 
        !             5: PAD *
        !             6: Pfopen(f)
        !             7:        FILE *f;
        !             8: {
        !             9:        register PAD *p=NULL;
        !            10:        register i;
        !            11:        if(f!=NULL && (p=(PAD *)malloc(sizeof (PAD)))!=NULL){
        !            12:                p->Pcbl=(_PCBL *)malloc(NPCBL*sizeof(_PCBL));
        !            13:                if(p->Pcbl==NULL){
        !            14:                        free(p);
        !            15:                        return(NULL);
        !            16:                }
        !            17:                for(i=0; i<NPCBL; i++){
        !            18:                        p->Pcbl[i].Pnextp= &p->Pcbl[(i+1)%NPCBL];
        !            19:                        p->Pcbl[(i+1)%NPCBL].Pprevp= &p->Pcbl[i];
        !            20:                        p->Pcbl[i].Pbase=NULL;
        !            21:                        p->Pcbl[i].Phiwat=NULL;
        !            22:                }
        !            23:                p->Pfile=f;
        !            24:                f->_cnt=0;      /* To be safe */
        !            25:                f->_flag|=_IOREAD;
        !            26:        }
        !            27:        return(p);
        !            28: }
        !            29: 
        !            30: int
        !            31: _Pfilbuf(p)
        !            32: register PAD *p;
        !            33: {
        !            34:        register _PCBL *pcbl;
        !            35:        register FILE *f;
        !            36: 
        !            37:        pcbl = p->Pcbl;
        !            38:        f = p->Pfile;
        !            39:        if ((f->_flag & _IOREAD) == 0 || f->_flag & _IOSTRG)
        !            40:                return (EOF);
        !            41: 
        !            42:        /*
        !            43:         * if this buffer is full, use next one
        !            44:         */
        !            45:        if (pcbl->Phiwat >= pcbl->Pbase + BUFSIZ) {
        !            46:                p->Pcbl = pcbl = pcbl->Pnextp;
        !            47:                f->_base = f->_ptr = pcbl->Pbase;
        !            48:                f->_cnt = pcbl->Phiwat - pcbl->Pbase;
        !            49:                }
        !            50: 
        !            51:        if (pcbl->Pbase == NULL) {
        !            52:                if ((pcbl->Pbase = (char *) malloc(BUFSIZ)) == NULL) {
        !            53:                        fprintf(stderr,"pad: can't malloc\n");  /* ? */
        !            54:                        f->_flag |= _IOERR;
        !            55:                        return (EOF);
        !            56:                        }
        !            57:                pcbl->Phiwat = f->_base = pcbl->Pbase;
        !            58:                f->_flag |= _IOMYBUF;
        !            59:                }
        !            60: 
        !            61:        /*
        !            62:         * if no more saved characters in this buffer,
        !            63:         * read some new ones
        !            64:         */
        !            65:        if (f->_cnt <= 0) {
        !            66:                f->_ptr = pcbl->Phiwat;
        !            67:                f->_cnt = read(fileno(f),f->_ptr,(pcbl->Pbase + BUFSIZ) - f->_ptr);
        !            68:                if (f->_cnt > 0) {
        !            69:                        pcbl->Phiwat += f->_cnt;
        !            70:                        pcbl->Pnextp->Phiwat = pcbl->Pnextp->Pbase;
        !            71:                        }
        !            72:                }
        !            73: 
        !            74:        if (--f->_cnt < 0) {
        !            75:                f->_flag |= (f->_cnt == -1 ? _IOEOF : _IOERR);
        !            76:                f->_cnt = 0;
        !            77:                return (EOF);
        !            78:                }
        !            79:        return (*f->_ptr++);
        !            80: }
        !            81: 
        !            82: Pclose(p)
        !            83:        register PAD *p;
        !            84: {
        !            85:        register i;
        !            86:        register _PCBL *pcbl=p->Pcbl;
        !            87:        register _PCBL *old;
        !            88:        for(i=0; i<NPCBL; i++){
        !            89:                if(pcbl->Pbase)
        !            90:                        free(pcbl->Pbase);
        !            91:                old=pcbl;
        !            92:                pcbl=pcbl->Pnextp;
        !            93:                free(old);
        !            94:        }
        !            95:        fclose(p->Pfile);
        !            96:        free(p);
        !            97: }
        !            98: 
        !            99: int
        !           100: Pbackc(p)
        !           101:        register PAD *p;
        !           102: {
        !           103:        register _PCBL *pcbl;
        !           104:        register FILE *f;
        !           105:        f=p->Pfile;
        !           106:        pcbl=p->Pcbl;
        !           107:        ++f->_cnt;
        !           108:        if(--f->_ptr < pcbl->Pbase){
        !           109:                pcbl=pcbl->Pprevp;              /* Only local... */
        !           110:                if(pcbl->Phiwat <= pcbl->Pbase){
        !           111:                        --f->_cnt;
        !           112:                        ++f->_ptr;
        !           113:                        return(EOF);
        !           114:                }
        !           115:                p->Pcbl=pcbl;                   /* ...until now */
        !           116:                f->_ptr=pcbl->Phiwat-1;
        !           117:                f->_cnt=1;
        !           118:        }
        !           119:        return(*f->_ptr);
        !           120: }
        !           121: 

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