Return to ul.c CVS log

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

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

1.1     ! root        1: static char *sccsid = "@(#)ul.c        4.1 (Berkeley) 10/1/80";
        !             2: /*
        !             3:  * ul
        !             4:  */
        !             5: #include <stdio.h>
        !             6: 
        !             7: char   buf[BUFSIZ];
        !             8: char   isul[BUFSIZ];
        !             9: char   termcap[1024];
        !            10: char   ulbuf[BUFSIZ];
        !            11: char   *stul, *endul, *chul;
        !            12: char   *backspace;
        !            13: char   *termtype;
        !            14: int    outc();
        !            15: char   *tgetstr();
        !            16: char   *getenv();
        !            17: 
        !            18: main(argc, argv)
        !            19:        int argc;
        !            20:        char **argv;
        !            21: {
        !            22:        register int i;
        !            23:        char *cp;
        !            24:        FILE *f;
        !            25: 
        !            26:        argc--, argv++;
        !            27:        termtype = getenv("TERM");
        !            28:        if (termtype == NULL)
        !            29:                termtype = "dumb";
        !            30:        while (argc > 0 && argv[0][0] == '-') {
        !            31:                switch(argv[0][1]) {
        !            32: 
        !            33:                case 't':
        !            34:                case 'T': /* for nroff compatibility */
        !            35:                        if (argv[0][2])
        !            36:                                termtype = &argv[0][2];
        !            37:                        else {
        !            38:                                termtype = argv[1];
        !            39:                                argc--;
        !            40:                                argv++;
        !            41:                        }
        !            42:                        break;
        !            43:                case 'i':
        !            44:                        argc--, argv++;
        !            45:                        iul(argc, argv);
        !            46:                        exit(0);
        !            47: 
        !            48:                default:
        !            49:                        printf("Usage: ul [ -i ] [ -tTerm ] file...\n");
        !            50:                        exit(1);
        !            51:                }
        !            52:        }
        !            53:        switch(tgetent(termcap, termtype)) {
        !            54: 
        !            55:        case 1:
        !            56:                if (tgetflag("os"))
        !            57:                        execv("/bin/cat",argv[-1]);
        !            58:                cp = ulbuf;
        !            59:                if ((backspace = tgetstr("bc",&cp)) == NULL)
        !            60:                        backspace = "\b";
        !            61:                /*
        !            62:                 * Handle terminals that have start underline/stop
        !            63:                 * underline sequences, as well as those with
        !            64:                 * underline char sequences (we assume the sequence
        !            65:                 * moves the cursor forward one character).
        !            66:                 * If we can't find underline sequences, we
        !            67:                 * settle for standout sequences.
        !            68:                 */
        !            69:                if ((chul=tgetstr("uc",&cp)) == NULL)
        !            70:                        chul = "";
        !            71:                if ((stul=tgetstr("us",&cp)) == NULL && !tgetflag("ul") &&
        !            72:                    (!*chul) && (stul=tgetstr("so",&cp)) == NULL)
        !            73:                        stul = "";
        !            74:                if ((endul=tgetstr("ue",&cp)) == NULL && !tgetflag("ul") &&
        !            75:                    (!*chul) && (endul=tgetstr("se",&cp)) == NULL)
        !            76:                        endul = "";
        !            77: #define nilstr(x) (x == NULL || *x == '\0')
        !            78:                if (nilstr(chul)&&nilstr(stul)&&nilstr(endul)&&tgetflag("ul"))
        !            79:                        execv("/bin/cat",argv[-1]);
        !            80:                break;
        !            81: 
        !            82:        default:
        !            83:                fprintf(stderr,"ul: trouble reading termcap\n");
        !            84:                /* fall through to ... */
        !            85: 
        !            86:        case 0:
        !            87:                /* No such terminal type - assume dumb */
        !            88:                stul = endul = chul = "";
        !            89:                break;
        !            90:        }
        !            91:        fflush (stderr);
        !            92:        if (argc == 0)
        !            93:                filter(stdin);
        !            94:        else for (i=0; i<argc; i++) {
        !            95:                f = fopen(argv[i],"r");
        !            96:                if (f == NULL) {
        !            97:                        perror(argv[i]);
        !            98:                        exit(1);
        !            99:                } else
        !           100:                        filter(f);
        !           101:        }
        !           102:        exit(0);
        !           103: }
        !           104: 
        !           105: filter(f)
        !           106: FILE *f;
        !           107: {
        !           108:        register int p, n;
        !           109:        register char c;
        !           110:        int state;
        !           111: 
        !           112:        n = 0;
        !           113:        for (;;) {
        !           114:                p = 0;
        !           115:                for (p=0; p<n; p++) {
        !           116:                        buf[p] = '\0';
        !           117:                        isul[p] = 0;
        !           118:                }
        !           119:                p = n = 0;
        !           120: 
        !           121:                for (;;) {
        !           122:                        c = getc(f);
        !           123:                        if (c==EOF)
        !           124:                                break;
        !           125:                        if (c=='\b') {
        !           126:                                if (p > 0) {
        !           127:                                        p--;
        !           128:                                }
        !           129:                        } else if (c=='_' && isul[p]==0 && buf[p]) {
        !           130:                                isul[p] = 1;
        !           131:                                p++;
        !           132:                        } else {
        !           133:                                if (buf[p] == '_')
        !           134:                                        isul[p] = 1;
        !           135:                                buf[p] = c;
        !           136:                                p++;
        !           137:                                if (n < p)
        !           138:                                        n = p;
        !           139:                        }
        !           140:                        if (c=='\n')
        !           141:                                break;
        !           142:                }
        !           143: 
        !           144:                state = 0;
        !           145:                for (p=0; p<n; p++) {
        !           146:                        if (isul[p] != state)
        !           147:                                tputs(isul[p] ? stul : endul, 1, outc);
        !           148:                        state = isul[p];
        !           149:                        putchar(buf[p]);
        !           150:                        if (isul[p] && *chul) {
        !           151:                                printf("%s",backspace);
        !           152:                                tputs(chul, 1, outc);
        !           153:                        }
        !           154:                }
        !           155:                if (c==EOF) break;
        !           156:        }
        !           157: }
        !           158: 
        !           159: outc(c)
        !           160: char c;
        !           161: {
        !           162:        putchar(c);
        !           163: }
        !           164: 
        !           165: #define BACKSPACE 0
        !           166: #define        QUOTE   0200
        !           167: 
        !           168: char   linebuf[BUFSIZ], genbuf[BUFSIZ];
        !           169: char   *strcpy();
        !           170: 
        !           171: iul(argc, argv)
        !           172:        int argc;
        !           173:        char *argv[];
        !           174: {
        !           175:        register c;
        !           176:        register char *lp;
        !           177: 
        !           178:        do {
        !           179:                if (argc > 0) {
        !           180:                        if (freopen(argv[0], "r", stdin) == NULL) {
        !           181:                                perror(argv[0]);
        !           182:                                exit(1);
        !           183:                        }
        !           184:                        argc--; argv++;
        !           185:                }
        !           186:                while (fgets(linebuf, sizeof linebuf, stdin) != 0) {
        !           187:                        for (lp = linebuf; *lp; lp++)
        !           188:                                continue;
        !           189:                        *--lp = 0;
        !           190:                        doulg();
        !           191:                        dographic();
        !           192:                        if (genbuf[0])
        !           193:                                printf("\n%s", genbuf);
        !           194:                        putchar('\n');
        !           195:                        fflush(stdout);
        !           196:                }
        !           197:        } while (argc > 0);
        !           198:        exit(0);
        !           199: }
        !           200: 
        !           201: dographic()
        !           202: {
        !           203:        register char *lp;
        !           204:        register c;
        !           205: 
        !           206:        for (lp = linebuf; c = *lp++;) {
        !           207:                switch (c) {
        !           208:                        case '\b':
        !           209:                                if (BACKSPACE == 0)
        !           210:                                        c = '?';
        !           211:                                break;
        !           212:                        default:
        !           213:                                if (c < ' ' || c == 0177)
        !           214:                                        c = '?';
        !           215:                                break;
        !           216:                        case '\t':
        !           217:                                break;
        !           218:                }
        !           219:                putchar(c);
        !           220:        }
        !           221: }
        !           222: 
        !           223: doulg()
        !           224: {
        !           225:        register char *lp, *gp;
        !           226:        char *maxgp;
        !           227:        register c;
        !           228:        char csw;
        !           229:        int col;
        !           230: 
        !           231:        gp = genbuf;
        !           232:        *gp = 0;
        !           233:        maxgp = gp;
        !           234:        col = 0;
        !           235:        for (lp = linebuf; c = *lp++;) {
        !           236:                switch (c) {
        !           237:                        case '\t':
        !           238:                                while ((col & 7) != 7) {
        !           239:                                        *gp++ = ' ';
        !           240:                                        if (gp >= &genbuf[BUFSIZ - 2])
        !           241:                                                goto ovflo;
        !           242:                                        col++;
        !           243:                                }
        !           244:                                break;
        !           245:                        default:
        !           246:                                if (gp >= maxgp)
        !           247:                                        break;
        !           248:                                c |= (*gp & QUOTE);
        !           249:                                break;
        !           250:                        case '_':
        !           251:                                if (gp >= maxgp)
        !           252:                                        c = QUOTE;
        !           253:                                else
        !           254:                                        c = *gp | QUOTE;
        !           255:                                break;
        !           256:                        case '\b':
        !           257:                                if (gp > genbuf) {
        !           258:                                        gp--;
        !           259:                                        col--;
        !           260:                                }
        !           261:                                continue;
        !           262:                }
        !           263:                if (gp >= &genbuf[BUFSIZ - 2]) {
        !           264: ovflo:
        !           265:                        fprintf(stderr, "ul: line too long\n");
        !           266:                        exit(1);
        !           267:                }
        !           268:                *gp++ = c;
        !           269:                if (gp > maxgp)
        !           270:                        maxgp = gp;
        !           271:                col++;
        !           272:        }
        !           273:        *maxgp = 0;
        !           274:        strcpy(linebuf, genbuf);
        !           275:        for (lp = linebuf, gp = genbuf; c = *lp; gp++, lp++)
        !           276:                if (c & QUOTE) {
        !           277:                        c &= 0177;
        !           278:                        if (c == 0)
        !           279:                                *lp = '_', *gp = ' ';
        !           280:                        else
        !           281:                                *lp = c, *gp = '-';
        !           282:                } else
        !           283:                        *gp = ' ';
        !           284:        --gp;
        !           285:        while (gp >= genbuf && *gp == ' ')
        !           286:                --gp;
        !           287:        gp[1] = 0;
        !           288: }

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