Return to upost.c CVS log

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

Annotation of researchv10no/cmd/cref/upost.c, revision 1.1

1.1     ! root        1: /*int  mbuf[1024];     /*INSTR*/
        !             2: int    psw     1;
        !             3: int    initf   1;
        !             4: 
        !             5: main(argc, argv)
        !             6:        char    *argv[];
        !             7: {
        !             8:        auto    f,fct,file;
        !             9: 
        !            10:        if(argc < 2) {
        !            11:                printf("Usage: cpost [-d] file1 file2 ...\n");
        !            12:                exit();
        !            13:        }
        !            14: 
        !            15:        if(*argv[1] == '-') {
        !            16:                fct = argv[1][1] - '0';
        !            17:                if((fct < 1) || (fct > 9)) {
        !            18:                        printf("-d: 0 < d < 10\n");
        !            19:                        exit();
        !            20:                }
        !            21:                argv++;
        !            22:                argc--;
        !            23:        } else {
        !            24:                fct = 1;
        !            25:        }
        !            26: 
        !            27:        f = 0;
        !            28:        while(++f < argc) {
        !            29:                file = open(argv[f], 0);
        !            30: 
        !            31:                edl(file, fct);
        !            32: 
        !            33:                close(file);
        !            34:                psw = 0;
        !            35:        }
        !            36:        flsh(0);
        !            37: 
        !            38:        exit();
        !            39: }
        !            40: 
        !            41: int    lno     1;
        !            42: 
        !            43: edl(file)
        !            44: {
        !            45:        auto t,l;
        !            46:        char    static  buf[20],fld[20],line[200];
        !            47:        char    c;
        !            48: field:
        !            49:        t = -1;
        !            50:        while(((buf[++t] = get(file)) != '\t') && (buf[t] != -1))
        !            51:                if(buf[t] == '\0')      goto done;
        !            52: 
        !            53:        if((c = buf[t]) == -1)  c = ' ';
        !            54:        buf[t] = '\0';
        !            55:        if(comp(buf,fld)) {
        !            56:                lno++;
        !            57:                goto junk;
        !            58:        } else {
        !            59:                if(lno == 0) {
        !            60:                        put(0,line,++l);
        !            61:                }
        !            62:                l = copy(buf,line);
        !            63:                copy(buf,fld);
        !            64:                line[--l] = c;
        !            65:                lno = 0;
        !            66:                goto fill;
        !            67:        }
        !            68: 
        !            69: fill:
        !            70:        while((line[++l] = get(file)) != '\n') {
        !            71:                if(line[l] == -1)       line[l] = ' ';
        !            72:                if(line[l] == '\0')     goto done;
        !            73:        }
        !            74: 
        !            75:        goto field;
        !            76: 
        !            77: junk:
        !            78:        while((*line = get(file)) != '\n')
        !            79:                if(*line == '\0')       goto done;
        !            80: 
        !            81:        goto field;
        !            82: 
        !            83: done:
        !            84:        if(lno == 0)
        !            85:                put(0,line,++l);
        !            86:                lno = 1;
        !            87:        return(0);
        !            88: 
        !            89: }
        !            90: 
        !            91: 
        !            92: 
        !            93: gfld(file, buf)
        !            94:        char    *buf;
        !            95: {
        !            96:        char    c;
        !            97: 
        !            98:        buf--;
        !            99:        while(*++buf  = get(file)) {
        !           100:                if((*buf == '\t') || (*buf == '\n')) {
        !           101:                        c = *buf;
        !           102:                        *buf = '\0';
        !           103:                        return(c);
        !           104:                } else {
        !           105:                        continue;
        !           106:                }
        !           107:        }
        !           108:        return('\0');
        !           109: }
        !           110: 
        !           111: copy(a, b)
        !           112:        char    *a,*b;
        !           113: {
        !           114:        char    *c;
        !           115: 
        !           116:        b--;
        !           117:        c = --a;
        !           118:        while(*++b = *++a);
        !           119:        return(a - c);
        !           120: }
        !           121: 
        !           122: comp(a, b)
        !           123:        char    *a, *b;
        !           124: {
        !           125: /*     printf("comp: %s %s\n",a,b); /*DEBUG*/
        !           126:        a--;
        !           127:        b--;
        !           128:        while(*++a == *++b) {
        !           129:                if(*a == '\0')  return(1);
        !           130:        }
        !           131:        return(0);
        !           132: }
        !           133: 
        !           134: 
        !           135: char   buf[512];
        !           136: int    nread   1;
        !           137: 
        !           138: get(ifile) int ifile;
        !           139: {
        !           140: 
        !           141:        char static *ibuf;
        !           142: 
        !           143:        if(--nread){
        !           144:                return(*ibuf++);
        !           145:        }
        !           146: 
        !           147:        if(nread = read(ifile,buf,512)){
        !           148:                if(nread < 0)goto err;
        !           149: 
        !           150:                ibuf = buf;
        !           151:                return(*ibuf++);
        !           152:        }
        !           153: 
        !           154:        nread = 1;
        !           155:        return(0);
        !           156: 
        !           157: err:
        !           158:        nread = 1;
        !           159:        printf("read error\n");
        !           160:        return(0);
        !           161: 
        !           162: }
        !           163: 
        !           164: 
        !           165: int    tp[1]   1;
        !           166: int    optr[4];
        !           167: char   bsp[512];
        !           168: 
        !           169: char   *obuf[1]        bsp;
        !           170: 
        !           171: int    nflush;
        !           172: 
        !           173: put(fil,string,n)
        !           174:        char    *string;
        !           175: {
        !           176:        int     i;
        !           177:        char    *o;
        !           178: 
        !           179: /*printf("%d %c %d\n",fil,*string,n);/*DEBUG*/
        !           180: 
        !           181:        string--;
        !           182: 
        !           183:        if((i = optr[fil] + n - 512) >= 0) {
        !           184:                n =- i;
        !           185:                o = &obuf[fil][optr[fil]] -1;
        !           186:                while(--n >= 0)
        !           187:                        *++o = *++string;
        !           188:                optr[fil] = 512;
        !           189:                flsh(fil);
        !           190:                n = i;
        !           191:        }
        !           192: 
        !           193:        o = &obuf[fil][optr[fil]] - 1;
        !           194:        optr[fil] =+ n;
        !           195: 
        !           196:        while(--n >= 0) {
        !           197:                *++o = *++string;
        !           198:        }
        !           199:        return(0);
        !           200: }
        !           201: 
        !           202: flsh(fil)
        !           203: {
        !           204:        extern  tp[];
        !           205: 
        !           206:        if(optr[fil] <= 0)      return(optr[fil]);
        !           207: 
        !           208:        nflush++;
        !           209:        if(write(tp[fil],obuf[fil],optr[fil]) != optr[fil])
        !           210:                return(-1);
        !           211:        optr[fil] = 0;
        !           212:        return(0);
        !           213: }
        !           214: 

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