src/paste.c

   1 /* paste - merge lines of files
   2    Copyright (C) 1997-2024 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 3 of the License, or
   8    (at your option) 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, see <https://www.gnu.org/licenses/>.  */
  17
  18 /* Written by David Ihnat.  */
  19
  20 /* The list of valid escape sequences has been expanded over the Unix
  21    version, to include \b, \f, \r, and \v.
  22
  23    POSIX changes, bug fixes, long-named options, and cleanup
  24    by David MacKenzie <djm@gnu.ai.mit.edu>.
  25
  26    Options:
  27    --serial
  28    -s                           Paste one file at a time rather than
  29                                 one line from each file.
  30    --delimiters=delim-list
  31    -d delim-list                Consecutively use the characters in
  32                                 DELIM-LIST instead of tab to separate
  33                                 merged lines.  When DELIM-LIST is exhausted,
  34                                 start again at its beginning.
  35    A FILE of '-' means standard input.
  36    If no FILEs are given, standard input is used. */
  37
  38 #include <config.h>
  39
  40 #include <stdio.h>
  41 #include <getopt.h>
  42 #include <sys/types.h>
  43 #include "system.h"
  44 #include "fadvise.h"
  45
  46 /* The official name of this program (e.g., no 'g' prefix).  */
  47 #define PROGRAM_NAME "paste"
  48
  49 #define AUTHORS \
  50   proper_name ("David M. Ihnat"), \
  51   proper_name ("David MacKenzie")
  52
  53 /* Indicates that no delimiter should be added in the current position. */
  54 #define EMPTY_DELIM '\0'
  55
  56 /* If nonzero, we have read standard input at some point. */
  57 static bool have_read_stdin;
  58
  59 /* If nonzero, merge subsequent lines of each file rather than
  60    corresponding lines from each file in parallel. */
  61 static bool serial_merge;
  62
  63 /* The delimiters between lines of input files (used cyclically). */
  64 static char *delims;
  65
  66 /* A pointer to the character after the end of 'delims'. */
  67 static char const *delim_end;
  68
  69 static unsigned char line_delim = '\n';
  70
  71 static struct option const longopts[] =
  72 {
  73   {"serial", no_argument, nullptr, 's'},
  74   {"delimiters", required_argument, nullptr, 'd'},
  75   {"zero-terminated", no_argument, nullptr, 'z'},
  76   {GETOPT_HELP_OPTION_DECL},
  77   {GETOPT_VERSION_OPTION_DECL},
  78   {nullptr, 0, nullptr, 0}
  79 };
  80
  81 /* Set globals delims and delim_end.  Copy STRPTR to DELIMS, converting
  82    backslash representations of special characters in STRPTR to their actual
  83    values. The set of possible backslash characters has been expanded beyond
  84    that recognized by the Unix version.
  85    Return 0 upon success.
  86    If the string ends in an odd number of backslashes, ignore the
  87    final backslash and return nonzero.  */
  88
  89 static int
  90 collapse_escapes (char const *strptr)
  91 {
  92   char *strout = xstrdup (strptr);
  93   bool backslash_at_end = false;
  94
  95   delims = strout;
  96
  97   while (*strptr)
  98     {
  99       if (*strptr != '\\')      /* Is it an escape character? */
 100         *strout++ = *strptr++;  /* No, just transfer it. */
 101       else
 102         {
 103           switch (*++strptr)
 104             {
 105             case '0':
 106               *strout++ = EMPTY_DELIM;
 107               break;
 108
 109             case 'b':
 110               *strout++ = '\b';
 111               break;
 112
 113             case 'f':
 114               *strout++ = '\f';
 115               break;
 116
 117             case 'n':
 118               *strout++ = '\n';
 119               break;
 120
 121             case 'r':
 122               *strout++ = '\r';
 123               break;
 124
 125             case 't':
 126               *strout++ = '\t';
 127               break;
 128
 129             case 'v':
 130               *strout++ = '\v';
 131               break;
 132
 133             case '\\':
 134               *strout++ = '\\';
 135               break;
 136
 137             case '\0':
 138               backslash_at_end = true;
 139               goto done;
 140
 141             default:
 142               *strout++ = *strptr;
 143               break;
 144             }
 145           strptr++;
 146         }
 147     }
 148
 149  done:
 150
 151   delim_end = strout;
 152   return backslash_at_end ? 1 : 0;
 153 }
 154
 155 /* Output a single byte, reporting any write errors.  */
 156
 157 static inline void
 158 xputchar (char c)
 159 {
 160   if (putchar (c) < 0)
 161     write_error ();
 162 }
 163
 164 /* Perform column paste on the NFILES files named in FNAMPTR.
 165    Return true if successful, false if one or more files could not be
 166    opened or read. */
 167
 168 static bool
 169 paste_parallel (size_t nfiles, char **fnamptr)
 170 {
 171   bool ok = true;
 172   /* If all files are just ready to be closed, or will be on this
 173      round, the string of delimiters must be preserved.
 174      delbuf[0] through delbuf[nfiles]
 175      store the delimiters for closed files. */
 176   char *delbuf = xmalloc (nfiles + 2);
 177
 178   /* Streams open to the files to process; null if the corresponding
 179      stream is closed.  */
 180   FILE **fileptr = xnmalloc (nfiles + 1, sizeof *fileptr);
 181
 182   /* Number of files still open to process.  */
 183   size_t files_open;
 184
 185   /* True if any fopen got fd == STDIN_FILENO.  */
 186   bool opened_stdin = false;
 187
 188   /* Attempt to open all files.  This could be expanded to an infinite
 189      number of files, but at the (considerable) expense of remembering
 190      each file and its current offset, then opening/reading/closing.  */
 191
 192   for (files_open = 0; files_open < nfiles; ++files_open)
 193     {
 194       if (STREQ (fnamptr[files_open], "-"))
 195         {
 196           have_read_stdin = true;
 197           fileptr[files_open] = stdin;
 198         }
 199       else
 200         {
 201           fileptr[files_open] = fopen (fnamptr[files_open], "r");
 202           if (fileptr[files_open] == nullptr)
 203             error (EXIT_FAILURE, errno, "%s", quotef (fnamptr[files_open]));
 204           else if (fileno (fileptr[files_open]) == STDIN_FILENO)
 205             opened_stdin = true;
 206           fadvise (fileptr[files_open], FADVISE_SEQUENTIAL);
 207         }
 208     }
 209
 210   if (opened_stdin && have_read_stdin)
 211     error (EXIT_FAILURE, 0, _("standard input is closed"));
 212
 213   /* Read a line from each file and output it to stdout separated by a
 214      delimiter, until we go through the loop without successfully
 215      reading from any of the files. */
 216
 217   while (files_open)
 218     {
 219       /* Set up for the next line. */
 220       bool somedone = false;
 221       char const *delimptr = delims;
 222       size_t delims_saved = 0;  /* Number of delims saved in 'delbuf'. */
 223
 224       for (size_t i = 0; i < nfiles && files_open; i++)
 225         {
 226           int chr;                      /* Input character. */
 227           int err;                      /* Input errno value.  */
 228           bool sometodo = false;        /* Input chars to process.  */
 229
 230           if (fileptr[i])
 231             {
 232               chr = getc (fileptr[i]);
 233               err = errno;
 234               if (chr != EOF && delims_saved)
 235                 {
 236                   if (fwrite (delbuf, 1, delims_saved, stdout) != delims_saved)
 237                     write_error ();
 238                   delims_saved = 0;
 239                 }
 240
 241               while (chr != EOF)
 242                 {
 243                   sometodo = true;
 244                   if (chr == line_delim)
 245                     break;
 246                   xputchar (chr);
 247                   chr = getc (fileptr[i]);
 248                   err = errno;
 249                 }
 250             }
 251
 252           if (! sometodo)
 253             {
 254               /* EOF, read error, or closed file.
 255                  If an EOF or error, close the file.  */
 256               if (fileptr[i])
 257                 {
 258                   if (!ferror (fileptr[i]))
 259                     err = 0;
 260                   if (fileptr[i] == stdin)
 261                     clearerr (fileptr[i]); /* Also clear EOF. */
 262                   else if (fclose (fileptr[i]) == EOF && !err)
 263                     err = errno;
 264                   if (err)
 265                     {
 266                       error (0, err, "%s", quotef (fnamptr[i]));
 267                       ok = false;
 268                     }
 269
 270                   fileptr[i] = nullptr;
 271                   files_open--;
 272                 }
 273
 274               if (i + 1 == nfiles)
 275                 {
 276                   /* End of this output line.
 277                      Is this the end of the whole thing? */
 278                   if (somedone)
 279                     {
 280                       /* No.  Some files were not closed for this line. */
 281                       if (delims_saved)
 282                         {
 283                           if (fwrite (delbuf, 1, delims_saved, stdout)
 284                               != delims_saved)
 285                             write_error ();
 286                           delims_saved = 0;
 287                         }
 288                       xputchar (line_delim);
 289                     }
 290                   continue;     /* Next read of files, or exit. */
 291                 }
 292               else
 293                 {
 294                   /* Closed file; add delimiter to 'delbuf'. */
 295                   if (*delimptr != EMPTY_DELIM)
 296                     delbuf[delims_saved++] = *delimptr;
 297                   if (++delimptr == delim_end)
 298                     delimptr = delims;
 299                 }
 300             }
 301           else
 302             {
 303               /* Some data read. */
 304               somedone = true;
 305
 306               /* Except for last file, replace last newline with delim. */
 307               if (i + 1 != nfiles)
 308                 {
 309                   if (chr != line_delim && chr != EOF)
 310                     xputchar (chr);
 311                   if (*delimptr != EMPTY_DELIM)
 312                     xputchar (*delimptr);
 313                   if (++delimptr == delim_end)
 314                     delimptr = delims;
 315                 }
 316               else
 317                 {
 318                   /* If the last line of the last file lacks a newline,
 319                      print one anyhow.  POSIX requires this.  */
 320                   char c = (chr == EOF ? line_delim : chr);
 321                   xputchar (c);
 322                 }
 323             }
 324         }
 325     }
 326   free (fileptr);
 327   free (delbuf);
 328   return ok;
 329 }
 330
 331 /* Perform serial paste on the NFILES files named in FNAMPTR.
 332    Return true if no errors, false if one or more files could not be
 333    opened or read. */
 334
 335 static bool
 336 paste_serial (size_t nfiles, char **fnamptr)
 337 {
 338   bool ok = true;       /* false if open or read errors occur. */
 339   int charnew, charold; /* Current and previous char read. */
 340   char const *delimptr; /* Current delimiter char. */
 341   FILE *fileptr;        /* Open for reading current file. */
 342
 343   for (; nfiles; nfiles--, fnamptr++)
 344     {
 345       int saved_errno;
 346       bool is_stdin = STREQ (*fnamptr, "-");
 347       if (is_stdin)
 348         {
 349           have_read_stdin = true;
 350           fileptr = stdin;
 351         }
 352       else
 353         {
 354           fileptr = fopen (*fnamptr, "r");
 355           if (fileptr == nullptr)
 356             {
 357               error (0, errno, "%s", quotef (*fnamptr));
 358               ok = false;
 359               continue;
 360             }
 361           fadvise (fileptr, FADVISE_SEQUENTIAL);
 362         }
 363
 364       delimptr = delims;        /* Set up for delimiter string. */
 365
 366       charold = getc (fileptr);
 367       saved_errno = errno;
 368       if (charold != EOF)
 369         {
 370           /* 'charold' is set up.  Hit it!
 371              Keep reading characters, stashing them in 'charnew';
 372              output 'charold', converting to the appropriate delimiter
 373              character if needed.  After the EOF, output 'charold'
 374              if it's a newline; otherwise, output it and then a newline. */
 375
 376           while ((charnew = getc (fileptr)) != EOF)
 377             {
 378               /* Process the old character. */
 379               if (charold == line_delim)
 380                 {
 381                   if (*delimptr != EMPTY_DELIM)
 382                     xputchar (*delimptr);
 383
 384                   if (++delimptr == delim_end)
 385                     delimptr = delims;
 386                 }
 387               else
 388                 xputchar (charold);
 389
 390               charold = charnew;
 391             }
 392           saved_errno = errno;
 393
 394           /* Hit EOF.  Process that last character. */
 395           xputchar (charold);
 396         }
 397
 398       if (charold != line_delim)
 399         xputchar (line_delim);
 400
 401       if (!ferror (fileptr))
 402         saved_errno = 0;
 403       if (is_stdin)
 404         clearerr (fileptr);     /* Also clear EOF. */
 405       else if (fclose (fileptr) != 0 && !saved_errno)
 406         saved_errno = errno;
 407       if (saved_errno)
 408         {
 409           error (0, saved_errno, "%s", quotef (*fnamptr));
 410           ok = false;
 411         }
 412     }
 413   return ok;
 414 }
 415
 416 void
 417 usage (int status)
 418 {
 419   if (status != EXIT_SUCCESS)
 420     emit_try_help ();
 421   else
 422     {
 423       printf (_("\
 424 Usage: %s [OPTION]... [FILE]...\n\
 425 "),
 426               program_name);
 427       fputs (_("\
 428 Write lines consisting of the sequentially corresponding lines from\n\
 429 each FILE, separated by TABs, to standard output.\n\
 430 "), stdout);
 431
 432       emit_stdin_note ();
 433       emit_mandatory_arg_note ();
 434
 435       fputs (_("\
 436   -d, --delimiters=LIST   reuse characters from LIST instead of TABs\n\
 437   -s, --serial            paste one file at a time instead of in parallel\n\
 438 "), stdout);
 439       fputs (_("\
 440   -z, --zero-terminated    line delimiter is NUL, not newline\n\
 441 "), stdout);
 442       fputs (HELP_OPTION_DESCRIPTION, stdout);
 443       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 444       /* FIXME: add a couple of examples.  */
 445       emit_ancillary_info (PROGRAM_NAME);
 446     }
 447   exit (status);
 448 }
 449
 450 int
 451 main (int argc, char **argv)
 452 {
 453   int optc;
 454   char const *delim_arg = "\t";
 455
 456   initialize_main (&argc, &argv);
 457   set_program_name (argv[0]);
 458   setlocale (LC_ALL, "");
 459   bindtextdomain (PACKAGE, LOCALEDIR);
 460   textdomain (PACKAGE);
 461
 462   atexit (close_stdout);
 463
 464   have_read_stdin = false;
 465   serial_merge = false;
 466
 467   while ((optc = getopt_long (argc, argv, "d:sz", longopts, nullptr)) != -1)
 468     {
 469       switch (optc)
 470         {
 471         case 'd':
 472           /* Delimiter character(s). */
 473           delim_arg = (optarg[0] == '\0' ? "\\0" : optarg);
 474           break;
 475
 476         case 's':
 477           serial_merge = true;
 478           break;
 479
 480         case 'z':
 481           line_delim = '\0';
 482           break;
 483
 484         case_GETOPT_HELP_CHAR;
 485
 486         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 487
 488         default:
 489           usage (EXIT_FAILURE);
 490         }
 491     }
 492
 493   int nfiles = argc - optind;
 494   if (nfiles == 0)
 495     {
 496       argv[optind] = bad_cast ("-");
 497       nfiles++;
 498     }
 499
 500   if (collapse_escapes (delim_arg))
 501     {
 502       /* Don't use the quote() quoting style, because that would double the
 503          number of displayed backslashes, making the diagnostic look bogus.  */
 504       error (EXIT_FAILURE, 0,
 505              _("delimiter list ends with an unescaped backslash: %s"),
 506              quotearg_n_style_colon (0, c_maybe_quoting_style, delim_arg));
 507     }
 508
 509   bool ok = ((serial_merge ? paste_serial : paste_parallel)
 510              (nfiles, &argv[optind]));
 511
 512   free (delims);
 513
 514   if (have_read_stdin && fclose (stdin) == EOF)
 515     error (EXIT_FAILURE, errno, "-");
 516   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 517 }