src/paste.c

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