Return to vis.c CVS log

Up to [Research Unix] / researchv8dc / cmd

Annotation of researchv8dc/cmd/vis.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #define        STDIN   (char *)0
                      3: int    col=0;
                      4: int    lastc=0;
                      5: int    nprintfiles=0;
                      6: int    sflag=0;
                      7: int    tflag=0;
                      8: main(argc, argv)
                      9:        char *argv[];
                     10: {
                     11:        while(argc > 1) {
                     12:                --argc; argv++;
                     13:                if(argv[0][0] == '-'){
                     14:                        switch(argv[0][1]){
                     15:                        case 's':
                     16:                                sflag++;
                     17:                                break;
                     18:                        case 't':
                     19:                                tflag++;
                     20:                                break;
                     21:                        }
                     22:                }else{
                     23:                        printfile(argv[0]);
                     24:                        nprintfiles++;
                     25:                }
                     26:        }
                     27:        if(nprintfiles == 0)
                     28:                printfile(STDIN);
                     29: }
                     30: printfile(s)
                     31:        register char *s;
                     32: {
                     33:        register c;
                     34:        register FILE *f=s? fopen(s, "r"): stdin;
                     35:        if(f == NULL){
                     36:                perror(s);
                     37:                fprintf(stderr, "vis: can't open %s\n", s);
                     38:                return;
                     39:        }
                     40:        while((c=getc(f)) != EOF)
                     41:                if(sflag)
                     42:                        sput(c);
                     43:                else
                     44:                        put(c);
                     45:        fclose(f);
                     46: }
                     47: sput(c)
                     48:        register c;
                     49: {
                     50:        if((c>=' ' && c<='~') || c=='\t' || c=='\n')
                     51:                putchar(c);
                     52: }
                     53: put(c)
                     54:        register c;
                     55: {
                     56:        register inc=c;
                     57:        if (c=='\n') {
                     58:                if(lastc == ' ') {
                     59:                        putchar('\\');
                     60:                        putchar('n');
                     61:                }
                     62:        } else {
                     63:                if (col >= (72-4-2)) {
                     64:                        putchar('\\');
                     65:                        putchar('\n');
                     66:                        putchar('\t');
                     67:                        col = 8;
                     68:                }
                     69:                if(tflag && c=='\t')
                     70:                        col |= 7;
                     71:                else if (c=='\b' || c=='\\' || c=='\t') {
                     72:                        putchar('\\');
                     73:                        c = c=='\b'? 'b' : c=='\t'? 't' : '\\';
                     74:                        col++;
                     75:                } else if ((c&0200) || c<' ' || c=='\177') {
                     76:                        putchar('\\');
                     77:                        putchar(((c>>6)&03)+'0');
                     78:                        putchar(((c>>3)&07)+'0');
                     79:                        c     = ( c    &07)+'0';
                     80:                        col += 3;
                     81:                }
                     82:                col++;
                     83:        }
                     84:        putchar(c);
                     85:        if(c == '\n')
                     86:                col=0;
                     87:        lastc=inc;
                     88: }

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