src/wc.c

   1 /* wc - print the number of bytes, words, and lines in files
   2    Copyright (C) 85, 91, 95, 96, 1997 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation; either version 2, or (at your option)
   7    any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software
  16    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Written by Paul Rubin, phr@ocf.berkeley.edu
  19    and David MacKenzie, djm@gnu.ai.mit.edu. */
  20 \f
  21 #include <config.h>
  22
  23 #include <stdio.h>
  24 #include <getopt.h>
  25 #include <sys/types.h>
  26 #include "system.h"
  27 #include "error.h"
  28
  29 /* Size of atomic reads. */
  30 #define BUFFER_SIZE (16 * 1024)
  31
  32 int safe_read ();
  33
  34 /* The name this program was run with. */
  35 char *program_name;
  36
  37 /* Cumulative number of lines, words, and chars in all files so far.
  38    max_line_length is the maximum over all files processed so far.  */
  39 static unsigned long total_lines, total_words, total_chars, max_line_length;
  40
  41 /* Which counts to print. */
  42 static int print_lines, print_words, print_chars, print_linelength;
  43
  44 /* Nonzero if we have ever read the standard input. */
  45 static int have_read_stdin;
  46
  47 /* The error code to return to the system. */
  48 static int exit_status;
  49
  50 /* If nonzero, display usage information and exit.  */
  51 static int show_help;
  52
  53 /* If nonzero, print the version on standard output then exits.  */
  54 static int show_version;
  55
  56 static struct option const longopts[] =
  57 {
  58   {"bytes", no_argument, NULL, 'c'},
  59   {"chars", no_argument, NULL, 'c'},
  60   {"lines", no_argument, NULL, 'l'},
  61   {"words", no_argument, NULL, 'w'},
  62   {"max-line-length", no_argument, NULL, 'L'},
  63   {"help", no_argument, &show_help, 1},
  64   {"version", no_argument, &show_version, 1},
  65   {NULL, 0, NULL, 0}
  66 };
  67
  68 static void
  69 usage (int status)
  70 {
  71   if (status != 0)
  72     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  73              program_name);
  74   else
  75     {
  76       printf (_("\
  77 Usage: %s [OPTION]... [FILE]...\n\
  78 "),
  79               program_name);
  80       printf (_("\
  81 Print line, word, and byte counts for each FILE, and a total line if\n\
  82 more than one FILE is specified.  With no FILE, or when FILE is -,\n\
  83 read standard input.\n\
  84   -c, --bytes, --chars   print the byte counts\n\
  85   -l, --lines            print the newline counts\n\
  86   -L, --max-line-length  print the length of the longest line\n\
  87   -w, --words            print the word counts\n\
  88       --help             display this help and exit\n\
  89       --version          output version information and exit\n\
  90 "));
  91       puts (_("\nReport bugs to <textutils-bugs@gnu.org>."));
  92     }
  93   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
  94 }
  95
  96 static void
  97 write_counts (long unsigned int lines, long unsigned int words,
  98               long unsigned int chars, long unsigned int linelength,
  99               const char *file)
 100 {
 101   if (print_lines)
 102     printf ("%7lu", lines);
 103   if (print_words)
 104     {
 105       if (print_lines)
 106         putchar (' ');
 107       printf ("%7lu", words);
 108     }
 109   if (print_chars)
 110     {
 111       if (print_lines || print_words)
 112         putchar (' ');
 113       printf ("%7lu", chars);
 114     }
 115   if (print_linelength)
 116     {
 117       if (print_lines || print_words || print_chars)
 118         putchar (' ');
 119       printf ("%7lu", linelength);
 120     }
 121   if (*file)
 122     printf (" %s", file);
 123   putchar ('\n');
 124 }
 125
 126 static void
 127 wc (int fd, const char *file)
 128 {
 129   char buf[BUFFER_SIZE + 1];
 130   register int bytes_read;
 131   register int in_word = 0;
 132   register unsigned long lines, words, chars, linelength;
 133
 134   lines = words = chars = linelength = 0;
 135
 136   /* When counting only bytes, save some line- and word-counting
 137      overhead.  If FD is a `regular' Unix file, using lseek is enough
 138      to get its `size' in bytes.  Otherwise, read blocks of BUFFER_SIZE
 139      bytes at a time until EOF.  Note that the `size' (number of bytes)
 140      that wc reports is smaller than stats.st_size when the file is not
 141      positioned at its beginning.  That's why the lseek calls below are
 142      necessary.  For example the command
 143      `(dd ibs=99k skip=1 count=0; ./wc -c) < /etc/group'
 144      should make wc report `0' bytes.  */
 145
 146   if (print_chars && !print_words && !print_lines && !print_linelength)
 147     {
 148       off_t current_pos, end_pos;
 149       struct stat stats;
 150
 151       if (fstat (fd, &stats) == 0 && S_ISREG (stats.st_mode)
 152           && (current_pos = lseek (fd, (off_t) 0, SEEK_CUR)) != -1
 153           && (end_pos = lseek (fd, (off_t) 0, SEEK_END)) != -1)
 154         {
 155           off_t diff;
 156           /* Be careful here.  The current position may actually be
 157              beyond the end of the file.  As in the example above.  */
 158           chars = (diff = end_pos - current_pos) < 0 ? 0 : diff;
 159         }
 160       else
 161         {
 162           while ((bytes_read = safe_read (fd, buf, BUFFER_SIZE)) > 0)
 163             {
 164               chars += bytes_read;
 165             }
 166           if (bytes_read < 0)
 167             {
 168               error (0, errno, "%s", file);
 169               exit_status = 1;
 170             }
 171         }
 172     }
 173   else if (!print_words && !print_linelength)
 174     {
 175       /* Use a separate loop when counting only lines or lines and bytes --
 176          but not words.  */
 177       while ((bytes_read = safe_read (fd, buf, BUFFER_SIZE)) > 0)
 178         {
 179           register char *p = buf;
 180
 181           while ((p = memchr (p, '\n', (buf + bytes_read) - p)))
 182             {
 183               ++p;
 184               ++lines;
 185             }
 186           chars += bytes_read;
 187         }
 188       if (bytes_read < 0)
 189         {
 190           error (0, errno, "%s", file);
 191           exit_status = 1;
 192         }
 193     }
 194   else
 195     {
 196       register unsigned long linepos = 0;
 197
 198       while ((bytes_read = safe_read (fd, buf, BUFFER_SIZE)) > 0)
 199         {
 200           register char *p = buf;
 201
 202           chars += bytes_read;
 203           do
 204             {
 205               switch (*p++)
 206                 {
 207                 case '\n':
 208                   lines++;
 209                   /* Fall through. */
 210                 case '\r':
 211                 case '\f':
 212                   if (linepos > linelength)
 213                     linelength = linepos;
 214                   linepos = 0;
 215                   goto word_separator;
 216                 case '\t':
 217                   linepos += 8 - (linepos % 8);
 218                   goto word_separator;
 219                 case ' ':
 220                   linepos++;
 221                   /* Fall through. */
 222                 case '\v':
 223                 word_separator:
 224                   if (in_word)
 225                     {
 226                       in_word = 0;
 227                       words++;
 228                     }
 229                   break;
 230                 default:
 231                   linepos++;
 232                   in_word = 1;
 233                   break;
 234                 }
 235             }
 236           while (--bytes_read);
 237         }
 238       if (bytes_read < 0)
 239         {
 240           error (0, errno, "%s", file);
 241           exit_status = 1;
 242         }
 243       if (linepos > linelength)
 244         linelength = linepos;
 245       if (in_word)
 246         words++;
 247     }
 248
 249   write_counts (lines, words, chars, linelength, file);
 250   total_lines += lines;
 251   total_words += words;
 252   total_chars += chars;
 253   if (linelength > max_line_length)
 254     max_line_length = linelength;
 255 }
 256
 257 static void
 258 wc_file (const char *file)
 259 {
 260   if (!strcmp (file, "-"))
 261     {
 262       have_read_stdin = 1;
 263       wc (0, file);
 264     }
 265   else
 266     {
 267       int fd = open (file, O_RDONLY);
 268       if (fd == -1)
 269         {
 270           error (0, errno, "%s", file);
 271           exit_status = 1;
 272           return;
 273         }
 274       wc (fd, file);
 275       if (close (fd))
 276         {
 277           error (0, errno, "%s", file);
 278           exit_status = 1;
 279         }
 280     }
 281 }
 282
 283 int
 284 main (int argc, char **argv)
 285 {
 286   int optc;
 287   int nfiles;
 288
 289   program_name = argv[0];
 290   setlocale (LC_ALL, "");
 291   bindtextdomain (PACKAGE, LOCALEDIR);
 292   textdomain (PACKAGE);
 293
 294   exit_status = 0;
 295   print_lines = print_words = print_chars = print_linelength = 0;
 296   total_lines = total_words = total_chars = max_line_length = 0;
 297
 298   while ((optc = getopt_long (argc, argv, "clLw", longopts, NULL)) != -1)
 299     switch (optc)
 300       {
 301       case 0:
 302         break;
 303
 304       case 'c':
 305         print_chars = 1;
 306         break;
 307
 308       case 'l':
 309         print_lines = 1;
 310         break;
 311
 312       case 'w':
 313         print_words = 1;
 314         break;
 315
 316       case 'L':
 317         print_linelength = 1;
 318         break;
 319
 320       default:
 321         usage (1);
 322       }
 323
 324   if (show_version)
 325     {
 326       printf ("wc (%s) %s\n", GNU_PACKAGE, VERSION);
 327       exit (EXIT_SUCCESS);
 328     }
 329
 330   if (show_help)
 331     usage (0);
 332
 333   if (print_lines + print_words + print_chars + print_linelength == 0)
 334     print_lines = print_words = print_chars = 1;
 335
 336   nfiles = argc - optind;
 337
 338   if (nfiles == 0)
 339     {
 340       have_read_stdin = 1;
 341       wc (0, "");
 342     }
 343   else
 344     {
 345       for (; optind < argc; ++optind)
 346         wc_file (argv[optind]);
 347
 348       if (nfiles > 1)
 349         write_counts (total_lines, total_words, total_chars, max_line_length,
 350                       _("total"));
 351     }
 352
 353   if (have_read_stdin && close (0))
 354     error (EXIT_FAILURE, errno, "-");
 355
 356   exit (exit_status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 357 }