Return to wc.c CVS log

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

Annotation of 40BSD/cmd/wc.c, revision 1.1.1.1

1.1       root        1: static char *sccsid = "@(#)wc.c        4.3 (Berkeley) 11/7/80";
                      2: /* wc line and word count */
                      3: 
                      4: #include <stdio.h>
                      5: long   linect, wordct, charct, pagect;
                      6: long   tlinect, twordct, tcharct, tpagect;
                      7: int    baud=300;       /* baud rate */
                      8: int    cps=30;         /* # of chars per second */
                      9: int    lpp=66;         /* # of lines per page */
                     10: char   *wd = "lwc";
                     11: int    verbose;
                     12: int    uucp;
                     13: 
                     14: main(argc, argv)
                     15: char **argv;
                     16: {
                     17:        int i, token;
                     18:        register FILE *fp;
                     19:        register int c;
                     20:        char *p;
                     21: 
                     22:        while (argc > 1 && *argv[1] == '-') {
                     23:                switch (argv[1][1]) {
                     24:                case 'l': case 'w': case 'c': case 'p': case 't':
                     25:                        wd = argv[1]+1;
                     26:                        break;
                     27:                case 's':
                     28:                        lpp = atoi(argv[1]+2);
                     29:                        if (lpp <= 0)
                     30:                                goto usage;
                     31:                        break;
                     32:                case 'v':
                     33:                        verbose++;
                     34:                        wd = "lwcpt";
                     35:                        break;
                     36:                case 'u':
                     37:                        uucp++;
                     38:                        break;
                     39:                case 'b':
                     40:                        baud = atoi(argv[1]+2);
                     41:                        if (baud == 110)
                     42:                                cps = 10;
                     43:                        else
                     44:                                cps = baud / 10;
                     45:                        if (cps <= 0)
                     46:                                goto usage;
                     47:                        break;
                     48:                default:
                     49:                usage:
                     50:                        fprintf(stderr, "Usage: wc [-lwcpt] [-v] [-u] [-spagesize] [-bbaudrate]\n");
                     51:                        exit(1);
                     52:                }
                     53:                argc--;
                     54:                argv++;
                     55:        }
                     56: 
                     57:        if (uucp)
                     58:                cps = cps * 9 / 10;     /* 27 cps at 300 baud */
                     59: 
                     60:        if (verbose) {
                     61:                for (p=wd; *p; p++)
                     62:                        switch(*p) {
                     63:                        case 'l':
                     64:                                printf("lines\t");
                     65:                                break;
                     66:                        case 'w':
                     67:                                printf("words\t");
                     68:                                break;
                     69:                        case 'c':
                     70:                                printf("chars\t");
                     71:                                break;
                     72:                        case 'p':
                     73:                                printf("pages\t");
                     74:                                break;
                     75:                        case 't':
                     76:                                printf("time@%d\t",baud);
                     77:                                break;
                     78:                        }
                     79:                printf("\n");
                     80:        }
                     81: 
                     82:        i = 1;
                     83:        fp = stdin;
                     84:        do {
                     85:                if(argc>1 && (fp=fopen(argv[i], "r")) == NULL) {
                     86:                        fprintf(stderr, "wc: can't open %s\n", argv[i]);
                     87:                        continue;
                     88:                }
                     89:                linect = 0;
                     90:                wordct = 0;
                     91:                charct = 0;
                     92:                pagect = 0;
                     93:                token = 0;
                     94:                for(;;) {
                     95:                        c = getc(fp);
                     96:                        if (c == EOF)
                     97:                                break;
                     98:                        charct++;
                     99:                        if(' '<c&&c<0177) {
                    100:                                if(!token) {
                    101:                                        wordct++;
                    102:                                        token++;
                    103:                                }
                    104:                                continue;
                    105:                        }
                    106:                        if(c=='\n') {
                    107:                                linect++;
                    108:                                if (linect % lpp == 1)
                    109:                                        pagect++;
                    110:                        }
                    111:                        else if(c!=' '&&c!='\t')
                    112:                                continue;
                    113:                        token = 0;
                    114:                }
                    115:                /* print lines, words, chars */
                    116:                wcp(wd, charct, wordct, linect, pagect);
                    117:                if(argc>1) {
                    118:                        printf(" %s\n", argv[i]);
                    119:                } else
                    120:                        printf("\n");
                    121:                fclose(fp);
                    122:                tlinect += linect;
                    123:                twordct += wordct;
                    124:                tcharct += charct;
                    125:                tpagect += pagect;
                    126:        } while(++i<argc);
                    127:        if(argc > 2) {
                    128:                wcp(wd, tcharct, twordct, tlinect, tpagect);
                    129:                printf(" total\n");
                    130:        }
                    131:        exit(0);
                    132: }
                    133: 
                    134: wcp(wd, charct, wordct, linect, pagect)
                    135: register char *wd;
                    136: long charct; long wordct; long linect, pagect;
                    137: {
                    138:        while (*wd) switch (*wd++) {
                    139:        case 'l':
                    140:                ipr(linect);
                    141:                break;
                    142: 
                    143:        case 'w':
                    144:                ipr(wordct);
                    145:                break;
                    146: 
                    147:        case 'c':
                    148:                ipr(charct);
                    149:                break;
                    150: 
                    151:        case 'p':
                    152:                ipr(pagect);
                    153:                break;
                    154: 
                    155:        case 't':
                    156:                prttime(charct/cps);
                    157:                break;
                    158:        }
                    159: }
                    160: 
                    161: ipr(num)
                    162: long num;
                    163: {
                    164:        if (verbose)
                    165:                printf("%ld\t", num);
                    166:        else
                    167:                printf("%7ld", num);
                    168: }
                    169: 
                    170: prttime(secs)
                    171: long secs;
                    172: {
                    173:        int hrs,mins;
                    174:        float t;
                    175:        long osecs;
                    176:        char *units;
                    177: 
                    178:        osecs = secs;
                    179:        hrs = secs / (60*60);
                    180:        secs = secs % (60*60);
                    181:        mins = secs / 60;
                    182:        secs = secs % 60;
                    183: 
                    184:        t = osecs;
                    185:        if (hrs) {
                    186:                t /= (60*60);
                    187:                units = "hr";
                    188:        } else if (mins) {
                    189:                t /= 60;
                    190:                units = "mi";
                    191:        } else {
                    192:                units = "se";
                    193:        }
                    194:        printf("%4.1f %2s\t", t, units);
                    195: }

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