Return to wc.c CVS log

Up to [MW Coherent from dump] / coherent / b / bin

Annotation of coherent/b/bin/wc.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * wc - word count
        !             3:  * Counts characters, lines, and words in all
        !             4:  * of the input files.
        !             5:  *
        !             6:  * Usage: wc [-lwc] [name ...]
        !             7:  *
        !             8:  * Revised June '93 for POSIX.2: changed output format and uses isspace () to
        !             9:  * delimit words.
        !            10:  */
        !            11: 
        !            12: #include <stdio.h>
        !            13: #include <ctype.h>
        !            14: #ifdef COHERENT
        !            15: #include <access.h>
        !            16: #endif
        !            17: 
        !            18: char   _cmdname[] = "wc";
        !            19: int    nfiles;
        !            20: int    lineflg;
        !            21: int    wordflg;
        !            22: int    charflg;
        !            23: long   chars, words, lines;
        !            24: long   tchars, twords, tlines;
        !            25: 
        !            26: main(argc, argv)
        !            27: char *argv[];
        !            28: {
        !            29:        register int i = 0;
        !            30:        register char *ap;
        !            31:        register FILE *fp;
        !            32: 
        !            33:        while (argv[1] != NULL && *argv[1] == '-') {
        !            34:                for (ap = &argv[1][1]; *ap; ap++)
        !            35:                        switch (*ap) {
        !            36:                        case 'l':
        !            37:                                lineflg = 1;
        !            38:                                break;
        !            39: 
        !            40:                        case 'w':
        !            41:                                wordflg = 1;
        !            42:                                break;
        !            43: 
        !            44:                        case 'c':
        !            45:                                charflg = 1;
        !            46:                                break;
        !            47: 
        !            48:                        default:
        !            49:                                usage();
        !            50:                        }
        !            51:                argv++;
        !            52:                argc--;
        !            53:        }
        !            54:        if (argc == 1) {
        !            55: #ifdef MSDOS
        !            56:                _setbinary(stdin);
        !            57: #endif
        !            58:                wc(stdin);
        !            59:                print(NULL);
        !            60:        } else {
        !            61:                argv++;  /* adjust args */
        !            62: 
        !            63:                while (*argv)
        !            64:                {
        !            65: #ifdef COHERENT
        !            66:                   if (access(*argv, AREAD))
        !            67:                    {  fprintf(stderr, "wc: can't open %s\n", *argv);
        !            68:                       *argv[0] = 0;  /* flag arg as invalid */
        !            69:                    }
        !            70: #endif
        !            71:                    i++;     /* count the arg */
        !            72:                    argv++;  /* advance to next arg */
        !            73:                }
        !            74:                
        !            75:                argv -= i;  /* back to start of filename args to process */
        !            76:                argc--; 
        !            77: 
        !            78:                for (i=0; i<argc; i++) {
        !            79:                        if (*argv[i] == 0)  /* arg to skip? */ 
        !            80:                           continue;        /* yes */
        !            81:                        if ((fp = fopen(argv[i], "rb")) == NULL) {
        !            82:                                fprintf(stderr,
        !            83:                                   "wc: can't open %s\n", argv[i]);
        !            84:                                continue;
        !            85:                        }
        !            86:                        nfiles++;
        !            87:                        wc(fp);
        !            88:                        print(argv[i]);
        !            89:                        tchars += chars;
        !            90:                        twords += words;
        !            91:                        tlines += lines;
        !            92:                        fclose(fp);
        !            93:                }
        !            94:                if (nfiles >= 2) {
        !            95:                        chars = tchars;
        !            96:                        words = twords;
        !            97:                        lines = tlines;
        !            98:                        print("Total");
        !            99:                }
        !           100:        }
        !           101: }
        !           102: 
        !           103: /*
        !           104:  * Count words, lines and characters in the input file
        !           105:  * descriptor and put into global variables.
        !           106:  */
        !           107: wc(in)
        !           108: register FILE *in;
        !           109: {
        !           110:        register c;
        !           111:        int inw;
        !           112: 
        !           113:        inw = 0;
        !           114:        chars = words = lines = 0;
        !           115:        while ((c = getc(in)) != EOF) {
        !           116:                chars++;
        !           117: 
        !           118:                if (c == '\n')
        !           119:                        lines++;
        !           120: 
        !           121:                if (isspace (c))
        !           122:                        inw = 0;
        !           123:                else if (!inw) {
        !           124:                        inw = 1;
        !           125:                        words++;
        !           126:                }
        !           127:        }
        !           128: }
        !           129: 
        !           130: /*
        !           131:  * Print according to option flags to totals
        !           132:  */
        !           133: print(name)
        !           134: char *name;
        !           135: {
        !           136:        if (!lineflg && !wordflg && !charflg)
        !           137:                printf("%7ld %7ld %7ld", lines, words, chars);
        !           138:        else {
        !           139:                if (lineflg) {
        !           140:                        printf("%7ld", lines);
        !           141:                        if (wordflg || charflg)
        !           142:                                putchar (' ');
        !           143:                }
        !           144:                if (wordflg) {
        !           145:                        printf("%7ld", words);
        !           146:                        if (charflg)
        !           147:                                putchar (' ');
        !           148:                }
        !           149:                if (charflg)
        !           150:                        printf("%7ld", chars);
        !           151:        }
        !           152:        if (name != NULL)
        !           153:                printf(" %s", name);
        !           154:        printf("\n");
        !           155: }
        !           156: 
        !           157: usage()
        !           158: {
        !           159:        fprintf(stderr, "Usage: wc [-lwc] [name ...]\n");
        !           160:        exit(1);
        !           161: }

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