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               field_1_buffer = NULL;
 610               if (ferror (stream) || feof (stream))
 611                 break;
 612               xalloc_die ();
 613             }
 614
 615           n_bytes = len;
 616           assert (n_bytes != 0);
 617
 618           /* If the first field extends to the end of line (it is not
 619              delimited) and we are printing all non-delimited lines,
 620              print this one.  */
 621           if (to_uchar (field_1_buffer[n_bytes - 1]) != delim)
 622             {
 623               if (suppress_non_delimited)
 624                 {
 625                   /* Empty.  */
 626                 }
 627               else
 628                 {
 629                   fwrite (field_1_buffer, sizeof (char), n_bytes, stdout);
 630                   /* Make sure the output line is newline terminated.  */
 631                   if (field_1_buffer[n_bytes - 1] != '\n')
 632                     putchar ('\n');
 633                 }
 634               continue;
 635             }
 636           if (print_kth (1, NULL))
 637             {
 638               /* Print the field, but not the trailing delimiter.  */
 639               fwrite (field_1_buffer, sizeof (char), n_bytes - 1, stdout);
 640               found_any_selected_field = true;
 641             }
 642           ++field_idx;
 643         }
 644
 645       if (c != EOF)
 646         {
 647           if (print_kth (field_idx, NULL))
 648             {
 649               if (found_any_selected_field)
 650                 {
 651                   fwrite (output_delimiter_string, sizeof (char),
 652                           output_delimiter_length, stdout);
 653                 }
 654               found_any_selected_field = true;
 655
 656               while ((c = getc (stream)) != delim && c != '\n' && c != EOF)
 657                 {
 658                   putchar (c);
 659                 }
 660             }
 661           else
 662             {
 663               while ((c = getc (stream)) != delim && c != '\n' && c != EOF)
 664                 {
 665                   /* Empty.  */
 666                 }
 667             }
 668         }
 669
 670       if (c == '\n')
 671         {
 672           c = getc (stream);
 673           if (c != EOF)
 674             {
 675               ungetc (c, stream);
 676               c = '\n';
 677             }
 678         }
 679
 680       if (c == delim)
 681         ++field_idx;
 682       else if (c == '\n' || c == EOF)
 683         {
 684           if (found_any_selected_field
 685               || !(suppress_non_delimited && field_idx == 1))
 686             putchar ('\n');
 687           if (c == EOF)
 688             break;
 689           field_idx = 1;
 690           found_any_selected_field = false;
 691         }
 692     }
 693 }
 694
 695 static void
 696 cut_stream (FILE *stream)
 697 {
 698   if (operating_mode == byte_mode)
 699     cut_bytes (stream);
 700   else
 701     cut_fields (stream);
 702 }
 703
 704 /* Process file FILE to standard output.
 705    Return true if successful.  */
 706
 707 static bool
 708 cut_file (char const *file)
 709 {
 710   FILE *stream;
 711
 712   if (STREQ (file, "-"))
 713     {
 714       have_read_stdin = true;
 715       stream = stdin;
 716     }
 717   else
 718     {
 719       stream = fopen (file, "r");
 720       if (stream == NULL)
 721         {
 722           error (0, errno, "%s", file);
 723           return false;
 724         }
 725     }
 726
 727   cut_stream (stream);
 728
 729   if (ferror (stream))
 730     {
 731       error (0, errno, "%s", file);
 732       return false;
 733     }
 734   if (STREQ (file, "-"))
 735     clearerr (stream);          /* Also clear EOF. */
 736   else if (fclose (stream) == EOF)
 737     {
 738       error (0, errno, "%s", file);
 739       return false;
 740     }
 741   return true;
 742 }
 743
 744 int
 745 main (int argc, char **argv)
 746 {
 747   int optc;
 748   bool ok;
 749   bool delim_specified = false;
 750   char *spec_list_string IF_LINT(= NULL);
 751
 752   initialize_main (&argc, &argv);
 753   program_name = argv[0];
 754   setlocale (LC_ALL, "");
 755   bindtextdomain (PACKAGE, LOCALEDIR);
 756   textdomain (PACKAGE);
 757
 758   atexit (close_stdout);
 759
 760   operating_mode = undefined_mode;
 761
 762   /* By default, all non-delimited lines are printed.  */
 763   suppress_non_delimited = false;
 764
 765   delim = '\0';
 766   have_read_stdin = false;
 767
 768   while ((optc = getopt_long (argc, argv, "b:c:d:f:ns", longopts, NULL)) != -1)
 769     {
 770       switch (optc)
 771         {
 772         case 'b':
 773         case 'c':
 774           /* Build the byte list. */
 775           if (operating_mode != undefined_mode)
 776             FATAL_ERROR (_("only one type of list may be specified"));
 777           operating_mode = byte_mode;
 778           spec_list_string = optarg;
 779           break;
 780
 781         case 'f':
 782           /* Build the field list. */
 783           if (operating_mode != undefined_mode)
 784             FATAL_ERROR (_("only one type of list may be specified"));
 785           operating_mode = field_mode;
 786           spec_list_string = optarg;
 787           break;
 788
 789         case 'd':
 790           /* New delimiter. */
 791           /* Interpret -d '' to mean `use the NUL byte as the delimiter.'  */
 792           if (optarg[0] != '\0' && optarg[1] != '\0')
 793             FATAL_ERROR (_("the delimiter must be a single character"));
 794           delim = optarg[0];
 795           delim_specified = true;
 796           break;
 797
 798         case OUTPUT_DELIMITER_OPTION:
 799           output_delimiter_specified = true;
 800           /* Interpret --output-delimiter='' to mean
 801              `use the NUL byte as the delimiter.'  */
 802           output_delimiter_length = (optarg[0] == '\0'
 803                                      ? 1 : strlen (optarg));
 804           output_delimiter_string = xstrdup (optarg);
 805           break;
 806
 807         case 'n':
 808           break;
 809
 810         case 's':
 811           suppress_non_delimited = true;
 812           break;
 813
 814         case COMPLEMENT_OPTION:
 815           complement = true;
 816           break;
 817
 818         case_GETOPT_HELP_CHAR;
 819
 820         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 821
 822         default:
 823           usage (EXIT_FAILURE);
 824         }
 825     }
 826
 827   if (operating_mode == undefined_mode)
 828     FATAL_ERROR (_("you must specify a list of bytes, characters, or fields"));
 829
 830   if (delim != '\0' && operating_mode != field_mode)
 831     FATAL_ERROR (_("an input delimiter may be specified only\
 832  when operating on fields"));
 833
 834   if (suppress_non_delimited && operating_mode != field_mode)
 835     FATAL_ERROR (_("suppressing non-delimited lines makes sense\n\
 836 \tonly when operating on fields"));
 837
 838   if (output_delimiter_specified)
 839     {
 840       range_start_ht = hash_initialize (HT_RANGE_START_INDEX_INITIAL_CAPACITY,
 841                                         NULL, hash_int,
 842                                         hash_compare_ints, NULL);
 843       if (range_start_ht == NULL)
 844         xalloc_die ();
 845
 846     }
 847
 848   if (! set_fields (spec_list_string))
 849     {
 850       if (operating_mode == field_mode)
 851         FATAL_ERROR (_("missing list of fields"));
 852       else
 853         FATAL_ERROR (_("missing list of positions"));
 854     }
 855
 856   if (!delim_specified)
 857     delim = '\t';
 858
 859   if (output_delimiter_string == NULL)
 860     {
 861       static char dummy[2];
 862       dummy[0] = delim;
 863       dummy[1] = '\0';
 864       output_delimiter_string = dummy;
 865       output_delimiter_length = 1;
 866     }
 867
 868   if (optind == argc)
 869     ok = cut_file ("-");
 870   else
 871     for (ok = true; optind < argc; optind++)
 872       ok &= cut_file (argv[optind]);
 873
 874   if (range_start_ht)
 875     hash_free (range_start_ht);
 876
 877   if (have_read_stdin && fclose (stdin) == EOF)
 878     {
 879       error (0, errno, "-");
 880       ok = false;
 881     }
 882
 883   exit (ok ? EXIT_SUCCESS : EXIT_FAILURE);
 884 }