Return to iul.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd

Annotation of 3BSD/cmd/iul.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: 
                      3: #define BACKSPACE 0
                      4: #define        QUOTE   0200
                      5: /*
                      6:  * iul - a cat like program to indicate underlining for graphic terminals
                      7:  *
                      8:  * Bill Joy UCB June 22, 1977
                      9:  *
                     10:  * This program was a piece of the editor ex.
                     11:  */
                     12: 
                     13: #define        LBSIZE  512
                     14: 
                     15: char   linebuf[LBSIZE], genbuf[LBSIZE];
                     16: char   *strcpy();
                     17: 
                     18: main(argc, argv)
                     19:        int argc;
                     20:        char *argv[];
                     21: {
                     22:        register c;
                     23:        register char *lp;
                     24:        char obuf[BUFSIZ];
                     25: 
                     26:        setbuf(stdout, obuf);
                     27:        argc--;
                     28:        argv++;
                     29:        do {
                     30:                if (argc > 0) {
                     31:                        if (freopen(argv[0], "r", stdin) == NULL) {
                     32:                                perror(argv[0]);
                     33:                                exit(1);
                     34:                        }
                     35:                        argc--; argv++;
                     36:                }
                     37:                while (fgets(linebuf, sizeof linebuf, stdin) != 0) {
                     38:                        for (lp = linebuf; *lp; lp++)
                     39:                                continue;
                     40:                        *--lp = 0;
                     41:                        doulg();
                     42:                        dographic();
                     43:                        if (genbuf[0])
                     44:                                printf("\n%s", genbuf);
                     45:                        putchar('\n');
                     46:                        fflush(stdout);
                     47:                }
                     48:        } while (argc > 0);
                     49:        exit(0);
                     50: }
                     51: 
                     52: dographic()
                     53: {
                     54:        register char *lp;
                     55:        register c;
                     56: 
                     57:        for (lp = linebuf; c = *lp++;) {
                     58:                switch (c) {
                     59:                        case '\b':
                     60:                                if (BACKSPACE == 0)
                     61:                                        c = '?';
                     62:                                break;
                     63:                        default:
                     64:                                if (c < ' ' || c == 0177)
                     65:                                        c = '?';
                     66:                                break;
                     67:                        case '\t':
                     68:                                break;
                     69:                }
                     70:                putchar(c);
                     71:        }
                     72: }
                     73: 
                     74: doulg()
                     75: {
                     76:        register char *lp, *gp;
                     77:        char *maxgp;
                     78:        register c;
                     79:        char csw;
                     80:        int col;
                     81: 
                     82:        gp = genbuf;
                     83:        *gp = 0;
                     84:        maxgp = gp;
                     85:        col = 0;
                     86:        for (lp = linebuf; c = *lp++;) {
                     87:                switch (c) {
                     88:                        case '\t':
                     89:                                while ((col & 7) != 7) {
                     90:                                        *gp++ = ' ';
                     91:                                        if (gp >= &genbuf[LBSIZE - 2])
                     92:                                                goto ovflo;
                     93:                                        col++;
                     94:                                }
                     95:                                break;
                     96:                        default:
                     97:                                if (gp >= maxgp)
                     98:                                        break;
                     99:                                c =| (*gp & QUOTE);
                    100:                                break;
                    101:                        case '_':
                    102:                                if (gp >= maxgp)
                    103:                                        c = QUOTE;
                    104:                                else
                    105:                                        c = *gp | QUOTE;
                    106:                                break;
                    107:                        case '\b':
                    108:                                if (gp > genbuf) {
                    109:                                        gp--;
                    110:                                        col--;
                    111:                                }
                    112:                                continue;
                    113:                }
                    114:                if (gp >= &genbuf[LBSIZE - 2]) {
                    115: ovflo:
                    116:                        fprintf(stderr, "Line too long\n");
                    117:                        exit(1);
                    118:                }
                    119:                *gp++ = c;
                    120:                if (gp > maxgp)
                    121:                        maxgp = gp;
                    122:                col++;
                    123:        }
                    124:        *maxgp = 0;
                    125:        strcpy(linebuf, genbuf);
                    126:        for (lp = linebuf, gp = genbuf; c = *lp; gp++, lp++)
                    127:                if (c & QUOTE) {
                    128:                        c =& 0177;
                    129:                        if (c == 0)
                    130:                                *lp = '_', *gp = ' ';
                    131:                        else
                    132:                                *lp = c, *gp = '-';
                    133:                } else
                    134:                        *gp = ' ';
                    135:        --gp;
                    136:        while (gp >= genbuf && *gp == ' ')
                    137:                --gp;
                    138:        gp[1] = 0;
                    139: }

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