Return to col.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / usr.bin

Annotation of 43BSDTahoe/usr.bin/col.c, revision 1.1

1.1     ! root        1: static char *sccsid = "@(#)col.c       4.2 (Berkeley) 5/15/84";
        !             2: # include <stdio.h>
        !             3: # define PL 256
        !             4: # define ESC '\033'
        !             5: # define RLF '\013'
        !             6: # define SI '\017'
        !             7: # define SO '\016'
        !             8: # define GREEK 0200
        !             9: # define LINELN 800
        !            10: 
        !            11: char *page[PL];
        !            12: char lbuff [LINELN], *line;
        !            13: int bflag, hflag, fflag;
        !            14: int half;
        !            15: int cp, lp;
        !            16: int ll, llh, mustwr;
        !            17: int pcp = 0;
        !            18: char *pgmname;
        !            19: char   *strcpy();
        !            20: 
        !            21: main (argc, argv)
        !            22:        int argc; char **argv;
        !            23: {
        !            24:        int i;
        !            25:        int greek;
        !            26:        register int c;
        !            27: 
        !            28:        pgmname = argv[0];
        !            29: 
        !            30:        for (i = 1; i < argc; i++) {
        !            31:                register char *p;
        !            32:                if (*argv[i] != '-') {
        !            33:                        fprintf (stderr, "%s: bad option %s\n",
        !            34:                                pgmname, argv[i]);
        !            35:                        exit (2);
        !            36:                }
        !            37:                for (p = argv[i]+1; *p; p++) {
        !            38:                        switch (*p) {
        !            39:                        case 'b':
        !            40:                                bflag++;
        !            41:                                break;
        !            42: 
        !            43:                        case 'h':
        !            44:                                hflag++;
        !            45:                                break;
        !            46: 
        !            47:                        case 'f':
        !            48:                                fflag++;
        !            49:                                break;
        !            50: 
        !            51:                        default:
        !            52:                                fprintf (stderr, "%s: bad option letter %c\n",
        !            53:                                        pgmname, *p);
        !            54:                                exit (2);
        !            55:                        }
        !            56:                }
        !            57:        }
        !            58: 
        !            59:        for (ll=0; ll<PL; ll++)
        !            60:                page[ll] = 0;
        !            61: 
        !            62:        cp = 0;
        !            63:        ll = 0;
        !            64:        greek = 0;
        !            65:        mustwr = PL;
        !            66:        line = lbuff;
        !            67: 
        !            68:        while ((c = getchar()) != EOF) {
        !            69:                switch (c) {
        !            70:                case '\n':
        !            71:                        incr();
        !            72:                        incr();
        !            73:                        cp = 0;
        !            74:                        continue;
        !            75: 
        !            76:                case '\0':
        !            77:                        continue;
        !            78: 
        !            79:                case ESC:
        !            80:                        c = getchar();
        !            81:                        switch (c) {
        !            82:                        case '7':       /* reverse full line feed */
        !            83:                                decr();
        !            84:                                decr();
        !            85:                                break;
        !            86: 
        !            87:                        case '8':       /* reverse half line feed */
        !            88:                                if (fflag)
        !            89:                                        decr();
        !            90:                                else {
        !            91:                                        if (--half < -1) {
        !            92:                                                decr();
        !            93:                                                decr();
        !            94:                                                half += 2;
        !            95:                                        }
        !            96:                                }
        !            97:                                break;
        !            98: 
        !            99:                        case '9':       /* forward half line feed */
        !           100:                                if (fflag)
        !           101:                                        incr();
        !           102:                                else {
        !           103:                                        if (++half > 0) {
        !           104:                                                incr();
        !           105:                                                incr();
        !           106:                                                half -= 2;
        !           107:                                        }
        !           108:                                }
        !           109:                                break;
        !           110:                        }
        !           111:                        continue;
        !           112: 
        !           113:                case SO:
        !           114:                        greek = GREEK;
        !           115:                        continue;
        !           116: 
        !           117:                case SI:
        !           118:                        greek = 0;
        !           119:                        continue;
        !           120: 
        !           121:                case RLF:
        !           122:                        decr();
        !           123:                        decr();
        !           124:                        continue;
        !           125: 
        !           126:                case '\r':
        !           127:                        cp = 0;
        !           128:                        continue;
        !           129: 
        !           130:                case '\t':
        !           131:                        cp = (cp + 8) & -8;
        !           132:                        continue;
        !           133: 
        !           134:                case '\b':
        !           135:                        if (cp > 0)
        !           136:                                cp--;
        !           137:                        continue;
        !           138: 
        !           139:                case ' ':
        !           140:                        cp++;
        !           141:                        continue;
        !           142: 
        !           143:                default:
        !           144:                        c &= 0177;
        !           145:                        if (c > 040 && c < 0177) {      /* if printable */
        !           146:                                outc(c | greek);
        !           147:                                cp++;
        !           148:                        }
        !           149:                        continue;
        !           150:                }
        !           151:        }
        !           152: 
        !           153:        for (i=0; i<PL; i++)
        !           154:                if (page[(mustwr+i)%PL] != 0)
        !           155:                        emit (page[(mustwr+i) % PL], mustwr+i-PL);
        !           156:        emit (" ", (llh + 1) & -2);
        !           157:        exit(0);
        !           158: }
        !           159: 
        !           160: outc (c)
        !           161:        register char c;
        !           162: {
        !           163:        if (lp > cp) {
        !           164:                line = lbuff;
        !           165:                lp = 0;
        !           166:        }
        !           167: 
        !           168:        while (lp < cp) {
        !           169:                switch (*line) {
        !           170:                case '\0':
        !           171:                        *line = ' ';
        !           172:                        lp++;
        !           173:                        break;
        !           174: 
        !           175:                case '\b':
        !           176:                        lp--;
        !           177:                        break;
        !           178: 
        !           179:                default:
        !           180:                        lp++;
        !           181:                }
        !           182:                line++;
        !           183:        }
        !           184:        while (*line == '\b') {
        !           185:                line += 2;
        !           186:        }
        !           187:        if (bflag || *line == '\0' || *line == ' ')
        !           188:                *line = c;
        !           189:        else {
        !           190:                register char c1, c2, c3;
        !           191:                c1 = *++line;
        !           192:                *line++ = '\b';
        !           193:                c2 = *line;
        !           194:                *line++ = c;
        !           195:                while (c1) {
        !           196:                        c3 = *line;
        !           197:                        *line++ = c1;
        !           198:                        c1 = c2;
        !           199:                        c2 = c3;
        !           200:                }
        !           201:                lp = 0;
        !           202:                line = lbuff;
        !           203:        }
        !           204: }
        !           205: 
        !           206: store (lno)
        !           207: {
        !           208:        char *malloc();
        !           209: 
        !           210:        lno %= PL;
        !           211:        if (page[lno] != 0)
        !           212:                free (page[lno]);
        !           213:        page[lno] = malloc((unsigned)strlen(lbuff) + 2);
        !           214:        if (page[lno] == 0) {
        !           215:                fprintf (stderr, "%s: no storage\n", pgmname);
        !           216:                exit (2);
        !           217:        }
        !           218:        strcpy (page[lno],lbuff);
        !           219: }
        !           220: 
        !           221: fetch(lno)
        !           222: {
        !           223:        register char *p;
        !           224: 
        !           225:        lno %= PL;
        !           226:        p = lbuff;
        !           227:        while (*p)
        !           228:                *p++ = '\0';
        !           229:        line = lbuff;
        !           230:        lp = 0;
        !           231:        if (page[lno])
        !           232:                strcpy (line, page[lno]);
        !           233: }
        !           234: emit (s, lineno)
        !           235:        char *s;
        !           236:        int lineno;
        !           237: {
        !           238:        static int cline = 0;
        !           239:        register int ncp;
        !           240:        register char *p;
        !           241:        static int gflag = 0;
        !           242: 
        !           243:        if (*s) {
        !           244:                while (cline < lineno - 1) {
        !           245:                        putchar ('\n');
        !           246:                        pcp = 0;
        !           247:                        cline += 2;
        !           248:                }
        !           249:                if (cline != lineno) {
        !           250:                        putchar (ESC);
        !           251:                        putchar ('9');
        !           252:                        cline++;
        !           253:                }
        !           254:                if (pcp)
        !           255:                        putchar ('\r');
        !           256:                pcp = 0;
        !           257:                p = s;
        !           258:                while (*p) {
        !           259:                        ncp = pcp;
        !           260:                        while (*p++ == ' ') {
        !           261:                                if ((++ncp & 7) == 0 && hflag) {
        !           262:                                        pcp = ncp;
        !           263:                                        putchar ('\t');
        !           264:                                }
        !           265:                        }
        !           266:                        if (!*--p)
        !           267:                                break;
        !           268:                        while (pcp < ncp) {
        !           269:                                putchar (' ');
        !           270:                                pcp++;
        !           271:                        }
        !           272:                        if (gflag != (*p & GREEK) && *p != '\b') {
        !           273:                                if (gflag)
        !           274:                                        putchar (SI);
        !           275:                                else
        !           276:                                        putchar (SO);
        !           277:                                gflag ^= GREEK;
        !           278:                        }
        !           279:                        putchar (*p & ~GREEK);
        !           280:                        if (*p++ == '\b')
        !           281:                                pcp--;
        !           282:                        else
        !           283:                                pcp++;
        !           284:                }
        !           285:        }
        !           286: }
        !           287: 
        !           288: incr()
        !           289: {
        !           290:        store (ll++);
        !           291:        if (ll > llh)
        !           292:                llh = ll;
        !           293:        if (ll >= mustwr && page[ll%PL]) {
        !           294:                emit (page[ll%PL], ll - PL);
        !           295:                mustwr++;
        !           296:                free (page[ll%PL]);
        !           297:                page[ll%PL] = 0;
        !           298:        }
        !           299:        fetch (ll);
        !           300: }
        !           301: 
        !           302: decr()
        !           303: {
        !           304:        if (ll > mustwr - PL) {
        !           305:                store (ll--);
        !           306:                fetch (ll);
        !           307:        }
        !           308: }

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