src/paste.c

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