Return to wrap.c CVS log

Up to [MW Coherent from dump] / coherent / b / kernel / tools

Annotation of coherent/b/kernel/tools/wrap.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * wrap.c - fold over lines > 80 characters to avoid truncation during printout
                      3:  *
                      4:  * usage:  wrap [-ttablen] [-wwraplen] < infile > outfile
                      5:  *   tab length defaults to 8
                      6:  *   wrap column defaults to 80
                      7:  */
                      8: #include <stdio.h>
                      9: 
                     10: #define WRAPLEN 80
                     11: #define TABLEN 8
                     12: 
                     13: main(argc, argv)
                     14: int argc;
                     15: char * argv[];
                     16: {
                     17:        /*
                     18:         * get tab length from command line or default to TABLEN
                     19:         * get wrap column from command line or default to WRAPLEN
                     20:         */
                     21: 
                     22:        int chars_this_line = 0;
                     23:        int ch, wl = WRAPLEN, tl = TABLEN;
                     24:        int argnum;
                     25: 
                     26:        for (argnum = 1; argnum < argc; argnum++) {
                     27:                if (argv[argnum][0] == '-')
                     28:                        switch (argv[argnum][1]) {
                     29:                        case 't':
                     30:                                tl = atoi(argv[argnum]+2);
                     31:                                if (tl <= 0 || tl >= 256)
                     32:                                        tl = TABLEN;
                     33:                                break;
                     34:                        case 'w':
                     35:                                wl = atoi(argv[argnum]+2);
                     36:                                if (wl <= 0 || wl >= 256)
                     37:                                        wl = WRAPLEN;
                     38:                                break;
                     39:                        }
                     40:        }
                     41: 
                     42:        /*
                     43:         * while (not at end of stdin)
                     44:         *   get next character
                     45:         *   if it's newline
                     46:         *     reset chars_this_line to zero
                     47:         *   else if it's backspace
                     48:         *     if chars_this_line is > 0
                     49:         *       decrement chars_this_line
                     50:         *   else if it's tab
                     51:         *     insert the right number of spaces
                     52:         *   else
                     53:         *     increment chars_this_line
                     54:         *     if chars_this_line > WRAPLEN
                     55:         *       write newline to stdout
                     56:         *       decrement chars_this_line by WRAPLEN
                     57:         *   write character to stdout
                     58:         */
                     59:        while ((ch = getchar()) != EOF) {
                     60:                if (ch == '\n') {
                     61:                        chars_this_line = 0;
                     62:                        putchar(ch);
                     63:                } else if (ch == '\b') {
                     64:                        if (chars_this_line)
                     65:                                chars_this_line--;
                     66:                        putchar(ch);
                     67:                } else if (ch == '\t') {
                     68:                        do {
                     69:                                chars_this_line++;
                     70:                                if (chars_this_line > wl) {
                     71:                                        putchar('\n');
                     72:                                        chars_this_line -= wl;
                     73:                                }
                     74:                                putchar(' ');
                     75:                        } while (chars_this_line % tl);
                     76:                } else {
                     77:                        chars_this_line++;
                     78:                        if (chars_this_line > wl) {
                     79:                                putchar('\n');
                     80:                                chars_this_line -= wl;
                     81:                        }
                     82:                        putchar(ch);
                     83:                }
                     84:        }
                     85: }

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