Return to pad.c CVS log

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

Annotation of researchv9/cmd/p/pad.c, revision 1.1.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.