src/cut.c

   1 /* cut - remove parts of lines of files
   2    Copyright (C) 1984 by David M. Ihnat
   3
   4    This program is a total rewrite of the Bell Laboratories Unix(Tm)
   5    command of the same name, as of System V.  It contains no proprietary
   6    code, and therefore may be used without violation of any proprietary
   7    agreements whatsoever.  However, you will notice that the program is
   8    copyrighted by me.  This is to assure the program does *not* fall
   9    into the public domain.  Thus, I may specify just what I am now:
  10    This program may be freely copied and distributed, provided this notice
  11    remains; it may not be sold for profit without express written consent of
  12    the author.
  13    Please note that I recreated the behavior of the Unix(Tm) 'cut' command
  14    as faithfully as possible; however, I haven't run a full set of regression
  15    tests.  Thus, the user of this program accepts full responsibility for any
  16    effects or loss; in particular, the author is not responsible for any losses,
  17    explicit or incidental, that may be incurred through use of this program.
  18
  19    I ask that any bugs (and, if possible, fixes) be reported to me when
  20    possible.  -David Ihnat (312) 784-4544 ignatz@homebru.chi.il.us
  21
  22    POSIX changes, bug fixes, long-named options, and cleanup
  23    by David MacKenzie <djm@gnu.ai.mit.edu>.
  24
  25    Rewrite cut_fields and cut_bytes -- Jim Meyering (meyering@comco.com).
  26
  27    Options:
  28    --bytes=byte-list
  29    -b byte-list                 Print only the bytes in positions listed
  30                                 in BYTE-LIST.
  31                                 Tabs and backspaces are treated like any
  32                                 other character; they take up 1 byte.
  33
  34    --characters=character-list
  35    -c character-list            Print only characters in positions listed
  36                                 in CHARACTER-LIST.
  37                                 The same as -b for now, but
  38                                 internationalization will change that.
  39                                 Tabs and backspaces are treated like any
  40                                 other character; they take up 1 character.
  41
  42    --fields=field-list
  43    -f field-list                Print only the fields listed in FIELD-LIST.
  44                                 Fields are separated by a TAB by default.
  45
  46    --delimiter=delim
  47    -d delim                     For -f, fields are separated by the first
  48                                 character in DELIM instead of TAB.
  49
  50    -n                           Do not split multibyte chars (no-op for now).
  51
  52    --only-delimited
  53    -s                           For -f, do not print lines that do not contain
  54                                 the field separator character.
  55
  56    The BYTE-LIST, CHARACTER-LIST, and FIELD-LIST are one or more numbers
  57    or ranges separated by commas.  The first byte, character, and field
  58    are numbered 1.
  59
  60    A FILE of `-' means standard input. */
  61
  62 #include <config.h>
  63
  64 /* Get isblank from GNU libc.  */
  65 #define _GNU_SOURCE
  66
  67 #include <stdio.h>
  68
  69 #define NDEBUG
  70 #include <assert.h>
  71
  72 #include <getopt.h>
  73 #include <sys/types.h>
  74 #include "system.h"
  75 #include "error.h"
  76
  77 #define FATAL_ERROR(s)                                                  \
  78   do                                                                    \
  79     {                                                                   \
  80       error (0, 0, (s));                                                \
  81       usage (2);                                                        \
  82     }                                                                   \
  83   while (0)
  84
  85 /* Append LOW, HIGH to the list RP of range pairs, allocating additional
  86    space if necessary.  Update local variable N_RP.  When allocating,
  87    update global variable N_RP_ALLOCATED.  */
  88
  89 #define ADD_RANGE_PAIR(rp, low, high)                                   \
  90   do                                                                    \
  91     {                                                                   \
  92       if (n_rp >= n_rp_allocated)                                       \
  93         {                                                               \
  94           n_rp_allocated *= 2;                                          \
  95           (rp) = (struct range_pair *) xrealloc ((rp),                  \
  96                                    n_rp_allocated * sizeof (*(rp)));    \
  97         }                                                               \
  98       rp[n_rp].lo = (low);                                              \
  99       rp[n_rp].hi = (high);                                             \
 100       ++n_rp;                                                           \
 101     }                                                                   \
 102   while (0)
 103
 104 struct range_pair
 105   {
 106     unsigned int lo;
 107     unsigned int hi;
 108   };
 109
 110 char *xmalloc ();
 111 char *xrealloc ();
 112
 113 /* This buffer is used to support the semantics of the -s option
 114    (or lack of same) when the specified field list includes (does
 115    not include) the first field.  In both of those cases, the entire
 116    first field must be read into this buffer to determine whether it
 117    is followed by a delimiter or a newline before any of it may be
 118    output.  Otherwise, cut_fields can do the job without using this
 119    buffer.  */
 120 static char *field_1_buffer;
 121
 122 /* The number of bytes allocated for FIELD_1_BUFFER.  */
 123 static int field_1_bufsize;
 124
 125 /* The largest field or byte index used as an endpoint of a closed
 126    or degenerate range specification;  this doesn't include the starting
 127    index of right-open-ended ranges.  For example, with either range spec
 128    `2-5,9-', `2-3,5,9-' this variable would be set to 5.  */
 129 static unsigned int max_range_endpoint;
 130
 131 /* If nonzero, this is the index of the first field in a range that goes
 132    to end of line. */
 133 static unsigned int eol_range_start;
 134
 135 /* In byte mode, which bytes to output.
 136    In field mode, which DELIM-separated fields to output.
 137    Both bytes and fields are numbered starting with 1,
 138    so the zeroth element of this array is unused.
 139    A field or byte K has been selected if
 140    (K <= MAX_RANGE_ENDPOINT and PRINTABLE_FIELD[K])
 141     || (EOL_RANGE_START > 0 && K >= EOL_RANGE_START).  */
 142 static int *printable_field;
 143
 144 enum operating_mode
 145   {
 146     undefined_mode,
 147
 148     /* Output characters that are in the given bytes. */
 149     byte_mode,
 150
 151     /* Output the given delimeter-separated fields. */
 152     field_mode
 153   };
 154
 155 /* The name this program was run with. */
 156 char *program_name;
 157
 158 static enum operating_mode operating_mode;
 159
 160 /* If nonzero do not output lines containing no delimeter characters.
 161    Otherwise, all such lines are printed.  This option is valid only
 162    with field mode.  */
 163 static int suppress_non_delimited;
 164
 165 /* The delimeter character for field mode. */
 166 static int delim;
 167
 168 /* Nonzero if we have ever read standard input. */
 169 static int have_read_stdin;
 170
 171 /* If nonzero, display usage information and exit.  */
 172 static int show_help;
 173
 174 /* If nonzero, print the version on standard output then exit.  */
 175 static int show_version;
 176
 177 static struct option const longopts[] =
 178 {
 179   {"bytes", required_argument, 0, 'b'},
 180   {"characters", required_argument, 0, 'c'},
 181   {"fields", required_argument, 0, 'f'},
 182   {"delimiter", required_argument, 0, 'd'},
 183   {"only-delimited", no_argument, 0, 's'},
 184   {"help", no_argument, &show_help, 1},
 185   {"version", no_argument, &show_version, 1},
 186   {0, 0, 0, 0}
 187 };
 188
 189 static void
 190 usage (int status)
 191 {
 192   if (status != 0)
 193     fprintf (stderr, _("Try `%s --help' for more information.\n"),
 194              program_name);
 195   else
 196     {
 197       printf (_("\
 198 Usage: %s [OPTION]... [FILE]...\n\
 199 "),
 200               program_name);
 201       printf (_("\
 202 Print selected parts of lines from each FILE to standard output.\n\
 203 \n\
 204   -b, --bytes=LIST        output only these bytes\n\
 205   -c, --characters=LIST   output only these characters\n\
 206   -d, --delimiter=DELIM   use DELIM instead of TAB for field delimiter\n\
 207   -f, --fields=LIST       output only these fields\n\
 208   -n                      (ignored)\n\
 209   -s, --only-delimited    do not print lines not containing delimiters\n\
 210       --help              display this help and exit\n\
 211       --version           output version information and exit\n\
 212 \n\
 213 Use one, and only one of -b, -c or -f.  Each LIST is made up of one\n\
 214 range, or many ranges separated by commas.  Each range is one of:\n\
 215 \n\
 216   N     N'th byte, character or field, counted from 1\n\
 217   N-    from N'th byte, character or field, to end of line\n\
 218   N-M   from N'th to M'th (included) byte, character or field\n\
 219   -M    from first to M'th (included) byte, character or field\n\
 220 \n\
 221 With no FILE, or when FILE is -, read standard input.\n\
 222 "));
 223     }
 224   exit (status);
 225 }
 226
 227 /* The following function was copied from getline.c, but with these changes:
 228    - Read up to and including a newline or TERMINATOR, whichever comes first.
 229    The original does not treat newline specially.
 230    - Remove unused argument, OFFSET.
 231    - Use xmalloc and xrealloc instead of malloc and realloc.
 232    - Declare this function static.  */
 233
 234 /* Always add at least this many bytes when extending the buffer.  */
 235 #define MIN_CHUNK 64
 236
 237 /* Read up to (and including) a newline or TERMINATOR from STREAM into
 238    *LINEPTR (and null-terminate it). *LINEPTR is a pointer returned from
 239    xmalloc (or NULL), pointing to *N characters of space.  It is
 240    xrealloc'd as necessary.  Return the number of characters read (not
 241    including the null terminator), or -1 on error or EOF.  */
 242
 243 static int
 244 getstr (char **lineptr, int *n, FILE *stream, char terminator)
 245 {
 246   int nchars_avail;             /* Allocated but unused chars in *LINEPTR.  */
 247   char *read_pos;               /* Where we're reading into *LINEPTR. */
 248
 249   if (!lineptr || !n || !stream)
 250     return -1;
 251
 252   if (!*lineptr)
 253     {
 254       *n = MIN_CHUNK;
 255       *lineptr = xmalloc (*n);
 256       if (!*lineptr)
 257         return -1;
 258     }
 259
 260   nchars_avail = *n;
 261   read_pos = *lineptr;
 262
 263   for (;;)
 264     {
 265       register int c = getc (stream);
 266
 267       /* We always want at least one char left in the buffer, since we
 268          always (unless we get an error while reading the first char)
 269          NUL-terminate the line buffer.  */
 270
 271       assert (*n - nchars_avail == read_pos - *lineptr);
 272       if (nchars_avail < 1)
 273         {
 274           if (*n > MIN_CHUNK)
 275             *n *= 2;
 276           else
 277             *n += MIN_CHUNK;
 278
 279           nchars_avail = *n + *lineptr - read_pos;
 280           *lineptr = xrealloc (*lineptr, *n);
 281           if (!*lineptr)
 282             return -1;
 283           read_pos = *n - nchars_avail + *lineptr;
 284           assert (*n - nchars_avail == read_pos - *lineptr);
 285         }
 286
 287       if (feof (stream) || ferror (stream))
 288         {
 289           /* Return partial line, if any.  */
 290           if (read_pos == *lineptr)
 291             return -1;
 292           else
 293             break;
 294         }
 295
 296       *read_pos++ = c;
 297       nchars_avail--;
 298
 299       if (c == terminator || c == '\n')
 300         /* Return the line.  */
 301         break;
 302     }
 303
 304   /* Done - NUL terminate and return the number of chars read.  */
 305   *read_pos = '\0';
 306
 307   return read_pos - *lineptr;
 308 }
 309
 310 static int
 311 print_kth (unsigned int k)
 312 {
 313   return ((0 < eol_range_start && eol_range_start <= k)
 314           || (k <= max_range_endpoint && printable_field[k]));
 315 }
 316
 317 /* Given the list of field or byte range specifications FIELDSTR, set
 318    MAX_RANGE_ENDPOINT and allocate and initialize the PRINTABLE_FIELD
 319    array.  If there is a right-open-ended range, set EOL_RANGE_START
 320    to its starting index.  FIELDSTR should be composed of one or more
 321    numbers or ranges of numbers, separated by blanks or commas.
 322    Incomplete ranges may be given: `-m' means `1-m'; `n-' means `n'
 323    through end of line.  Return nonzero if FIELDSTR contains at least
 324    one field specification, zero otherwise.  */
 325
 326 /* FIXME-someday:  What if the user wants to cut out the 1,000,000-th field
 327    of some huge input file?  This function shouldn't have to alloate a table
 328    of a million ints just so we can test every field < 10^6 with an array
 329    dereference.  Instead, consider using a dynamic hash table.  It would be
 330    simpler and nearly as good a solution to use a 32K x 4-byte table with
 331    one bit per field index instead of a whole `int' per index.  */
 332
 333 static int
 334 set_fields (const char *fieldstr)
 335 {
 336   unsigned int initial = 1;     /* Value of first number in a range.  */
 337   unsigned int value = 0;       /* If nonzero, a number being accumulated.  */
 338   int dash_found = 0;           /* Nonzero if a '-' is found in this field.  */
 339   int field_found = 0;          /* Non-zero if at least one field spec
 340                                    has been processed.  */
 341
 342   struct range_pair *rp;
 343   unsigned int n_rp;
 344   unsigned int n_rp_allocated;
 345   unsigned int i;
 346
 347   n_rp = 0;
 348   n_rp_allocated = 16;
 349   rp = (struct range_pair *) xmalloc (n_rp_allocated * sizeof (*rp));
 350
 351   /* Collect and store in RP the range end points.
 352      It also sets EOL_RANGE_START if appropriate.  */
 353
 354   for (;;)
 355     {
 356       if (*fieldstr == '-')
 357         {
 358           /* Starting a range. */
 359           if (dash_found)
 360             FATAL_ERROR (_("invalid byte or field list"));
 361           dash_found++;
 362           fieldstr++;
 363
 364           if (value)
 365             {
 366               initial = value;
 367               value = 0;
 368             }
 369           else
 370             initial = 1;
 371         }
 372       else if (*fieldstr == ',' || ISBLANK (*fieldstr) || *fieldstr == '\0')
 373         {
 374           /* Ending the string, or this field/byte sublist. */
 375           if (dash_found)
 376             {
 377               dash_found = 0;
 378
 379               /* A range.  Possibilites: -n, m-n, n-.
 380                  In any case, `initial' contains the start of the range. */
 381               if (value == 0)
 382                 {
 383                   /* `n-'.  From `initial' to end of line. */
 384                   eol_range_start = initial;
 385                   field_found = 1;
 386                 }
 387               else
 388                 {
 389                   /* `m-n' or `-n' (1-n). */
 390                   if (value < initial)
 391                     FATAL_ERROR (_("invalid byte or field list"));
 392
 393                   /* Is there already a range going to end of line? */
 394                   if (eol_range_start != 0)
 395                     {
 396                       /* Yes.  Is the new sequence already contained
 397                          in the old one?  If so, no processing is
 398                          necessary. */
 399                       if (initial < eol_range_start)
 400                         {
 401                           /* No, the new sequence starts before the
 402                              old.  Does the old range going to end of line
 403                              extend into the new range?  */
 404                           if (value + 1 >= eol_range_start)
 405                             {
 406                               /* Yes.  Simply move the end of line marker. */
 407                               eol_range_start = initial;
 408                             }
 409                           else
 410                             {
 411                               /* No.  A simple range, before and disjoint from
 412                                  the range going to end of line.  Fill it. */
 413                               ADD_RANGE_PAIR (rp, initial, value);
 414                             }
 415
 416                           /* In any case, some fields were selected. */
 417                           field_found = 1;
 418                         }
 419                     }
 420                   else
 421                     {
 422                       /* There is no range going to end of line. */
 423                       ADD_RANGE_PAIR (rp, initial, value);
 424                       field_found = 1;
 425                     }
 426                   value = 0;
 427                 }
 428             }
 429           else if (value != 0)
 430             {
 431               /* A simple field number, not a range. */
 432               ADD_RANGE_PAIR (rp, value, value);
 433               value = 0;
 434               field_found = 1;
 435             }
 436
 437           if (*fieldstr == '\0')
 438             {
 439               break;
 440             }
 441
 442           fieldstr++;
 443         }
 444       else if (ISDIGIT (*fieldstr))
 445         {
 446           /* FIXME: detect overflow?  */
 447           value = 10 * value + *fieldstr - '0';
 448           fieldstr++;
 449         }
 450       else
 451         FATAL_ERROR (_("invalid byte or field list"));
 452     }
 453
 454   max_range_endpoint = 0;
 455   for (i = 0; i < n_rp; i++)
 456     {
 457       if (rp[i].hi > max_range_endpoint)
 458         max_range_endpoint = rp[i].hi;
 459     }
 460
 461   /* Allocate an array large enough so that it may be indexed by
 462      the field numbers corresponding to all finite ranges
 463      (i.e. `2-6' or `-4', but not `5-') in FIELDSTR.  */
 464
 465   printable_field = (int *) xmalloc ((max_range_endpoint + 1) * sizeof (int));
 466   memset (printable_field, 0, (max_range_endpoint + 1) * sizeof (int));
 467
 468   /* Set the array entries corresponding to integers in the ranges of RP.  */
 469   for (i = 0; i < n_rp; i++)
 470     {
 471       unsigned int j;
 472       for (j = rp[i].lo; j <= rp[i].hi; j++)
 473         {
 474           printable_field[j] = 1;
 475         }
 476     }
 477
 478   free (rp);
 479
 480   return field_found;
 481 }
 482
 483 /* Read from stream STREAM, printing to standard output any selected bytes.  */
 484
 485 static void
 486 cut_bytes (FILE *stream)
 487 {
 488   unsigned int byte_idx;        /* Number of chars in the line so far. */
 489
 490   byte_idx = 0;
 491   while (1)
 492     {
 493       register int c;           /* Each character from the file. */
 494
 495       c = getc (stream);
 496
 497       if (c == '\n')
 498         {
 499           putchar ('\n');
 500           byte_idx = 0;
 501         }
 502       else if (c == EOF)
 503         {
 504           if (byte_idx > 0)
 505             putchar ('\n');
 506           break;
 507         }
 508       else
 509         {
 510           ++byte_idx;
 511           if (print_kth (byte_idx))
 512             {
 513               putchar (c);
 514             }
 515         }
 516     }
 517 }
 518
 519 /* Read from stream STREAM, printing to standard output any selected fields.  */
 520
 521 static void
 522 cut_fields (FILE *stream)
 523 {
 524   int c;
 525   unsigned int field_idx;
 526   int found_any_selected_field;
 527   int buffer_first_field;
 528
 529   found_any_selected_field = 0;
 530   field_idx = 1;
 531
 532   /* To support the semantics of the -s flag, we may have to buffer
 533      all of the first field to determine whether it is `delimited.'
 534      But that is unnecessary if all non-delimited lines must be printed
 535      and the first field has been selected, or if non-delimited lines
 536      must be suppressed and the first field has *not* been selected.
 537      That is because a non-delimited line has exactly one field.  */
 538   buffer_first_field = (suppress_non_delimited ^ !print_kth (1));
 539
 540   while (1)
 541     {
 542       if (field_idx == 1 && buffer_first_field)
 543         {
 544           int len;
 545
 546           len = getstr (&field_1_buffer, &field_1_bufsize, stream, delim);
 547           if (len < 0)
 548             break;
 549
 550           assert (len != 0);
 551
 552           /* If the first field extends to the end of line (it is not
 553              delimited) and we are printing all non-delimited lines,
 554              print this one.  */
 555           if (field_1_buffer[len - 1] != delim)
 556             {
 557               if (suppress_non_delimited)
 558                 {
 559                   /* Empty.  */
 560                 }
 561               else
 562                 {
 563                   fwrite (field_1_buffer, sizeof (char), len, stdout);
 564                   /* Make sure the output line is newline terminated.  */
 565                   if (field_1_buffer[len - 1] != '\n')
 566                     putchar ('\n');
 567                 }
 568               continue;
 569             }
 570           if (print_kth (1))
 571             {
 572               /* Print the field, but not the trailing delimiter.  */
 573               fwrite (field_1_buffer, sizeof (char), len - 1, stdout);
 574               found_any_selected_field = 1;
 575             }
 576           ++field_idx;
 577         }
 578
 579       if (print_kth (field_idx))
 580         {
 581           if (found_any_selected_field)
 582             putchar (delim);
 583           found_any_selected_field = 1;
 584
 585           while ((c = getc (stream)) != delim && c != '\n' && c != EOF)
 586             {
 587               putchar (c);
 588             }
 589         }
 590       else
 591         {
 592           while ((c = getc (stream)) != delim && c != '\n' && c != EOF)
 593             {
 594               /* Empty.  */
 595             }
 596         }
 597
 598       if (c == '\n')
 599         {
 600           c = getc (stream);
 601           if (c != EOF)
 602             {
 603               ungetc (c, stream);
 604               c = '\n';
 605             }
 606         }
 607
 608       if (c == delim)
 609         ++field_idx;
 610       else if (c == '\n' || c == EOF)
 611         {
 612           if (found_any_selected_field
 613               || !(suppress_non_delimited && field_idx == 1))
 614             putchar ('\n');
 615           if (c == EOF)
 616             break;
 617           field_idx = 1;
 618           found_any_selected_field = 0;
 619         }
 620     }
 621 }
 622
 623 static void
 624 cut_stream (FILE *stream)
 625 {
 626   if (operating_mode == byte_mode)
 627     cut_bytes (stream);
 628   else
 629     cut_fields (stream);
 630 }
 631
 632 /* Process file FILE to standard output.
 633    Return 0 if successful, 1 if not. */
 634
 635 static int
 636 cut_file (char *file)
 637 {
 638   FILE *stream;
 639
 640   if (!strcmp (file, "-"))
 641     {
 642       have_read_stdin = 1;
 643       stream = stdin;
 644     }
 645   else
 646     {
 647       stream = fopen (file, "r");
 648       if (stream == NULL)
 649         {
 650           error (0, errno, "%s", file);
 651           return 1;
 652         }
 653     }
 654
 655   cut_stream (stream);
 656
 657   if (ferror (stream))
 658     {
 659       error (0, errno, "%s", file);
 660       return 1;
 661     }
 662   if (!strcmp (file, "-"))
 663     clearerr (stream);          /* Also clear EOF. */
 664   else if (fclose (stream) == EOF)
 665     {
 666       error (0, errno, "%s", file);
 667       return 1;
 668     }
 669   return 0;
 670 }
 671
 672 void
 673 main (int argc, char **argv)
 674 {
 675   int optc, exit_status = 0;
 676
 677   program_name = argv[0];
 678   setlocale (LC_ALL, "");
 679   bindtextdomain (PACKAGE, LOCALEDIR);
 680   textdomain (PACKAGE);
 681
 682   operating_mode = undefined_mode;
 683
 684   /* By default, all non-delimited lines are printed.  */
 685   suppress_non_delimited = 0;
 686
 687   delim = '\0';
 688   have_read_stdin = 0;
 689
 690   while ((optc = getopt_long (argc, argv, "b:c:d:f:ns", longopts, (int *) 0))
 691          != EOF)
 692     {
 693       switch (optc)
 694         {
 695         case 0:
 696           break;
 697
 698         case 'b':
 699         case 'c':
 700           /* Build the byte list. */
 701           if (operating_mode != undefined_mode)
 702             FATAL_ERROR (_("only one type of list may be specified"));
 703           operating_mode = byte_mode;
 704           if (set_fields (optarg) == 0)
 705             FATAL_ERROR (_("missing list of positions"));
 706           break;
 707
 708         case 'f':
 709           /* Build the field list. */
 710           if (operating_mode != undefined_mode)
 711             FATAL_ERROR (_("only one type of list may be specified"));
 712           operating_mode = field_mode;
 713           if (set_fields (optarg) == 0)
 714             FATAL_ERROR (_("missing list of fields"));
 715           break;
 716
 717         case 'd':
 718           /* New delimiter. */
 719           /* Interpret -d '' to mean `use the NUL byte as the delimiter.'  */
 720           if (optarg[0] != '\0' && optarg[1] != '\0')
 721             FATAL_ERROR (_("the delimiter must be a single character"));
 722           delim = optarg[0];
 723           break;
 724
 725         case 'n':
 726           break;
 727
 728         case 's':
 729           suppress_non_delimited = 1;
 730           break;
 731
 732         default:
 733           usage (2);
 734         }
 735     }
 736
 737   if (show_version)
 738     {
 739       printf ("cut - %s\n", PACKAGE_VERSION);
 740       exit (0);
 741     }
 742
 743   if (show_help)
 744     usage (0);
 745
 746   if (operating_mode == undefined_mode)
 747     FATAL_ERROR (_("you must specify a list of bytes, characters, or fields"));
 748
 749   if (delim != '\0' && operating_mode != field_mode)
 750     FATAL_ERROR (_("a delimiter may be specified only when operating on fields"));
 751
 752   if (suppress_non_delimited && operating_mode != field_mode)
 753     FATAL_ERROR (_("suppressing non-delimited lines makes sense\n\
 754 \tonly when operating on fields"));
 755
 756   if (delim == '\0')
 757     delim = '\t';
 758
 759   if (optind == argc)
 760     exit_status |= cut_file ("-");
 761   else
 762     for (; optind < argc; optind++)
 763       exit_status |= cut_file (argv[optind]);
 764
 765   if (have_read_stdin && fclose (stdin) == EOF)
 766     {
 767       error (0, errno, "-");
 768       exit_status = 1;
 769     }
 770   if (ferror (stdout) || fclose (stdout) == EOF)
 771     error (1, errno, _("write error"));
 772
 773   exit (exit_status);
 774 }