home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / textutils-1.19-src.tgz / tar.out / fsf / textutils / src / tac.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  18KB  |  686 lines
  1. /* tac - concatenate and print files in reverse
  2.    Copyright (C) 88, 89, 90, 91, 95, 1996 Free Software Foundation, Inc.
  3.  
  4.    This program is free software; you can redistribute it and/or modify
  5.    it under the terms of the GNU General Public License as published by
  6.    the Free Software Foundation; either version 2, or (at your option)
  7.    any later version.
  8.  
  9.    This program is distributed in the hope that it will be useful,
  10.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.    GNU General Public License for more details.
  13.  
  14.    You should have received a copy of the GNU General Public License
  15.    along with this program; if not, write to the Free Software
  16.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17.  
  18. /* Written by Jay Lepreau (lepreau@cs.utah.edu).
  19.    GNU enhancements by David MacKenzie (djm@gnu.ai.mit.edu). */
  20.  
  21. /* Copy each FILE, or the standard input if none are given or when a
  22.    FILE name of "-" is encountered, to the standard output with the
  23.    order of the records reversed.  The records are separated by
  24.    instances of a string, or a newline if none is given.  By default, the
  25.    separator string is attached to the end of the record that it
  26.    follows in the file.
  27.  
  28.    Options:
  29.    -b, --before            The separator is attached to the beginning
  30.                 of the record that it precedes in the file.
  31.    -r, --regex            The separator is a regular expression.
  32.    -s, --separator=separator    Use SEPARATOR as the record separator.
  33.  
  34.    To reverse a file byte by byte, use (in bash, ksh, or sh):
  35. tac -r -s '.\|
  36. ' file */
  37.  
  38. #include <config.h>
  39.  
  40. #include <stdio.h>
  41. #include <getopt.h>
  42. #include <sys/types.h>
  43. #include <signal.h>
  44. #include "system.h"    /* Before regex to avoid clashes with system defines */
  45. #if WITH_REGEX
  46. # include <regex.h>
  47. #else
  48. # include <rx.h>
  49. #endif
  50. #include "error.h"
  51.  
  52. #ifndef STDC_HEADERS
  53. char *malloc ();
  54. char *realloc ();
  55. #endif
  56.  
  57. #ifndef DEFAULT_TMPDIR
  58. #define DEFAULT_TMPDIR "/tmp"
  59. #endif
  60.  
  61. /* The number of bytes per atomic read. */
  62. #define INITIAL_READSIZE 8192
  63.  
  64. /* The number of bytes per atomic write. */
  65. #define WRITESIZE 8192
  66.  
  67. char *mktemp ();
  68.  
  69. int full_write ();
  70. int safe_read ();
  71.  
  72. /* The name this program was run with. */
  73. char *program_name;
  74.  
  75. /* The string that separates the records of the file. */
  76. static char *separator;
  77.  
  78. /* If nonzero, print `separator' along with the record preceding it
  79.    in the file; otherwise with the record following it. */
  80. static int separator_ends_record;
  81.  
  82. /* 0 if `separator' is to be matched as a regular expression;
  83.    otherwise, the length of `separator', used as a sentinel to
  84.    stop the search. */
  85. static int sentinel_length;
  86.  
  87. /* The length of a match with `separator'.  If `sentinel_length' is 0,
  88.    `match_length' is computed every time a match succeeds;
  89.    otherwise, it is simply the length of `separator'. */
  90. static int match_length;
  91.  
  92. /* The input buffer. */
  93. static char *buffer;
  94.  
  95. /* The number of bytes to read at once into `buffer'. */
  96. static unsigned read_size;
  97.  
  98. /* The size of `buffer'.  This is read_size * 2 + sentinel_length + 2.
  99.    The extra 2 bytes allow `past_end' to have a value beyond the
  100.    end of `buffer' and `match_start' to run off the front of `buffer'. */
  101. static unsigned buffer_size;
  102.  
  103. /* The compiled regular expression representing `separator'. */
  104. static struct re_pattern_buffer compiled_separator;
  105.  
  106. /* The name of a temporary file containing a copy of pipe input. */
  107. static char *tempfile;
  108.  
  109. /* If nonzero, display usage information and exit.  */
  110. static int show_help;
  111.  
  112. /* If nonzero, print the version on standard output then exit.  */
  113. static int show_version;
  114.  
  115. static struct option const longopts[] =
  116. {
  117.   {"before", no_argument, &separator_ends_record, 0},
  118.   {"regex", no_argument, &sentinel_length, 0},
  119.   {"separator", required_argument, NULL, 's'},
  120.   {"help", no_argument, &show_help, 1},
  121.   {"version", no_argument, &show_version, 1},
  122.   {NULL, 0, NULL, 0}
  123. };
  124.  
  125. static void
  126. usage (int status)
  127. {
  128.   if (status != 0)
  129.     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  130.          program_name);
  131.   else
  132.     {
  133.       printf (_("\
  134. Usage: %s [OPTION]... [FILE]...\n\
  135. "),
  136.           program_name);
  137.       printf (_("\
  138. Write each FILE to standard output, last line first.\n\
  139. With no FILE, or when FILE is -, read standard input.\n\
  140. \n\
  141.   -b, --before             attach the separator before instead of after\n\
  142.   -r, --regex              interpret the separator as a regular expression\n\
  143.   -s, --separator=STRING   use STRING as the separator instead of newline\n\
  144.       --help               display this help and exit\n\
  145.       --version            output version information and exit\n\
  146. "));
  147.     }
  148.   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
  149. }
  150.  
  151. static void
  152. cleanup (void)
  153. {
  154.   unlink (tempfile);
  155. }
  156.  
  157. static void
  158. cleanup_fatal (void)
  159. {
  160.   cleanup ();
  161.   exit (EXIT_FAILURE);
  162. }
  163.  
  164. static RETSIGTYPE
  165. sighandler (int sig)
  166. {
  167. #ifdef SA_INTERRUPT
  168.   struct sigaction sigact;
  169.  
  170.   sigact.sa_handler = SIG_DFL;
  171.   sigemptyset (&sigact.sa_mask);
  172.   sigact.sa_flags = 0;
  173.   sigaction (sig, &sigact, NULL);
  174. #else                /* !SA_INTERRUPT */
  175.   signal (sig, SIG_DFL);
  176. #endif                /* SA_INTERRUPT */
  177.   cleanup ();
  178.   kill (getpid (), sig);
  179. }
  180.  
  181. /* Allocate N bytes of memory dynamically, with error checking.  */
  182.  
  183. static char *
  184. xmalloc (unsigned int n)
  185. {
  186.   char *p;
  187.  
  188.   p = malloc (n);
  189.   if (p == 0)
  190.     {
  191.       error (0, 0, _("virtual memory exhausted"));
  192.       cleanup_fatal ();
  193.     }
  194.   return p;
  195. }
  196.  
  197. /* Change the size of memory area P to N bytes, with error checking. */
  198.  
  199. static char *
  200. xrealloc (char *p, unsigned int n)
  201. {
  202.   p = realloc (p, n);
  203.   if (p == 0)
  204.     {
  205.       error (0, 0, _("virtual memory exhausted"));
  206.       cleanup_fatal ();
  207.     }
  208.   return p;
  209. }
  210.  
  211. static void
  212. xwrite (int desc, const char *buffer, int size)
  213. {
  214.   if (full_write (desc, buffer, size) < 0)
  215.     {
  216.       error (0, errno, _("write error"));
  217.       cleanup_fatal ();
  218.     }
  219. }
  220.  
  221. /* Print the characters from START to PAST_END - 1.
  222.    If START is NULL, just flush the buffer. */
  223.  
  224. static void
  225. output (const char *start, const char *past_end)
  226. {
  227.   static char buffer[WRITESIZE];
  228.   static int bytes_in_buffer = 0;
  229.   int bytes_to_add = past_end - start;
  230.   int bytes_available = WRITESIZE - bytes_in_buffer;
  231.  
  232.   if (start == 0)
  233.     {
  234.       xwrite (STDOUT_FILENO, buffer, bytes_in_buffer);
  235.       bytes_in_buffer = 0;
  236.       return;
  237.     }
  238.  
  239.   /* Write out as many full buffers as possible. */
  240.   while (bytes_to_add >= bytes_available)
  241.     {
  242.       memcpy (buffer + bytes_in_buffer, start, bytes_available);
  243.       bytes_to_add -= bytes_available;
  244.       start += bytes_available;
  245.       xwrite (STDOUT_FILENO, buffer, WRITESIZE);
  246.       bytes_in_buffer = 0;
  247.       bytes_available = WRITESIZE;
  248.     }
  249.  
  250.   memcpy (buffer + bytes_in_buffer, start, bytes_to_add);
  251.   bytes_in_buffer += bytes_to_add;
  252. }
  253.  
  254. /* Print in reverse the file open on descriptor FD for reading FILE.
  255.    Return 0 if ok, 1 if an error occurs. */
  256.  
  257. static int
  258. tac (int fd, const char *file)
  259. {
  260.   /* Pointer to the location in `buffer' where the search for
  261.      the next separator will begin. */
  262.   char *match_start;
  263.   /* Pointer to one past the rightmost character in `buffer' that
  264.      has not been printed yet. */
  265.   char *past_end;
  266.   unsigned saved_record_size;    /* Length of the record growing in `buffer'. */
  267.   off_t file_pos;        /* Offset in the file of the next read. */
  268.   /* Nonzero if `output' has not been called yet for any file.
  269.      Only used when the separator is attached to the preceding record. */
  270.   int first_time = 1;
  271.   char first_char = *separator;    /* Speed optimization, non-regexp. */
  272.   char *separator1 = separator + 1; /* Speed optimization, non-regexp. */
  273.   int match_length1 = match_length - 1; /* Speed optimization, non-regexp. */
  274.   struct re_registers regs;
  275.  
  276.   /* Find the size of the input file. */
  277.   file_pos = lseek (fd, (off_t) 0, SEEK_END);
  278.   if (file_pos < 1)
  279.     return 0;            /* It's an empty file. */
  280.  
  281.   /* Arrange for the first read to lop off enough to leave the rest of the
  282.      file a multiple of `read_size'.  Since `read_size' can change, this may
  283.      not always hold during the program run, but since it usually will, leave
  284.      it here for i/o efficiency (page/sector boundaries and all that).
  285.      Note: the efficiency gain has not been verified. */
  286.   saved_record_size = file_pos % read_size;
  287.   if (saved_record_size == 0)
  288.     saved_record_size = read_size;
  289.   file_pos -= saved_record_size;
  290.   /* `file_pos' now points to the start of the last (probably partial) block
  291.      in the input file. */
  292.  
  293.   lseek (fd, file_pos, SEEK_SET);
  294.   if (safe_read (fd, buffer, saved_record_size) != saved_record_size)
  295.     {
  296.       error (0, errno, "%s", file);
  297.       return 1;
  298.     }
  299.  
  300.   match_start = past_end = buffer + saved_record_size;
  301.   /* For non-regexp search, move past impossible positions for a match. */
  302.   if (sentinel_length)
  303.     match_start -= match_length1;
  304.  
  305.   for (;;)
  306.     {
  307.       /* Search backward from `match_start' - 1 to `buffer' for a match
  308.      with `separator'; for speed, use strncmp if `separator' contains no
  309.      metacharacters.
  310.      If the match succeeds, set `match_start' to point to the start of
  311.      the match and `match_length' to the length of the match.
  312.      Otherwise, make `match_start' < `buffer'. */
  313.       if (sentinel_length == 0)
  314.     {
  315.       int i = match_start - buffer;
  316.       int ret;
  317.  
  318.       ret = re_search (&compiled_separator, buffer, i, i - 1, -i, ®s);
  319.       if (ret == -1)
  320.         match_start = buffer - 1;
  321.       else if (ret == -2)
  322.         {
  323.           error (0, 0, _("error in regular expression search"));
  324.           cleanup_fatal ();
  325.         }
  326.       else
  327.         {
  328.           match_start = buffer + regs.start[0];
  329.           match_length = regs.end[0] - regs.start[0];
  330.         }
  331.     }
  332.       else
  333.     {
  334.       /* `match_length' is constant for non-regexp boundaries. */
  335.       while (*--match_start != first_char
  336.          || (match_length1 && strncmp (match_start + 1, separator1,
  337.                            match_length1)))
  338.         /* Do nothing. */ ;
  339.     }
  340.  
  341.       /* Check whether we backed off the front of `buffer' without finding
  342.          a match for `separator'. */
  343.       if (match_start < buffer)
  344.     {
  345.       if (file_pos == 0)
  346.         {
  347.           /* Hit the beginning of the file; print the remaining record. */
  348.           output (buffer, past_end);
  349.           return 0;
  350.         }
  351.  
  352.       saved_record_size = past_end - buffer;
  353.       if (saved_record_size > read_size)
  354.         {
  355.           /* `buffer_size' is about twice `read_size', so since
  356.          we want to read in another `read_size' bytes before
  357.          the data already in `buffer', we need to increase
  358.          `buffer_size'. */
  359.           char *newbuffer;
  360.           int offset = sentinel_length ? sentinel_length : 1;
  361.  
  362.           read_size *= 2;
  363.           buffer_size = read_size * 2 + sentinel_length + 2;
  364.           newbuffer = xrealloc (buffer - offset, buffer_size) + offset;
  365.           /* Adjust the pointers for the new buffer location.  */
  366.           match_start += newbuffer - buffer;
  367.           past_end += newbuffer - buffer;
  368.           buffer = newbuffer;
  369.         }
  370.  
  371.       /* Back up to the start of the next bufferfull of the file.  */
  372.       if (file_pos >= read_size)
  373.         file_pos -= read_size;
  374.       else
  375.         {
  376.           read_size = file_pos;
  377.           file_pos = 0;
  378.         }
  379.       lseek (fd, file_pos, SEEK_SET);
  380.  
  381.       /* Shift the pending record data right to make room for the new.
  382.          The source and destination regions probably overlap.  */
  383.       memmove (buffer + read_size, buffer, saved_record_size);
  384.       past_end = buffer + read_size + saved_record_size;
  385.       /* For non-regexp searches, avoid unneccessary scanning. */
  386.       if (sentinel_length)
  387.         match_start = buffer + read_size;
  388.       else
  389.         match_start = past_end;
  390.  
  391.       if (safe_read (fd, buffer, read_size) != read_size)
  392.         {
  393.           error (0, errno, "%s", file);
  394.           return 1;
  395.         }
  396.     }
  397.       else
  398.     {
  399.       /* Found a match of `separator'. */
  400.       if (separator_ends_record)
  401.         {
  402.           char *match_end = match_start + match_length;
  403.  
  404.           /* If this match of `separator' isn't at the end of the
  405.              file, print the record. */
  406.           if (first_time == 0 || match_end != past_end)
  407.         output (match_end, past_end);
  408.           past_end = match_end;
  409.           first_time = 0;
  410.         }
  411.       else
  412.         {
  413.           output (match_start, past_end);
  414.           past_end = match_start;
  415.         }
  416.       match_start -= match_length - 1;
  417.     }
  418.     }
  419. }
  420.  
  421. /* Print FILE in reverse.
  422.    Return 0 if ok, 1 if an error occurs. */
  423.  
  424. static int
  425. tac_file (const char *file)
  426. {
  427.   int fd, errors;
  428.  
  429.   fd = open (file, O_RDONLY);
  430.   if (fd == -1)
  431.     {
  432.       error (0, errno, "%s", file);
  433.       return 1;
  434.     }
  435.   errors = tac (fd, file);
  436.   if (close (fd) < 0)
  437.     {
  438.       error (0, errno, "%s", file);
  439.       return 1;
  440.     }
  441.   return errors;
  442. }
  443.  
  444. /* Make a copy of the standard input in `tempfile'. */
  445.  
  446. static void
  447. save_stdin (void)
  448. {
  449.   static char *template = NULL;
  450.   static char *tempdir;
  451.   int fd;
  452.   int bytes_read;
  453.  
  454.   if (template == NULL)
  455.     {
  456.       tempdir = getenv ("TMPDIR");
  457.       if (tempdir == NULL)
  458.     tempdir = DEFAULT_TMPDIR;
  459.       template = xmalloc (strlen (tempdir) + 11);
  460.     }
  461.   sprintf (template, "%s/tacXXXXXX", tempdir);
  462.   tempfile = mktemp (template);
  463.  
  464.   fd = creat (tempfile, 0600);
  465.   if (fd == -1)
  466.     {
  467.       error (0, errno, "%s", tempfile);
  468.       cleanup_fatal ();
  469.     }
  470.   while ((bytes_read = safe_read (0, buffer, read_size)) > 0)
  471.     if (full_write (fd, buffer, bytes_read) < 0)
  472.       {
  473.     error (0, errno, "%s", tempfile);
  474.     cleanup_fatal ();
  475.       }
  476.   if (close (fd) < 0)
  477.     {
  478.       error (0, errno, "%s", tempfile);
  479.       cleanup_fatal ();
  480.     }
  481.   if (bytes_read == -1)
  482.     {
  483.       error (0, errno, _("read error"));
  484.       cleanup_fatal ();
  485.     }
  486. }
  487.  
  488. /* Print the standard input in reverse, saving it to temporary
  489.    file `tempfile' first if it is a pipe.
  490.    Return 0 if ok, 1 if an error occurs. */
  491.  
  492. static int
  493. tac_stdin (void)
  494. {
  495.   /* Previous values of signal handlers. */
  496.   RETSIGTYPE (*sigint) (), (*sighup) (), (*sigpipe) (), (*sigterm) ();
  497.   int errors;
  498.   struct stat stats;
  499. #ifdef SA_INTERRUPT
  500.     struct sigaction oldact, newact;
  501. #endif                /* SA_INTERRUPT */
  502.  
  503.   /* No tempfile is needed for "tac < file".
  504.      Use fstat instead of checking for errno == ESPIPE because
  505.      lseek doesn't work on some special files but doesn't return an
  506.      error, either. */
  507.   if (fstat (0, &stats))
  508.     {
  509.       error (0, errno, _("standard input"));
  510.       return 1;
  511.     }
  512.   if (S_ISREG (stats.st_mode))
  513.     return tac (0, _("standard input"));
  514.  
  515. #ifdef SA_INTERRUPT
  516.   newact.sa_handler = sighandler;
  517.   sigemptyset (&newact.sa_mask);
  518.   newact.sa_flags = 0;
  519.  
  520.   sigaction (SIGINT, NULL, &oldact);
  521.   sigint = oldact.sa_handler;
  522.   if (sigint != SIG_IGN)
  523.     sigaction (SIGINT, &newact, NULL);
  524.  
  525.   sigaction (SIGHUP, NULL, &oldact);
  526.   sighup = oldact.sa_handler;
  527.   if (sighup != SIG_IGN)
  528.     sigaction (SIGHUP, &newact, NULL);
  529.  
  530.   sigaction (SIGPIPE, NULL, &oldact);
  531.   sigpipe = oldact.sa_handler;
  532.   if (sigpipe != SIG_IGN)
  533.     sigaction (SIGPIPE, &newact, NULL);
  534.  
  535.   sigaction (SIGTERM, NULL, &oldact);
  536.   sigterm = oldact.sa_handler;
  537.   if (sigterm != SIG_IGN)
  538.     sigaction (SIGTERM, &newact, NULL);
  539. #else                /* !SA_INTERRUPT */
  540.   sigint = signal (SIGINT, SIG_IGN);
  541.   if (sigint != SIG_IGN)
  542.     signal (SIGINT, sighandler);
  543.  
  544.   sighup = signal (SIGHUP, SIG_IGN);
  545.   if (sighup != SIG_IGN)
  546.     signal (SIGHUP, sighandler);
  547.  
  548.   sigpipe = signal (SIGPIPE, SIG_IGN);
  549.   if (sigpipe != SIG_IGN)
  550.     signal (SIGPIPE, sighandler);
  551.  
  552.   sigterm = signal (SIGTERM, SIG_IGN);
  553.   if (sigterm != SIG_IGN)
  554.     signal (SIGTERM, sighandler);
  555. #endif                /* SA_INTERRUPT */
  556.  
  557.   save_stdin ();
  558.  
  559.   errors = tac_file (tempfile);
  560.  
  561.   unlink (tempfile);
  562.  
  563. #ifdef SA_INTERRUPT
  564.   newact.sa_handler = sigint;
  565.   sigaction (SIGINT, &newact, NULL);
  566.   newact.sa_handler = sighup;
  567.   sigaction (SIGHUP, &newact, NULL);
  568.   newact.sa_handler = sigterm;
  569.   sigaction (SIGTERM, &newact, NULL);
  570.   newact.sa_handler = sigpipe;
  571.   sigaction (SIGPIPE, &newact, NULL);
  572. #else                /* !SA_INTERRUPT */
  573.   signal (SIGINT, sigint);
  574.   signal (SIGHUP, sighup);
  575.   signal (SIGTERM, sigterm);
  576.   signal (SIGPIPE, sigpipe);
  577. #endif                /* SA_INTERRUPT */
  578.  
  579.   return errors;
  580. }
  581.  
  582. int
  583. main (int argc, char **argv)
  584. {
  585.   const char *error_message;    /* Return value from re_compile_pattern. */
  586.   int optc, errors;
  587.   int have_read_stdin = 0;
  588.  
  589.   program_name = argv[0];
  590.   setlocale (LC_ALL, "");
  591.   bindtextdomain (PACKAGE, LOCALEDIR);
  592.   textdomain (PACKAGE);
  593.  
  594.   errors = 0;
  595.   separator = "\n";
  596.   sentinel_length = 1;
  597.   separator_ends_record = 1;
  598.  
  599.   while ((optc = getopt_long (argc, argv, "brs:", longopts, (int *) 0))
  600.      != EOF)
  601.     {
  602.       switch (optc)
  603.     {
  604.     case 0:
  605.       break;
  606.     case 'b':
  607.       separator_ends_record = 0;
  608.       break;
  609.     case 'r':
  610.       sentinel_length = 0;
  611.       break;
  612.     case 's':
  613.       separator = optarg;
  614.       if (*separator == 0)
  615.         error (EXIT_FAILURE, 0, _("separator cannot be empty"));
  616.       break;
  617.     default:
  618.       usage (1);
  619.     }
  620.     }
  621.  
  622.   if (show_version)
  623.     {
  624.       printf ("tac - %s\n", PACKAGE_VERSION);
  625.       exit (EXIT_SUCCESS);
  626.     }
  627.  
  628.   if (show_help)
  629.     usage (0);
  630.  
  631.   if (sentinel_length == 0)
  632.     {
  633.       compiled_separator.allocated = 100;
  634.       compiled_separator.buffer = (unsigned char *)
  635.     xmalloc (compiled_separator.allocated);
  636.       compiled_separator.fastmap = xmalloc (256);
  637.       compiled_separator.translate = 0;
  638.       error_message = re_compile_pattern (separator, strlen (separator),
  639.                       &compiled_separator);
  640.       if (error_message)
  641.     error (EXIT_FAILURE, 0, "%s", error_message);
  642.     }
  643.   else
  644.     match_length = sentinel_length = strlen (separator);
  645.  
  646.   read_size = INITIAL_READSIZE;
  647.   /* A precaution that will probably never be needed. */
  648.   while (sentinel_length * 2 >= read_size)
  649.     read_size *= 2;
  650.   buffer_size = read_size * 2 + sentinel_length + 2;
  651.   buffer = xmalloc (buffer_size);
  652.   if (sentinel_length)
  653.     {
  654.       strcpy (buffer, separator);
  655.       buffer += sentinel_length;
  656.     }
  657.   else
  658.     ++buffer;
  659.  
  660.   if (optind == argc)
  661.     {
  662.       have_read_stdin = 1;
  663.       errors = tac_stdin ();
  664.     }
  665.   else
  666.     for (; optind < argc; ++optind)
  667.       {
  668.     if (strcmp (argv[optind], "-") == 0)
  669.       {
  670.         have_read_stdin = 1;
  671.         errors |= tac_stdin ();
  672.       }
  673.     else
  674.       errors |= tac_file (argv[optind]);
  675.       }
  676.  
  677.   /* Flush the output buffer. */
  678.   output ((char *) NULL, (char *) NULL);
  679.  
  680.   if (have_read_stdin && close (0) < 0)
  681.     error (EXIT_FAILURE, errno, "-");
  682.   if (close (1) < 0)
  683.     error (EXIT_FAILURE, errno, _("write error"));
  684.   exit (errors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
  685. }
  686.