Return to wc.c CVS log

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

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

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