usr.bin/wc/wc.c

   1 /*
   2  * Copyright (c) 1980, 1987, 1991, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. All advertising materials mentioning features or use of this software
  14  *    must display the following acknowledgement:
  15  *      This product includes software developed by the University of
  16  *      California, Berkeley and its contributors.
  17  * 4. Neither the name of the University nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  *
  33  * @(#) Copyright (c) 1980, 1987, 1991, 1993 The Regents of the University of California.  All rights reserved.
  34  * @(#)wc.c     8.1 (Berkeley) 6/6/93
  35  * $FreeBSD: src/usr.bin/wc/wc.c,v 1.11.2.1 2002/08/25 02:47:04 tjr Exp $
  36  * $DragonFly: src/usr.bin/wc/wc.c,v 1.5 2005/02/05 16:07:08 liamfoy Exp $
  37  */
  38
  39 #include <sys/param.h>
  40 #include <sys/stat.h>
  41
  42 #include <ctype.h>
  43 #include <err.h>
  44 #include <errno.h>
  45 #include <fcntl.h>
  46 #include <locale.h>
  47 #include <stdio.h>
  48 #include <stdlib.h>
  49 #include <string.h>
  50 #include <unistd.h>
  51
  52 uintmax_t tlinect, twordct, tcharct;
  53 int doline, doword, dochar, domulti;
  54
  55 static int      cnt(const char *);
  56 static void     usage(void);
  57
  58 int
  59 main(int argc, char **argv)
  60 {
  61         int ch, errors, total;
  62
  63         setlocale(LC_CTYPE, "");
  64
  65         while ((ch = getopt(argc, argv, "clmw")) != -1) {
  66                 switch (ch) {
  67                 case 'l':
  68                         doline = 1;
  69                         break;
  70                 case 'w':
  71                         doword = 1;
  72                         break;
  73                 case 'c':
  74                         dochar = 1;
  75                         domulti = 0;
  76                         break;
  77                 case 'm':
  78                         domulti = 1;
  79                         dochar = 0;
  80                         break;
  81                 case '?':
  82                 default:
  83                         usage();
  84                 }
  85         }
  86         argv += optind;
  87         argc -= optind;
  88
  89         /* Wc's flags are on by default. */
  90         if (doline + doword + dochar + domulti == 0)
  91                 doline = doword = dochar = 1;
  92
  93         errors = 0;
  94         total = 0;
  95         if (*argv == NULL) {
  96                 if (cnt(NULL) != 0)
  97                         ++errors;
  98                 else
  99                         printf("\n");
 100         }
 101         else do {
 102                 if (cnt(*argv) != 0)
 103                         ++errors;
 104                 else
 105                         printf(" %s\n", *argv);
 106                 ++total;
 107         } while(*++argv);
 108
 109         if (total > 1) {
 110                 if (doline)
 111                         printf(" %7ju", tlinect);
 112                 if (doword)
 113                         printf(" %7ju", twordct);
 114                 if (dochar || domulti)
 115                         printf(" %7ju", tcharct);
 116                 printf(" total\n");
 117         }
 118         exit(errors == 0 ? 0 : 1);
 119 }
 120
 121 static int
 122 cnt(const char *file)
 123 {
 124         struct stat sb;
 125         u_quad_t linect, wordct, charct;
 126         ssize_t nread;
 127         int clen, fd, len, warned;
 128         short gotsp;
 129         u_char *p;
 130         u_char buf[MAXBSIZE];
 131         wchar_t wch;
 132
 133         linect = wordct = charct = 0;
 134         if (file == NULL) {
 135                 file = "stdin";
 136                 fd = STDIN_FILENO;
 137         } else {
 138                 if ((fd = open(file, O_RDONLY)) < 0) {
 139                         warn("%s: open", file);
 140                         return (1);
 141                 }
 142                 if (doword || (domulti && MB_CUR_MAX != 1))
 143                         goto word;
 144                 /*
 145                  * Line counting is split out because it's a lot faster to get
 146                  * lines than to get words, since the word count requires some
 147                  * logic.
 148                  */
 149                 if (doline) {
 150                         while ((len = read(fd, buf, MAXBSIZE))) {
 151                                 if (len == -1) {
 152                                         warn("%s: read", file);
 153                                         close(fd);
 154                                         return (1);
 155                                 }
 156                                 charct += len;
 157                                 for (p = buf; len--; ++p) {
 158                                         if (*p == '\n')
 159                                                 ++linect;
 160                                 }
 161                         }
 162                         tlinect += linect;
 163                         printf(" %7ju", linect);
 164                         if (dochar) {
 165                                 tcharct += charct;
 166                                 printf(" %7ju", charct);
 167                         }
 168                         close(fd);
 169                         return (0);
 170                 }
 171                 /*
 172                  * If all we need is the number of characters and it's a
 173                  * regular file, just stat the puppy.
 174                  */
 175                 if (dochar || domulti) {
 176                         if (fstat(fd, &sb)) {
 177                                 warn("%s: fstat", file);
 178                                 close(fd);
 179                                 return (1);
 180                         }
 181                         if (S_ISREG(sb.st_mode)) {
 182                                 printf(" %7lld", (long long)sb.st_size);
 183                                 tcharct += sb.st_size;
 184                                 close(fd);
 185                                 return (0);
 186                         }
 187                 }
 188         }
 189
 190         /* Do it the hard way... */
 191 word:   gotsp = 1;
 192         len = 0;
 193         warned = 0;
 194         while ((nread = read(fd, buf + len, MAXBSIZE - len)) != 0) {
 195                 if (nread == -1) {
 196                         warn("%s: read", file);
 197                         close(fd);
 198                         return (1);
 199                 }
 200                 len += nread;
 201                 p = buf;
 202                 while (len > 0) {
 203                         if (!domulti || MB_CUR_MAX == 1) {
 204                                 clen = 1;
 205                                 wch = (unsigned char)*p;
 206                         } else if ((clen = mbtowc(&wch, p, len)) <= 0) {
 207                                 if (len > MB_CUR_MAX) {
 208                                         clen = 1;
 209                                         wch = (unsigned char)*p;
 210                                         if (!warned) {
 211                                                 errno = EILSEQ;
 212                                                 warn("%s", file);
 213                                                 warned = 1;
 214                                         }
 215                                 } else {
 216                                         memmove(buf, p, len);
 217                                         break;
 218                                 }
 219                         }
 220                         charct++;
 221                         len -= clen;
 222                         p += clen;
 223                         if (wch == L'\n')
 224                                 ++linect;
 225                         if (isspace(wch))
 226                                 gotsp = 1;
 227                         else if (gotsp) {
 228                                 gotsp = 0;
 229                                 ++wordct;
 230                         }
 231                 }
 232         }
 233         if (doline) {
 234                 tlinect += linect;
 235                 printf(" %7ju", linect);
 236         }
 237         if (doword) {
 238                 twordct += wordct;
 239                 printf(" %7ju", wordct);
 240         }
 241         if (dochar || domulti) {
 242                 tcharct += charct;
 243                 printf(" %7ju", charct);
 244         }
 245         close(fd);
 246         return (0);
 247 }
 248
 249 static void
 250 usage(void)
 251 {
 252         fprintf(stderr, "usage: wc [-clmw] [file ...]\n");
 253         exit(1);
 254 }