src/cut.c

   1 /* cut - remove parts of lines of files
   2    Copyright (C) 1997-2006 Free Software Foundation, Inc.
   3    Copyright (C) 1984 David M. Ihnat
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19 /* Written by David Ihnat.  */
  20
  21 /* POSIX changes, bug fixes, long-named options, and cleanup
  22    by David MacKenzie <djm@gnu.ai.mit.edu>.
  23
  24    Rewrite cut_fields and cut_bytes -- Jim Meyering.  */
  25
  26 #include <config.h>
  27
  28 #include <stdio.h>
  29 #include <assert.h>
  30 #include <getopt.h>
  31 #include <sys/types.h>
  32 #include "system.h"
  33
  34 #include "error.h"
  35 #include "getndelim2.h"
  36 #include "hash.h"
  37 #include "quote.h"
  38 #include "xstrndup.h"
  39
  40 /* The official name of this program (e.g., no `g' prefix).  */
  41 #define PROGRAM_NAME "cut"
  42
  43 #define AUTHORS "David Ihnat", "David MacKenzie", "Jim Meyering"
  44
  45 #define FATAL_ERROR(Message)                                            \
  46   do                                                                    \
  47     {                                                                   \
  48       error (0, 0, (Message));                                          \
  49       usage (EXIT_FAILURE);                                             \
  50     }                                                                   \
  51   while (0)
  52
  53 /* Append LOW, HIGH to the list RP of range pairs, allocating additional
  54    space if necessary.  Update local variable N_RP.  When allocating,
  55    update global variable N_RP_ALLOCATED.  */
  56
  57 #define ADD_RANGE_PAIR(rp, low, high)                   \
  58   do                                                    \
  59     {                                                   \
  60       if (n_rp >= n_rp_allocated)                       \
  61         {                                               \
  62           (rp) = X2NREALLOC (rp, &n_rp_allocated);      \
  63         }                                               \
  64       rp[n_rp].lo = (low);                              \
  65       rp[n_rp].hi = (high);                             \
  66       ++n_rp;                                           \
  67     }                                                   \
  68   while (0)
  69
  70 struct range_pair
  71   {
  72     size_t lo;
  73     size_t hi;
  74   };
  75
  76 /* This buffer is used to support the semantics of the -s option
  77    (or lack of same) when the specified field list includes (does
  78    not include) the first field.  In both of those cases, the entire
  79    first field must be read into this buffer to determine whether it
  80    is followed by a delimiter or a newline before any of it may be
  81    output.  Otherwise, cut_fields can do the job without using this
  82    buffer.  */
  83 static char *field_1_buffer;
  84
  85 /* The number of bytes allocated for FIELD_1_BUFFER.  */
  86 static size_t field_1_bufsize;
  87
  88 /* The largest field or byte index used as an endpoint of a closed
  89    or degenerate range specification;  this doesn't include the starting
  90    index of right-open-ended ranges.  For example, with either range spec
  91    `2-5,9-', `2-3,5,9-' this variable would be set to 5.  */
  92 static size_t max_range_endpoint;
  93
  94 /* If nonzero, this is the index of the first field in a range that goes
  95    to end of line. */
  96 static size_t eol_range_start;
  97
  98 /* This is a bit vector.
  99    In byte mode, which bytes to output.
 100    In field mode, which DELIM-separated fields to output.
 101    Both bytes and fields are numbered starting with 1,
 102    so the zeroth bit of this array is unused.
 103    A field or byte K has been selected if
 104    (K <= MAX_RANGE_ENDPOINT and is_printable_field(K))
 105     || (EOL_RANGE_START > 0 && K >= EOL_RANGE_START).  */
 106 static unsigned char *printable_field;
 107
 108 enum operating_mode
 109   {
 110     undefined_mode,
 111
 112     /* Output characters that are in the given bytes. */
 113     byte_mode,
 114
 115     /* Output the given delimeter-separated fields. */
 116     field_mode
 117   };
 118
 119 /* The name this program was run with. */
 120 char *program_name;
 121
 122 static enum operating_mode operating_mode;
 123
 124 /* If true do not output lines containing no delimeter characters.
 125    Otherwise, all such lines are printed.  This option is valid only
 126    with field mode.  */
 127 static bool suppress_non_delimited;
 128
 129 /* If nonzero, print all bytes, characters, or fields _except_
 130    those that were specified.  */
 131 static bool complement;
 132
 133 /* The delimeter character for field mode. */
 134 static unsigned char delim;
 135
 136 /* True if the --output-delimiter=STRING option was specified.  */
 137 static bool output_delimiter_specified;
 138
 139 /* The length of output_delimiter_string.  */
 140 static size_t output_delimiter_length;
 141
 142 /* The output field separator string.  Defaults to the 1-character
 143    string consisting of the input delimiter.  */
 144 static char *output_delimiter_string;
 145
 146 /* True if we have ever read standard input. */
 147 static bool have_read_stdin;
 148
 149 #define HT_RANGE_START_INDEX_INITIAL_CAPACITY 31
 150
 151 /* The set of range-start indices.  For example, given a range-spec list like
 152    `-b1,3-5,4-9,15-', the following indices will be recorded here: 1, 3, 15.
 153    Note that although `4' looks like a range-start index, it is in the middle
 154    of the `3-5' range, so it doesn't count.
 155    This table is created/used IFF output_delimiter_specified is set.  */
 156 static Hash_table *range_start_ht;
 157
 158 /* For long options that have no equivalent short option, use a
 159    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
 160 enum
 161 {
 162   OUTPUT_DELIMITER_OPTION = CHAR_MAX + 1,
 163   COMPLEMENT_OPTION
 164 };
 165
 166 static struct option const longopts[] =
 167 {
 168   {"bytes", required_argument, NULL, 'b'},
 169   {"characters", required_argument, NULL, 'c'},
 170   {"fields", required_argument, NULL, 'f'},
 171   {"delimiter", required_argument, NULL, 'd'},
 172   {"only-delimited", no_argument, NULL, 's'},
 173   {"output-delimiter", required_argument, NULL, OUTPUT_DELIMITER_OPTION},
 174   {"complement", no_argument, NULL, COMPLEMENT_OPTION},
 175   {GETOPT_HELP_OPTION_DECL},
 176   {GETOPT_VERSION_OPTION_DECL},
 177   {NULL, 0, NULL, 0}
 178 };
 179
 180 void
 181 usage (int status)
 182 {
 183   if (status != EXIT_SUCCESS)
 184     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 185              program_name);
 186   else
 187     {
 188       printf (_("\
 189 Usage: %s [OPTION]... [FILE]...\n\
 190 "),
 191               program_name);
 192       fputs (_("\
 193 Print selected parts of lines from each FILE to standard output.\n\
 194 \n\
 195 "), stdout);
 196       fputs (_("\
 197 Mandatory arguments to long options are mandatory for short options too.\n\
 198 "), stdout);
 199       fputs (_("\
 200   -b, --bytes=LIST        select only these bytes\n\
 201   -c, --characters=LIST   select only these characters\n\
 202   -d, --delimiter=DELIM   use DELIM instead of TAB for field delimiter\n\
 203 "), stdout);
 204       fputs (_("\
 205   -f, --fields=LIST       select only these fields;  also print any line\n\
 206                             that contains no delimiter character, unless\n\
 207                             the -s option is specified\n\
 208   -n                      (ignored)\n\
 209 "), stdout);
 210       fputs (_("\
 211       --complement        complement the set of selected bytes, characters\n\
 212                             or fields.\n\
 213 "), stdout);
 214       fputs (_("\
 215   -s, --only-delimited    do not print lines not containing delimiters\n\
 216       --output-delimiter=STRING  use STRING as the output delimiter\n\
 217                             the default is to use the input delimiter\n\
 218 "), stdout);
 219       fputs (HELP_OPTION_DESCRIPTION, stdout);
 220       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 221       fputs (_("\
 222 \n\
 223 Use one, and only one of -b, -c or -f.  Each LIST is made up of one\n\
 224 range, or many ranges separated by commas.  Selected input is written\n\
 225 in the same order that it is read, and is written exactly once.\n\
 226 "), stdout);
 227       fputs (_("\
 228 Each range is one of:\n\
 229 \n\
 230   N     N'th byte, character or field, counted from 1\n\
 231   N-    from N'th byte, character or field, to end of line\n\
 232   N-M   from N'th to M'th (included) byte, character or field\n\
 233   -M    from first to M'th (included) byte, character or field\n\
 234 \n\
 235 With no FILE, or when FILE is -, read standard input.\n\
 236 "), stdout);
 237       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
 238     }
 239   exit (status);
 240 }
 241
 242 static inline void
 243 mark_range_start (size_t i)
 244 {
 245   /* Record the fact that `i' is a range-start index.  */
 246   void *ent_from_table = hash_insert (range_start_ht, (void*) i);
 247   if (ent_from_table == NULL)
 248     {
 249       /* Insertion failed due to lack of memory.  */
 250       xalloc_die ();
 251     }
 252   assert ((size_t) ent_from_table == i);
 253 }
 254
 255 static inline void
 256 mark_printable_field (size_t i)
 257 {
 258   size_t n = i / CHAR_BIT;
 259   printable_field[n] |= (1 << (i % CHAR_BIT));
 260 }
 261
 262 static inline bool
 263 is_printable_field (size_t i)
 264 {
 265   size_t n = i / CHAR_BIT;
 266   return (printable_field[n] >> (i % CHAR_BIT)) & 1;
 267 }
 268
 269 static size_t
 270 hash_int (const void *x, size_t tablesize)
 271 {
 272 #ifdef UINTPTR_MAX
 273   uintptr_t y = (uintptr_t) x;
 274 #else
 275   size_t y = (size_t) x;
 276 #endif
 277   return y % tablesize;
 278 }
 279
 280 static bool
 281 hash_compare_ints (void const *x, void const *y)
 282 {
 283   return (x == y) ? true : false;
 284 }
 285
 286 static bool
 287 is_range_start_index (size_t i)
 288 {
 289   return hash_lookup (range_start_ht, (void *) i) ? true : false;
 290 }
 291
 292 /* Return nonzero if the K'th field or byte is printable.
 293    When returning nonzero, if RANGE_START is non-NULL,
 294    set *RANGE_START to true if K is the beginning of a range, and to
 295    false otherwise.  */
 296
 297 static bool
 298 print_kth (size_t k, bool *range_start)
 299 {
 300   bool k_selected
 301     = ((0 < eol_range_start && eol_range_start <= k)
 302        || (k <= max_range_endpoint && is_printable_field (k)));
 303
 304   bool is_selected = k_selected ^ complement;
 305   if (range_start && is_selected)
 306     *range_start = is_range_start_index (k);
 307
 308   return is_selected;
 309 }
 310
 311 /* Comparison function for qsort to order the list of
 312    struct range_pairs.  */
 313 static int
 314 compare_ranges (const void *a, const void *b)
 315 {
 316   int a_start = ((const struct range_pair *) a)->lo;
 317   int b_start = ((const struct range_pair *) b)->lo;
 318   return a_start < b_start ? -1 : a_start > b_start;
 319 }
 320
 321 /* Given the list of field or byte range specifications FIELDSTR, set
 322    MAX_RANGE_ENDPOINT and allocate and initialize the PRINTABLE_FIELD
 323    array.  If there is a right-open-ended range, set EOL_RANGE_START
 324    to its starting index.  FIELDSTR should be composed of one or more
 325    numbers or ranges of numbers, separated by blanks or commas.
 326    Incomplete ranges may be given: `-m' means `1-m'; `n-' means `n'
 327    through end of line.  Return true if FIELDSTR contains at least
 328    one field specification, false otherwise.  */
 329
 330 /* FIXME-someday:  What if the user wants to cut out the 1,000,000-th
 331    field of some huge input file?  This function shouldn't have to
 332    allocate a table of a million bits just so we can test every
 333    field < 10^6 with an array dereference.  Instead, consider using
 334    an adaptive approach: if the range of selected fields is too large,
 335    but only a few fields/byte-offsets are actually selected, use a
 336    hash table.  If the range of selected fields is too large, and
 337    too many are selected, then resort to using the range-pairs (the
 338    `rp' array) directly.  */
 339
 340 static bool
 341 set_fields (const char *fieldstr)
 342 {
 343   size_t initial = 1;           /* Value of first number in a range.  */
 344   size_t value = 0;             /* If nonzero, a number being accumulated.  */
 345   bool dash_found = false;      /* True if a '-' is found in this field.  */
 346   bool field_found = false;     /* True if at least one field spec
 347                                    has been processed.  */
 348
 349   struct range_pair *rp = NULL;
 350   size_t n_rp = 0;
 351   size_t n_rp_allocated = 0;
 352   size_t i;
 353   bool in_digits = false;
 354
 355   /* Collect and store in RP the range end points.
 356      It also sets EOL_RANGE_START if appropriate.  */
 357
 358   for (;;)
 359     {
 360       if (*fieldstr == '-')
 361         {
 362           in_digits = false;
 363           /* Starting a range. */
 364           if (dash_found)
 365             FATAL_ERROR (_("invalid byte or field list"));
 366           dash_found = true;
 367           fieldstr++;
 368
 369           if (value)
 370             {
 371               initial = value;
 372               value = 0;
 373             }
 374           else
 375             initial = 1;
 376         }
 377       else if (*fieldstr == ',' || isblank (*fieldstr) || *fieldstr == '\0')
 378         {
 379           in_digits = false;
 380           /* Ending the string, or this field/byte sublist. */
 381           if (dash_found)
 382             {
 383               dash_found = false;
 384
 385               /* A range.  Possibilites: -n, m-n, n-.
 386                  In any case, `initial' contains the start of the range. */
 387               if (value == 0)
 388                 {
 389                   /* `n-'.  From `initial' to end of line. */
 390                   eol_range_start = initial;
 391                   field_found = true;
 392                 }
 393               else
 394                 {
 395                   /* `m-n' or `-n' (1-n). */
 396                   if (value < initial)
 397                     FATAL_ERROR (_("invalid byte or field list"));
 398
 399                   /* Is there already a range going to end of line? */
 400                   if (eol_range_start != 0)
 401                     {
 402                       /* Yes.  Is the new sequence already contained
 403                          in the old one?  If so, no processing is
 404                          necessary. */
 405                       if (initial < eol_range_start)
 406                         {
 407                           /* No, the new sequence starts before the
 408                              old.  Does the old range going to end of line
 409                              extend into the new range?  */
 410                           if (eol_range_start <= value)
 411                             {
 412                               /* Yes.  Simply move the end of line marker. */
 413                               eol_range_start = initial;
 414                             }
 415                           else
 416                             {
 417                               /* No.  A simple range, before and disjoint from
 418                                  the range going to end of line.  Fill it. */
 419                               ADD_RANGE_PAIR (rp, initial, value);
 420                             }
 421
 422                           /* In any case, some fields were selected. */
 423                           field_found = true;
 424                         }
 425                     }
 426                   else
 427                     {
 428                       /* There is no range going to end of line. */
 429                       ADD_RANGE_PAIR (rp, initial, value);
 430                       field_found = true;
 431                     }
 432                   value = 0;
 433                 }
 434             }
 435           else if (value != 0)
 436             {
 437               /* A simple field number, not a range. */
 438               ADD_RANGE_PAIR (rp, value, value);
 439               value = 0;
 440               field_found = true;
 441             }
 442
 443           if (*fieldstr == '\0')
 444             {
 445               break;
 446             }
 447
 448           fieldstr++;
 449         }
 450       else if (ISDIGIT (*fieldstr))
 451         {
 452           /* Record beginning of digit string, in case we have to
 453              complain about it.  */
 454           static char const *num_start;
 455           if (!in_digits || !num_start)
 456             num_start = fieldstr;
 457           in_digits = true;
 458
 459           /* Detect overflow.  */
 460           if (!DECIMAL_DIGIT_ACCUMULATE (value, *fieldstr - '0', size_t))
 461             {
 462               /* In case the user specified -c4294967296,22,
 463                  complain only about the first number.  */
 464               /* Determine the length of the offending number.  */
 465               size_t len = strspn (num_start, "0123456789");
 466               char *bad_num = xstrndup (num_start, len);
 467               if (operating_mode == byte_mode)
 468                 error (0, 0,
 469                        _("byte offset %s is too large"), quote (bad_num));
 470               else
 471                 error (0, 0,
 472                        _("field number %s is too large"), quote (bad_num));
 473               free (bad_num);
 474               exit (EXIT_FAILURE);
 475             }
 476
 477           fieldstr++;
 478         }
 479       else
 480         FATAL_ERROR (_("invalid byte or field list"));
 481     }
 482
 483   max_range_endpoint = 0;
 484   for (i = 0; i < n_rp; i++)
 485     {
 486       if (rp[i].hi > max_range_endpoint)
 487         max_range_endpoint = rp[i].hi;
 488     }
 489
 490   /* Allocate an array large enough so that it may be indexed by
 491      the field numbers corresponding to all finite ranges
 492      (i.e. `2-6' or `-4', but not `5-') in FIELDSTR.  */
 493
 494   printable_field = xzalloc (max_range_endpoint / CHAR_BIT + 1);
 495
 496   qsort (rp, n_rp, sizeof (rp[0]), compare_ranges);
 497
 498   /* Set the array entries corresponding to integers in the ranges of RP.  */
 499   for (i = 0; i < n_rp; i++)
 500     {
 501       size_t j;
 502       size_t rsi_candidate;
 503
 504       /* Record the range-start indices, i.e., record each start
 505          index that is not part of any other (lo..hi] range.  */
 506       rsi_candidate = complement ? rp[i].hi + 1 : rp[i].lo;
 507       if (output_delimiter_specified
 508           && !is_printable_field (rsi_candidate))
 509         mark_range_start (rsi_candidate);
 510
 511       for (j = rp[i].lo; j <= rp[i].hi; j++)
 512         mark_printable_field (j);
 513     }
 514
 515   if (output_delimiter_specified
 516       && !complement
 517       && eol_range_start && !is_printable_field (eol_range_start))
 518     mark_range_start (eol_range_start);
 519
 520   free (rp);
 521
 522   return field_found;
 523 }
 524
 525 /* Read from stream STREAM, printing to standard output any selected bytes.  */
 526
 527 static void
 528 cut_bytes (FILE *stream)
 529 {
 530   size_t byte_idx;      /* Number of bytes in the line so far. */
 531   /* Whether to begin printing delimiters between ranges for the current line.
 532      Set after we've begun printing data corresponding to the first range.  */
 533   bool print_delimiter;
 534
 535   byte_idx = 0;
 536   print_delimiter = false;
 537   while (1)
 538     {
 539       int c;            /* Each character from the file. */
 540
 541       c = getc (stream);
 542
 543       if (c == '\n')
 544         {
 545           putchar ('\n');
 546           byte_idx = 0;
 547           print_delimiter = false;
 548         }
 549       else if (c == EOF)
 550         {
 551           if (byte_idx > 0)
 552             putchar ('\n');
 553           break;
 554         }
 555       else
 556         {
 557           bool range_start;
 558           bool *rs = output_delimiter_specified ? &range_start : NULL;
 559           if (print_kth (++byte_idx, rs))
 560             {
 561               if (rs && *rs && print_delimiter)
 562                 {
 563                   fwrite (output_delimiter_string, sizeof (char),
 564                           output_delimiter_length, stdout);
 565                 }
 566               print_delimiter = true;
 567               putchar (c);
 568             }
 569         }
 570     }
 571 }
 572
 573 /* Read from stream STREAM, printing to standard output any selected fields.  */
 574
 575 static void
 576 cut_fields (FILE *stream)
 577 {
 578   int c;
 579   size_t field_idx = 1;
 580   bool found_any_selected_field = false;
 581   bool buffer_first_field;
 582
 583   c = getc (stream);
 584   if (c == EOF)
 585     return;
 586
 587   ungetc (c, stream);
 588
 589   /* To support the semantics of the -s flag, we may have to buffer
 590      all of the first field to determine whether it is `delimited.'
 591      But that is unnecessary if all non-delimited lines must be printed
 592      and the first field has been selected, or if non-delimited lines
 593      must be suppressed and the first field has *not* been selected.
 594      That is because a non-delimited line has exactly one field.  */
 595   buffer_first_field = (suppress_non_delimited ^ !print_kth (1, NULL));
 596
 597   while (1)
 598     {
 599       if (field_idx == 1 && buffer_first_field)
 600         {
 601           ssize_t len;
 602           size_t n_bytes;
 603
 604           len = getndelim2 (&field_1_buffer, &field_1_bufsize, 0,
 605                             GETNLINE_NO_LIMIT, delim, '\n', stream);
 606           if (len < 0)
 607             {
 608               free (field_1_buffer);
 609               if (ferror (stream) || feof (stream))
 610                 break;
 611               xalloc_die ();
 612             }
 613
 614           n_bytes = len;
 615           assert (n_bytes != 0);
 616
 617           /* If the first field extends to the end of line (it is not
 618              delimited) and we are printing all non-delimited lines,
 619              print this one.  */
 620           if (to_uchar (field_1_buffer[n_bytes - 1]) != delim)
 621             {
 622               if (suppress_non_delimited)
 623                 {
 624                   /* Empty.  */
 625                 }
 626               else
 627                 {
 628                   fwrite (field_1_buffer, sizeof (char), n_bytes, stdout);
 629                   /* Make sure the output line is newline terminated.  */
 630                   if (field_1_buffer[n_bytes - 1] != '\n')
 631                     putchar ('\n');
 632                 }
 633               continue;
 634             }
 635           if (print_kth (1, NULL))
 636             {
 637               /* Print the field, but not the trailing delimiter.  */
 638               fwrite (field_1_buffer, sizeof (char), n_bytes - 1, stdout);
 639               found_any_selected_field = true;
 640             }
 641           ++field_idx;
 642         }
 643
 644       if (c != EOF)
 645         {
 646           if (print_kth (field_idx, NULL))
 647             {
 648               if (found_any_selected_field)
 649                 {
 650                   fwrite (output_delimiter_string, sizeof (char),
 651                           output_delimiter_length, stdout);
 652                 }
 653               found_any_selected_field = true;
 654
 655               while ((c = getc (stream)) != delim && c != '\n' && c != EOF)
 656                 {
 657                   putchar (c);
 658                 }
 659             }
 660           else
 661             {
 662               while ((c = getc (stream)) != delim && c != '\n' && c != EOF)
 663                 {
 664                   /* Empty.  */
 665                 }
 666             }
 667         }
 668
 669       if (c == '\n')
 670         {
 671           c = getc (stream);
 672           if (c != EOF)
 673             {
 674               ungetc (c, stream);
 675               c = '\n';
 676             }
 677         }
 678
 679       if (c == delim)
 680         ++field_idx;
 681       else if (c == '\n' || c == EOF)
 682         {
 683           if (found_any_selected_field
 684               || !(suppress_non_delimited && field_idx == 1))
 685             putchar ('\n');
 686           if (c == EOF)
 687             break;
 688           field_idx = 1;
 689           found_any_selected_field = false;
 690         }
 691     }
 692 }
 693
 694 static void
 695 cut_stream (FILE *stream)
 696 {
 697   if (operating_mode == byte_mode)
 698     cut_bytes (stream);
 699   else
 700     cut_fields (stream);
 701 }
 702
 703 /* Process file FILE to standard output.
 704    Return true if successful.  */
 705
 706 static bool
 707 cut_file (char const *file)
 708 {
 709   FILE *stream;
 710
 711   if (STREQ (file, "-"))
 712     {
 713       have_read_stdin = true;
 714       stream = stdin;
 715     }
 716   else
 717     {
 718       stream = fopen (file, "r");
 719       if (stream == NULL)
 720         {
 721           error (0, errno, "%s", file);
 722           return false;
 723         }
 724     }
 725
 726   cut_stream (stream);
 727
 728   if (ferror (stream))
 729     {
 730       error (0, errno, "%s", file);
 731       return false;
 732     }
 733   if (STREQ (file, "-"))
 734     clearerr (stream);          /* Also clear EOF. */
 735   else if (fclose (stream) == EOF)
 736     {
 737       error (0, errno, "%s", file);
 738       return false;
 739     }
 740   return true;
 741 }
 742
 743 int
 744 main (int argc, char **argv)
 745 {
 746   int optc;
 747   bool ok;
 748   bool delim_specified = false;
 749   char *spec_list_string IF_LINT(= NULL);
 750
 751   initialize_main (&argc, &argv);
 752   program_name = argv[0];
 753   setlocale (LC_ALL, "");
 754   bindtextdomain (PACKAGE, LOCALEDIR);
 755   textdomain (PACKAGE);
 756
 757   atexit (close_stdout);
 758
 759   operating_mode = undefined_mode;
 760
 761   /* By default, all non-delimited lines are printed.  */
 762   suppress_non_delimited = false;
 763
 764   delim = '\0';
 765   have_read_stdin = false;
 766
 767   while ((optc = getopt_long (argc, argv, "b:c:d:f:ns", longopts, NULL)) != -1)
 768     {
 769       switch (optc)
 770         {
 771         case 'b':
 772         case 'c':
 773           /* Build the byte list. */
 774           if (operating_mode != undefined_mode)
 775             FATAL_ERROR (_("only one type of list may be specified"));
 776           operating_mode = byte_mode;
 777           spec_list_string = optarg;
 778           break;
 779
 780         case 'f':
 781           /* Build the field list. */
 782           if (operating_mode != undefined_mode)
 783             FATAL_ERROR (_("only one type of list may be specified"));
 784           operating_mode = field_mode;
 785           spec_list_string = optarg;
 786           break;
 787
 788         case 'd':
 789           /* New delimiter. */
 790           /* Interpret -d '' to mean `use the NUL byte as the delimiter.'  */
 791           if (optarg[0] != '\0' && optarg[1] != '\0')
 792             FATAL_ERROR (_("the delimiter must be a single character"));
 793           delim = optarg[0];
 794           delim_specified = true;
 795           break;
 796
 797         case OUTPUT_DELIMITER_OPTION:
 798           output_delimiter_specified = true;
 799           /* Interpret --output-delimiter='' to mean
 800              `use the NUL byte as the delimiter.'  */
 801           output_delimiter_length = (optarg[0] == '\0'
 802                                      ? 1 : strlen (optarg));
 803           output_delimiter_string = xstrdup (optarg);
 804           break;
 805
 806         case 'n':
 807           break;
 808
 809         case 's':
 810           suppress_non_delimited = true;
 811           break;
 812
 813         case COMPLEMENT_OPTION:
 814           complement = true;
 815           break;
 816
 817         case_GETOPT_HELP_CHAR;
 818
 819         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 820
 821         default:
 822           usage (EXIT_FAILURE);
 823         }
 824     }
 825
 826   if (operating_mode == undefined_mode)
 827     FATAL_ERROR (_("you must specify a list of bytes, characters, or fields"));
 828
 829   if (delim != '\0' && operating_mode != field_mode)
 830     FATAL_ERROR (_("an input delimiter may be specified only\
 831  when operating on fields"));
 832
 833   if (suppress_non_delimited && operating_mode != field_mode)
 834     FATAL_ERROR (_("suppressing non-delimited lines makes sense\n\
 835 \tonly when operating on fields"));
 836
 837   if (output_delimiter_specified)
 838     {
 839       range_start_ht = hash_initialize (HT_RANGE_START_INDEX_INITIAL_CAPACITY,
 840                                         NULL, hash_int,
 841                                         hash_compare_ints, NULL);
 842       if (range_start_ht == NULL)
 843         xalloc_die ();
 844
 845     }
 846
 847   if (! set_fields (spec_list_string))
 848     {
 849       if (operating_mode == field_mode)
 850         FATAL_ERROR (_("missing list of fields"));
 851       else
 852         FATAL_ERROR (_("missing list of positions"));
 853     }
 854
 855   if (!delim_specified)
 856     delim = '\t';
 857
 858   if (output_delimiter_string == NULL)
 859     {
 860       static char dummy[2];
 861       dummy[0] = delim;
 862       dummy[1] = '\0';
 863       output_delimiter_string = dummy;
 864       output_delimiter_length = 1;
 865     }
 866
 867   if (optind == argc)
 868     ok = cut_file ("-");
 869   else
 870     for (ok = true; optind < argc; optind++)
 871       ok &= cut_file (argv[optind]);
 872
 873   if (range_start_ht)
 874     hash_free (range_start_ht);
 875
 876   if (have_read_stdin && fclose (stdin) == EOF)
 877     {
 878       error (0, errno, "-");
 879       ok = false;
 880     }
 881
 882   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 883 }