Return to tr.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/tr.c, revision 1.1.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.