Return to tr.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/tr.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: 
        !             3: #define N 500
        !             4: 
        !             5: unsigned char from[N];
        !             6: int nfrom;
        !             7: unsigned char to[N];
        !             8: int nto;
        !             9: unsigned char trans[256];
        !            10: unsigned char occur[256];
        !            11: 
        !            12: int cflag;
        !            13: int dflag;
        !            14: int sflag;
        !            15: 
        !            16: main(argc, argv)
        !            17: unsigned char **argv;
        !            18: {
        !            19:        int c;
        !            20:        for( ; argc>1 && argv[1][0]=='-'; argc--, argv++) {
        !            21:                while(c = *++argv[1]) {
        !            22:                        switch(c) {
        !            23:                        case 's':
        !            24:                                sflag++;
        !            25:                                continue;
        !            26:                        case 'd':
        !            27:                                dflag++;
        !            28:                                continue;
        !            29:                        case 'c':
        !            30:                                cflag++;
        !            31:                                continue;
        !            32:                        default:
        !            33:                                fprintf(stderr,"tr: bad option\n");
        !            34:                                exit(1);
        !            35:                        }
        !            36:                }
        !            37:        }
        !            38:        if(argc>1)
        !            39:                nfrom = canon(argv[1],from);
        !            40:        if(argc>2)
        !            41:                nto = canon(argv[2],to);
        !            42:        if(cflag)
        !            43:                complement();
        !            44:        if(dflag)
        !            45:                delete();
        !            46:        else
        !            47:                translit();
        !            48:        return 0;
        !            49: }
        !            50: 
        !            51: delete()
        !            52: {
        !            53:        register i, c, last;
        !            54:        for(i=0; i<nfrom; i++)
        !            55:                trans[from[i]] = 1;
        !            56:        if(sflag)
        !            57:                for(i=0; i<nto; i++)
        !            58:                        occur[to[i]] = 1;
        !            59:        last = -1;
        !            60:        while((c=getchar()) != EOF)
        !            61:                if(!trans[c] && (c!=last || !occur[c]))
        !            62:                        putchar(last = c);
        !            63: }
        !            64: 
        !            65: translit()
        !            66: {
        !            67:        register i, c;
        !            68:        if(nfrom>0 && nto==0) {
        !            69:                fprintf(stderr,"tr: arg count\n");
        !            70:                exit(1);
        !            71:        }
        !            72:        for(i=0; i<sizeof trans; i++)
        !            73:                trans[i] = i;
        !            74:        for(i=0; i<nfrom; i++)
        !            75:                trans[from[i]] = to[i<nto? i: nto-1];
        !            76:        if(sflag) 
        !            77:                squeeze();
        !            78:        else
        !            79:                while((c=getchar()) != EOF)
        !            80:                        putchar(trans[c]);
        !            81: }
        !            82: 
        !            83: squeeze()
        !            84: {
        !            85:        register i, c, last;
        !            86:        for(i=0; i<nto; i++)
        !            87:                occur[to[i]] = 1;
        !            88:        last = -1;
        !            89:        while((c=getchar()) != EOF)
        !            90:                if((c=trans[c]) != last || !occur[c])
        !            91:                        putchar(last = c);
        !            92: }
        !            93: 
        !            94: complement()
        !            95: {
        !            96:        register i;
        !            97:        for(i=0; i<nfrom; i++)
        !            98:                occur[from[i]] = 1;
        !            99:        for(i=nfrom=0; i<sizeof occur; i++)
        !           100:                if(!occur[i])
        !           101:                        from[nfrom++] = i;
        !           102:        memset((char*)occur,0,sizeof occur);
        !           103: }
        !           104: 
        !           105: getch(ps)
        !           106: unsigned char **ps;
        !           107: {
        !           108:        unsigned char *s = *ps;
        !           109:        int c = *s++;
        !           110:        int n, i;
        !           111:        if(c=='\\' && *s) {
        !           112:                n = 0;
        !           113:                for(i=0; i<3; i++)
        !           114:                        if(*s>='0' && *s<='7')
        !           115:                                n = 8*n + *s++ - '0';
        !           116:                        else
        !           117:                                break;
        !           118:                if(i == 0)
        !           119:                        c = *s;
        !           120:                else if(n <= 0377)
        !           121:                        c = n;
        !           122:                else {
        !           123:                        fprintf(stderr,"tr: char>0377\n");
        !           124:                        exit(1);
        !           125:                }
        !           126:        }
        !           127:        *ps = s;
        !           128:        return c;
        !           129: }
        !           130: 
        !           131: canon(s, t)
        !           132: unsigned char *s, *t;
        !           133: {
        !           134:        int n = 0;
        !           135:        int i, c;
        !           136:        while(*s && n<N) {
        !           137:                if(*s=='-' && n>0 && s[1]) {
        !           138:                        s++;
        !           139:                        c = getch(&s);
        !           140:                        for(i=t[n-1]; ++i<=c && n<N ; )
        !           141:                                t[n++] = i;
        !           142:                } else
        !           143:                        t[n++] = getch(&s);
        !           144:        }
        !           145:        if(n >= N) {
        !           146:                fprintf(stderr,"tr: arg string too long\n");
        !           147:                exit(1);
        !           148:        }
        !           149:        return n;
        !           150: }
        !           151: 

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