Update FSF postal mail address.
[platform/upstream/coreutils.git] / src / csplit.c
1 /* csplit - split a file into sections determined by context lines
2    Copyright (C) 91, 1995-2005 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 Foundation,
16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307, USA.  */
17
18 /* Written by Stuart Kemp, cpsrk@groper.jcu.edu.au.
19    Modified by David MacKenzie, djm@gnu.ai.mit.edu. */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <getopt.h>
25 #include <sys/types.h>
26 #include <signal.h>
27
28 #include "system.h"
29
30 #include <regex.h>
31
32 #include "error.h"
33 #include "inttostr.h"
34 #include "quote.h"
35 #include "safe-read.h"
36 #include "stdio-safer.h"
37 #include "xstrtol.h"
38
39 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
40    present.  */
41 #ifndef SA_NOCLDSTOP
42 # define SA_NOCLDSTOP 0
43 # define sigprocmask(How, Set, Oset) /* empty */
44 # define sigset_t int
45 # if ! HAVE_SIGINTERRUPT
46 #  define siginterrupt(sig, flag) /* empty */
47 # endif
48 #endif
49
50 /* The official name of this program (e.g., no `g' prefix).  */
51 #define PROGRAM_NAME "csplit"
52
53 #define AUTHORS "Stuart Kemp", "David MacKenzie"
54
55 /* Increment size of area for control records. */
56 #define ALLOC_SIZE 20
57
58 /* The default prefix for output file names. */
59 #define DEFAULT_PREFIX  "xx"
60
61 /* A compiled pattern arg. */
62 struct control
63 {
64   char *regexpr;                /* Non-compiled regular expression. */
65   struct re_pattern_buffer re_compiled; /* Compiled regular expression. */
66   intmax_t offset;              /* Offset from regexp to split at. */
67   uintmax_t lines_required;     /* Number of lines required. */
68   uintmax_t repeat;             /* Repeat count. */
69   int argnum;                   /* ARGV index. */
70   bool repeat_forever;          /* True if `*' used as a repeat count. */
71   bool ignore;                  /* If true, produce no output (for regexp). */
72 };
73
74 /* Initial size of data area in buffers. */
75 #define START_SIZE      8191
76
77 /* Increment size for data area. */
78 #define INCR_SIZE       2048
79
80 /* Number of lines kept in each node in line list. */
81 #define CTRL_SIZE       80
82
83 #ifdef DEBUG
84 /* Some small values to test the algorithms. */
85 # define START_SIZE     200
86 # define INCR_SIZE      10
87 # define CTRL_SIZE      1
88 #endif
89
90 /* A string with a length count. */
91 struct cstring
92 {
93   size_t len;
94   char *str;
95 };
96
97 /* Pointers to the beginnings of lines in the buffer area.
98    These structures are linked together if needed. */
99 struct line
100 {
101   size_t used;                  /* Number of offsets used in this struct. */
102   size_t insert_index;          /* Next offset to use when inserting line. */
103   size_t retrieve_index;        /* Next index to use when retrieving line. */
104   struct cstring starts[CTRL_SIZE]; /* Lines in the data area. */
105   struct line *next;            /* Next in linked list. */
106 };
107
108 /* The structure to hold the input lines.
109    Contains a pointer to the data area and a list containing
110    pointers to the individual lines. */
111 struct buffer_record
112 {
113   size_t bytes_alloc;           /* Size of the buffer area. */
114   size_t bytes_used;            /* Bytes used in the buffer area. */
115   uintmax_t start_line;         /* First line number in this buffer. */
116   uintmax_t first_available;    /* First line that can be retrieved. */
117   size_t num_lines;             /* Number of complete lines in this buffer. */
118   char *buffer;                 /* Data area. */
119   struct line *line_start;      /* Head of list of pointers to lines. */
120   struct line *curr_line;       /* The line start record currently in use. */
121   struct buffer_record *next;
122 };
123
124 static void close_output_file (void);
125 static void create_output_file (void);
126 static void delete_all_files (bool);
127 static void save_line_to_file (const struct cstring *line);
128 void usage (int status);
129
130 /* The name this program was run with. */
131 char *program_name;
132
133 /* Input file descriptor. */
134 static int input_desc;
135
136 /* Start of buffer list. */
137 static struct buffer_record *head = NULL;
138
139 /* Partially read line. */
140 static char *hold_area = NULL;
141
142 /* Number of bytes in `hold_area'. */
143 static size_t hold_count = 0;
144
145 /* Number of the last line in the buffers. */
146 static uintmax_t last_line_number = 0;
147
148 /* Number of the line currently being examined. */
149 static uintmax_t current_line = 0;
150
151 /* If true, we have read EOF. */
152 static bool have_read_eof = false;
153
154 /* Name of output files. */
155 static char * volatile filename_space = NULL;
156
157 /* Prefix part of output file names. */
158 static char * volatile prefix = NULL;
159
160 /* Suffix part of output file names. */
161 static char * volatile suffix = NULL;
162
163 /* Number of digits to use in output file names. */
164 static int volatile digits = 2;
165
166 /* Number of files created so far. */
167 static unsigned int volatile files_created = 0;
168
169 /* Number of bytes written to current file. */
170 static uintmax_t bytes_written;
171
172 /* Output file pointer. */
173 static FILE *output_stream = NULL;
174
175 /* Output file name. */
176 static char *output_filename = NULL;
177
178 /* Perhaps it would be cleaner to pass arg values instead of indexes. */
179 static char **global_argv;
180
181 /* If true, do not print the count of bytes in each output file. */
182 static bool suppress_count;
183
184 /* If true, remove output files on error. */
185 static bool volatile remove_files;
186
187 /* If true, remove all output files which have a zero length. */
188 static bool elide_empty_files;
189
190 /* The compiled pattern arguments, which determine how to split
191    the input file. */
192 static struct control *controls;
193
194 /* Number of elements in `controls'. */
195 static size_t control_used;
196
197 /* The set of signals that are caught.  */
198 static sigset_t caught_signals;
199
200 static struct option const longopts[] =
201 {
202   {"digits", required_argument, NULL, 'n'},
203   {"quiet", no_argument, NULL, 'q'},
204   {"silent", no_argument, NULL, 's'},
205   {"keep-files", no_argument, NULL, 'k'},
206   {"elide-empty-files", no_argument, NULL, 'z'},
207   {"prefix", required_argument, NULL, 'f'},
208   {"suffix-format", required_argument, NULL, 'b'},
209   {GETOPT_HELP_OPTION_DECL},
210   {GETOPT_VERSION_OPTION_DECL},
211   {NULL, 0, NULL, 0}
212 };
213
214 /* Optionally remove files created so far; then exit.
215    Called when an error detected. */
216
217 static void
218 cleanup (void)
219 {
220   sigset_t oldset;
221
222   close_output_file ();
223
224   sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
225   delete_all_files (false);
226   sigprocmask (SIG_SETMASK, &oldset, NULL);
227 }
228
229 static void cleanup_fatal (void) ATTRIBUTE_NORETURN;
230 static void
231 cleanup_fatal (void)
232 {
233   cleanup ();
234   exit (EXIT_FAILURE);
235 }
236
237 extern void
238 xalloc_die (void)
239 {
240   error (0, 0, "%s", _("memory exhausted"));
241   cleanup_fatal ();
242 }
243
244 static void
245 interrupt_handler (int sig)
246 {
247   if (! SA_NOCLDSTOP)
248     signal (sig, SIG_IGN);
249
250   delete_all_files (true);
251
252   signal (sig, SIG_DFL);
253   raise (sig);
254 }
255
256 /* Keep track of NUM bytes of a partial line in buffer START.
257    These bytes will be retrieved later when another large buffer is read.
258    It is not necessary to create a new buffer for these bytes; instead,
259    we keep a pointer to the existing buffer.  This buffer *is* on the
260    free list, and when the next buffer is obtained from this list
261    (even if it is this one), these bytes will be placed at the
262    start of the new buffer. */
263
264 static void
265 save_to_hold_area (char *start, size_t num)
266 {
267   hold_area = start;
268   hold_count = num;
269 }
270
271 /* Read up to MAX_N_BYTES bytes from the input stream into DEST.
272    Return the number of bytes read. */
273
274 static size_t
275 read_input (char *dest, size_t max_n_bytes)
276 {
277   size_t bytes_read;
278
279   if (max_n_bytes == 0)
280     return 0;
281
282   bytes_read = safe_read (input_desc, dest, max_n_bytes);
283
284   if (bytes_read == 0)
285     have_read_eof = true;
286
287   if (bytes_read == SAFE_READ_ERROR)
288     {
289       error (0, errno, _("read error"));
290       cleanup_fatal ();
291     }
292
293   return bytes_read;
294 }
295
296 /* Initialize existing line record P. */
297
298 static void
299 clear_line_control (struct line *p)
300 {
301   p->used = 0;
302   p->insert_index = 0;
303   p->retrieve_index = 0;
304 }
305
306 /* Return a new, initialized line record. */
307
308 static struct line *
309 new_line_control (void)
310 {
311   struct line *p = xmalloc (sizeof *p);
312
313   p->next = NULL;
314   clear_line_control (p);
315
316   return p;
317 }
318
319 /* Record LINE_START, which is the address of the start of a line
320    of length LINE_LEN in the large buffer, in the lines buffer of B. */
321
322 static void
323 keep_new_line (struct buffer_record *b, char *line_start, size_t line_len)
324 {
325   struct line *l;
326
327   /* If there is no existing area to keep line info, get some. */
328   if (b->line_start == NULL)
329     b->line_start = b->curr_line = new_line_control ();
330
331   /* If existing area for lines is full, get more. */
332   if (b->curr_line->used == CTRL_SIZE)
333     {
334       b->curr_line->next = new_line_control ();
335       b->curr_line = b->curr_line->next;
336     }
337
338   l = b->curr_line;
339
340   /* Record the start of the line, and update counters. */
341   l->starts[l->insert_index].str = line_start;
342   l->starts[l->insert_index].len = line_len;
343   l->used++;
344   l->insert_index++;
345 }
346
347 /* Scan the buffer in B for newline characters
348    and record the line start locations and lengths in B.
349    Return the number of lines found in this buffer.
350
351    There may be an incomplete line at the end of the buffer;
352    a pointer is kept to this area, which will be used when
353    the next buffer is filled. */
354
355 static size_t
356 record_line_starts (struct buffer_record *b)
357 {
358   char *line_start;             /* Start of current line. */
359   char *line_end;               /* End of each line found. */
360   size_t bytes_left;            /* Length of incomplete last line. */
361   size_t lines;                 /* Number of lines found. */
362   size_t line_length;           /* Length of each line found. */
363
364   if (b->bytes_used == 0)
365     return 0;
366
367   lines = 0;
368   line_start = b->buffer;
369   bytes_left = b->bytes_used;
370
371   for (;;)
372     {
373       line_end = memchr (line_start, '\n', bytes_left);
374       if (line_end == NULL)
375         break;
376       line_length = line_end - line_start + 1;
377       keep_new_line (b, line_start, line_length);
378       bytes_left -= line_length;
379       line_start = line_end + 1;
380       lines++;
381     }
382
383   /* Check for an incomplete last line. */
384   if (bytes_left)
385     {
386       if (have_read_eof)
387         {
388           keep_new_line (b, line_start, bytes_left);
389           lines++;
390         }
391       else
392         save_to_hold_area (line_start, bytes_left);
393     }
394
395   b->num_lines = lines;
396   b->first_available = b->start_line = last_line_number + 1;
397   last_line_number += lines;
398
399   return lines;
400 }
401
402 /* Return a new buffer with room to store SIZE bytes, plus
403    an extra byte for safety. */
404
405 static struct buffer_record *
406 create_new_buffer (size_t size)
407 {
408   struct buffer_record *new_buffer = xmalloc (sizeof *new_buffer);
409
410   new_buffer->buffer = xmalloc (size + 1);
411
412   new_buffer->bytes_alloc = size;
413   new_buffer->line_start = new_buffer->curr_line = NULL;
414
415   return new_buffer;
416 }
417
418 /* Return a new buffer of at least MINSIZE bytes.  If a buffer of at
419    least that size is currently free, use it, otherwise create a new one. */
420
421 static struct buffer_record *
422 get_new_buffer (size_t min_size)
423 {
424   struct buffer_record *new_buffer; /* Buffer to return. */
425   size_t alloc_size;    /* Actual size that will be requested. */
426
427   alloc_size = START_SIZE;
428   if (alloc_size < min_size)
429     {
430       size_t s = min_size - alloc_size + INCR_SIZE - 1;
431       alloc_size += s - s % INCR_SIZE;
432     }
433
434   new_buffer = create_new_buffer (alloc_size);
435
436   new_buffer->num_lines = 0;
437   new_buffer->bytes_used = 0;
438   new_buffer->start_line = new_buffer->first_available = last_line_number + 1;
439   new_buffer->next = NULL;
440
441   return new_buffer;
442 }
443
444 static void
445 free_buffer (struct buffer_record *buf)
446 {
447   free (buf->buffer);
448 }
449
450 /* Append buffer BUF to the linked list of buffers that contain
451    some data yet to be processed. */
452
453 static void
454 save_buffer (struct buffer_record *buf)
455 {
456   struct buffer_record *p;
457
458   buf->next = NULL;
459   buf->curr_line = buf->line_start;
460
461   if (head == NULL)
462     head = buf;
463   else
464     {
465       for (p = head; p->next; p = p->next)
466         /* Do nothing. */ ;
467       p->next = buf;
468     }
469 }
470
471 /* Fill a buffer of input.
472
473    Set the initial size of the buffer to a default.
474    Fill the buffer (from the hold area and input stream)
475    and find the individual lines.
476    If no lines are found (the buffer is too small to hold the next line),
477    release the current buffer (whose contents would have been put in the
478    hold area) and repeat the process with another large buffer until at least
479    one entire line has been read.
480
481    Return true if a new buffer was obtained, otherwise false
482    (in which case end-of-file must have been encountered). */
483
484 static bool
485 load_buffer (void)
486 {
487   struct buffer_record *b;
488   size_t bytes_wanted = START_SIZE; /* Minimum buffer size. */
489   size_t bytes_avail;           /* Size of new buffer created. */
490   size_t lines_found;           /* Number of lines in this new buffer. */
491   char *p;                      /* Place to load into buffer. */
492
493   if (have_read_eof)
494     return false;
495
496   /* We must make the buffer at least as large as the amount of data
497      in the partial line left over from the last call. */
498   if (bytes_wanted < hold_count)
499     bytes_wanted = hold_count;
500
501   do
502     {
503       b = get_new_buffer (bytes_wanted);
504       bytes_avail = b->bytes_alloc; /* Size of buffer returned. */
505       p = b->buffer;
506
507       /* First check the `holding' area for a partial line. */
508       if (hold_count)
509         {
510           if (p != hold_area)
511             memcpy (p, hold_area, hold_count);
512           p += hold_count;
513           b->bytes_used += hold_count;
514           bytes_avail -= hold_count;
515           hold_count = 0;
516         }
517
518       b->bytes_used += read_input (p, bytes_avail);
519
520       lines_found = record_line_starts (b);
521       bytes_wanted = b->bytes_alloc * 2;
522       if (!lines_found)
523         free_buffer (b);
524     }
525   while (!lines_found && !have_read_eof);
526
527   if (lines_found)
528     save_buffer (b);
529
530   return lines_found != 0;
531 }
532
533 /* Return the line number of the first line that has not yet been retrieved. */
534
535 static uintmax_t
536 get_first_line_in_buffer (void)
537 {
538   if (head == NULL && !load_buffer ())
539     error (EXIT_FAILURE, errno, _("input disappeared"));
540
541   return head->first_available;
542 }
543
544 /* Return a pointer to the logical first line in the buffer and make the
545    next line the logical first line.
546    Return NULL if there is no more input. */
547
548 static struct cstring *
549 remove_line (void)
550 {
551   /* If non-NULL, this is the buffer for which the previous call
552      returned the final line.  So now, presuming that line has been
553      processed, we can free the buffer and reset this pointer.  */
554   static struct buffer_record *prev_buf = NULL;
555
556   struct cstring *line;         /* Return value. */
557   struct line *l;               /* For convenience. */
558
559   if (prev_buf)
560     {
561       free_buffer (prev_buf);
562       prev_buf = NULL;
563     }
564
565   if (head == NULL && !load_buffer ())
566     return NULL;
567
568   if (current_line < head->first_available)
569     current_line = head->first_available;
570
571   ++(head->first_available);
572
573   l = head->curr_line;
574
575   line = &l->starts[l->retrieve_index];
576
577   /* Advance index to next line. */
578   if (++l->retrieve_index == l->used)
579     {
580       /* Go on to the next line record. */
581       head->curr_line = l->next;
582       if (head->curr_line == NULL || head->curr_line->used == 0)
583         {
584           /* Go on to the next data block.
585              but first record the current one so we can free it
586              once the line we're returning has been processed.  */
587           prev_buf = head;
588           head = head->next;
589         }
590     }
591
592   return line;
593 }
594
595 /* Search the buffers for line LINENUM, reading more input if necessary.
596    Return a pointer to the line, or NULL if it is not found in the file. */
597
598 static struct cstring *
599 find_line (uintmax_t linenum)
600 {
601   struct buffer_record *b;
602
603   if (head == NULL && !load_buffer ())
604     return NULL;
605
606   if (linenum < head->start_line)
607     return NULL;
608
609   for (b = head;;)
610     {
611       if (linenum < b->start_line + b->num_lines)
612         {
613           /* The line is in this buffer. */
614           struct line *l;
615           size_t offset;        /* How far into the buffer the line is. */
616
617           l = b->line_start;
618           offset = linenum - b->start_line;
619           /* Find the control record. */
620           while (offset >= CTRL_SIZE)
621             {
622               l = l->next;
623               offset -= CTRL_SIZE;
624             }
625           return &l->starts[offset];
626         }
627       if (b->next == NULL && !load_buffer ())
628         return NULL;
629       b = b->next;              /* Try the next data block. */
630     }
631 }
632
633 /* Return true if at least one more line is available for input. */
634
635 static bool
636 no_more_lines (void)
637 {
638   return find_line (current_line + 1) == NULL;
639 }
640
641 /* Set the name of the input file to NAME and open it. */
642
643 static void
644 set_input_file (const char *name)
645 {
646   if (STREQ (name, "-"))
647     input_desc = STDIN_FILENO;
648   else
649     {
650       input_desc = open (name, O_RDONLY);
651       if (input_desc < 0)
652         error (EXIT_FAILURE, errno, "%s", name);
653     }
654 }
655
656 /* Write all lines from the beginning of the buffer up to, but
657    not including, line LAST_LINE, to the current output file.
658    If IGNORE is true, do not output lines selected here.
659    ARGNUM is the index in ARGV of the current pattern. */
660
661 static void
662 write_to_file (uintmax_t last_line, bool ignore, int argnum)
663 {
664   struct cstring *line;
665   uintmax_t first_line;         /* First available input line. */
666   uintmax_t lines;              /* Number of lines to output. */
667   uintmax_t i;
668
669   first_line = get_first_line_in_buffer ();
670
671   if (first_line > last_line)
672     {
673       error (0, 0, _("%s: line number out of range"), global_argv[argnum]);
674       cleanup_fatal ();
675     }
676
677   lines = last_line - first_line;
678
679   for (i = 0; i < lines; i++)
680     {
681       line = remove_line ();
682       if (line == NULL)
683         {
684           error (0, 0, _("%s: line number out of range"), global_argv[argnum]);
685           cleanup_fatal ();
686         }
687       if (!ignore)
688         save_line_to_file (line);
689     }
690 }
691
692 /* Output any lines left after all regexps have been processed. */
693
694 static void
695 dump_rest_of_file (void)
696 {
697   struct cstring *line;
698
699   while ((line = remove_line ()) != NULL)
700     save_line_to_file (line);
701 }
702
703 /* Handle an attempt to read beyond EOF under the control of record P,
704    on iteration REPETITION if nonzero. */
705
706 static void handle_line_error (const struct control *, uintmax_t)
707      ATTRIBUTE_NORETURN;
708 static void
709 handle_line_error (const struct control *p, uintmax_t repetition)
710 {
711   char buf[INT_BUFSIZE_BOUND (uintmax_t)];
712
713   fprintf (stderr, _("%s: `%s': line number out of range"),
714            program_name, umaxtostr (p->lines_required, buf));
715   if (repetition)
716     fprintf (stderr, _(" on repetition %s\n"), umaxtostr (repetition, buf));
717   else
718     fprintf (stderr, "\n");
719
720   cleanup_fatal ();
721 }
722
723 /* Determine the line number that marks the end of this file,
724    then get those lines and save them to the output file.
725    P is the control record.
726    REPETITION is the repetition number. */
727
728 static void
729 process_line_count (const struct control *p, uintmax_t repetition)
730 {
731   uintmax_t linenum;
732   uintmax_t last_line_to_save = p->lines_required * (repetition + 1);
733   struct cstring *line;
734
735   create_output_file ();
736
737   linenum = get_first_line_in_buffer ();
738
739   while (linenum++ < last_line_to_save)
740     {
741       line = remove_line ();
742       if (line == NULL)
743         handle_line_error (p, repetition);
744       save_line_to_file (line);
745     }
746
747   close_output_file ();
748
749   /* Ensure that the line number specified is not 1 greater than
750      the number of lines in the file. */
751   if (no_more_lines ())
752     handle_line_error (p, repetition);
753 }
754
755 static void regexp_error (struct control *, uintmax_t, bool) ATTRIBUTE_NORETURN;
756 static void
757 regexp_error (struct control *p, uintmax_t repetition, bool ignore)
758 {
759   fprintf (stderr, _("%s: `%s': match not found"),
760            program_name, global_argv[p->argnum]);
761
762   if (repetition)
763     {
764       char buf[INT_BUFSIZE_BOUND (uintmax_t)];
765       fprintf (stderr, _(" on repetition %s\n"), umaxtostr (repetition, buf));
766     }
767   else
768     fprintf (stderr, "\n");
769
770   if (!ignore)
771     {
772       dump_rest_of_file ();
773       close_output_file ();
774     }
775   cleanup_fatal ();
776 }
777
778 /* Read the input until a line matches the regexp in P, outputting
779    it unless P->IGNORE is true.
780    REPETITION is this repeat-count; 0 means the first time. */
781
782 static void
783 process_regexp (struct control *p, uintmax_t repetition)
784 {
785   struct cstring *line;         /* From input file. */
786   size_t line_len;              /* To make "$" in regexps work. */
787   uintmax_t break_line;         /* First line number of next file. */
788   bool ignore = p->ignore;      /* If true, skip this section. */
789   int ret;
790
791   if (!ignore)
792     create_output_file ();
793
794   /* If there is no offset for the regular expression, or
795      it is positive, then it is not necessary to buffer the lines. */
796
797   if (p->offset >= 0)
798     {
799       for (;;)
800         {
801           line = find_line (++current_line);
802           if (line == NULL)
803             {
804               if (p->repeat_forever)
805                 {
806                   if (!ignore)
807                     {
808                       dump_rest_of_file ();
809                       close_output_file ();
810                     }
811                   exit (EXIT_SUCCESS);
812                 }
813               else
814                 regexp_error (p, repetition, ignore);
815             }
816           line_len = line->len;
817           if (line->str[line_len - 1] == '\n')
818             line_len--;
819           ret = re_search (&p->re_compiled, line->str, line_len,
820                            0, line_len, NULL);
821           if (ret == -2)
822             {
823               error (0, 0, _("error in regular expression search"));
824               cleanup_fatal ();
825             }
826           if (ret == -1)
827             {
828               line = remove_line ();
829               if (!ignore)
830                 save_line_to_file (line);
831             }
832           else
833             break;
834         }
835     }
836   else
837     {
838       /* Buffer the lines. */
839       for (;;)
840         {
841           line = find_line (++current_line);
842           if (line == NULL)
843             {
844               if (p->repeat_forever)
845                 {
846                   if (!ignore)
847                     {
848                       dump_rest_of_file ();
849                       close_output_file ();
850                     }
851                   exit (EXIT_SUCCESS);
852                 }
853               else
854                 regexp_error (p, repetition, ignore);
855             }
856           line_len = line->len;
857           if (line->str[line_len - 1] == '\n')
858             line_len--;
859           ret = re_search (&p->re_compiled, line->str, line_len,
860                            0, line_len, NULL);
861           if (ret == -2)
862             {
863               error (0, 0, _("error in regular expression search"));
864               cleanup_fatal ();
865             }
866           if (ret >= 0)
867             break;
868         }
869     }
870
871   /* Account for any offset from this regexp. */
872   break_line = current_line + p->offset;
873
874   write_to_file (break_line, ignore, p->argnum);
875
876   if (!ignore)
877     close_output_file ();
878
879   if (p->offset > 0)
880     current_line = break_line;
881 }
882
883 /* Split the input file according to the control records we have built. */
884
885 static void
886 split_file (void)
887 {
888   size_t i;
889
890   for (i = 0; i < control_used; i++)
891     {
892       uintmax_t j;
893       if (controls[i].regexpr)
894         {
895           for (j = 0; (controls[i].repeat_forever
896                        || j <= controls[i].repeat); j++)
897             process_regexp (&controls[i], j);
898         }
899       else
900         {
901           for (j = 0; (controls[i].repeat_forever
902                        || j <= controls[i].repeat); j++)
903             process_line_count (&controls[i], j);
904         }
905     }
906
907   create_output_file ();
908   dump_rest_of_file ();
909   close_output_file ();
910 }
911
912 /* Return the name of output file number NUM.
913
914    This function is called from a signal handler, so it should invoke
915    only reentrant functions that are async-signal-safe.  POSIX does
916    not guarantee this for the functions called below, but we don't
917    know of any hosts where this implementation isn't safe.  */
918
919 static char *
920 make_filename (unsigned int num)
921 {
922   strcpy (filename_space, prefix);
923   if (suffix)
924     sprintf (filename_space + strlen (prefix), suffix, num);
925   else
926     sprintf (filename_space + strlen (prefix), "%0*u", digits, num);
927   return filename_space;
928 }
929
930 /* Create the next output file. */
931
932 static void
933 create_output_file (void)
934 {
935   sigset_t oldset;
936   bool fopen_ok;
937   int fopen_errno;
938
939   output_filename = make_filename (files_created);
940
941   /* Create the output file in a critical section, to avoid races.  */
942   sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
943   output_stream = fopen_safer (output_filename, "w");
944   fopen_ok = (output_stream != NULL);
945   fopen_errno = errno;
946   files_created += fopen_ok;
947   sigprocmask (SIG_SETMASK, &oldset, NULL);
948
949   if (! fopen_ok)
950     {
951       error (0, fopen_errno, "%s", output_filename);
952       cleanup_fatal ();
953     }
954   bytes_written = 0;
955 }
956
957 /* If requested, delete all the files we have created.  This function
958    must be called only from critical sections.  */
959
960 static void
961 delete_all_files (bool in_signal_handler)
962 {
963   unsigned int i;
964
965   if (! remove_files)
966     return;
967
968   for (i = 0; i < files_created; i++)
969     {
970       const char *name = make_filename (i);
971       if (unlink (name) != 0 && !in_signal_handler)
972         error (0, errno, "%s", name);
973     }
974
975   files_created = 0;
976 }
977
978 /* Close the current output file and print the count
979    of characters in this file. */
980
981 static void
982 close_output_file (void)
983 {
984   if (output_stream)
985     {
986       if (ferror (output_stream))
987         {
988           error (0, 0, _("write error for `%s'"), output_filename);
989           output_stream = NULL;
990           cleanup_fatal ();
991         }
992       if (fclose (output_stream) != 0)
993         {
994           error (0, errno, "%s", output_filename);
995           output_stream = NULL;
996           cleanup_fatal ();
997         }
998       if (bytes_written == 0 && elide_empty_files)
999         {
1000           sigset_t oldset;
1001           bool unlink_ok;
1002           int unlink_errno;
1003
1004           /* Remove the output file in a critical section, to avoid races.  */
1005           sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
1006           unlink_ok = (unlink (output_filename) == 0);
1007           unlink_errno = errno;
1008           files_created -= unlink_ok;
1009           sigprocmask (SIG_SETMASK, &oldset, NULL);
1010
1011           if (! unlink_ok)
1012             error (0, unlink_errno, "%s", output_filename);
1013         }
1014       else
1015         {
1016           if (!suppress_count)
1017             {
1018               char buf[INT_BUFSIZE_BOUND (uintmax_t)];
1019               fprintf (stdout, "%s\n", umaxtostr (bytes_written, buf));
1020             }
1021         }
1022       output_stream = NULL;
1023     }
1024 }
1025
1026 /* Save line LINE to the output file and
1027    increment the character count for the current file. */
1028
1029 static void
1030 save_line_to_file (const struct cstring *line)
1031 {
1032   fwrite (line->str, sizeof (char), line->len, output_stream);
1033   bytes_written += line->len;
1034 }
1035
1036 /* Return a new, initialized control record. */
1037
1038 static struct control *
1039 new_control_record (void)
1040 {
1041   static size_t control_allocated = 0; /* Total space allocated. */
1042   struct control *p;
1043
1044   if (control_used == control_allocated)
1045     controls = x2nrealloc (controls, &control_allocated, sizeof *controls);
1046   p = &controls[control_used++];
1047   p->regexpr = NULL;
1048   p->repeat = 0;
1049   p->repeat_forever = false;
1050   p->lines_required = 0;
1051   p->offset = 0;
1052   return p;
1053 }
1054
1055 /* Check if there is a numeric offset after a regular expression.
1056    STR is the entire command line argument.
1057    P is the control record for this regular expression.
1058    NUM is the numeric part of STR. */
1059
1060 static void
1061 check_for_offset (struct control *p, const char *str, const char *num)
1062 {
1063   if (xstrtoimax (num, NULL, 10, &p->offset, "") != LONGINT_OK)
1064     error (EXIT_FAILURE, 0, _("%s: integer expected after delimiter"), str);
1065 }
1066
1067 /* Given that the first character of command line arg STR is '{',
1068    make sure that the rest of the string is a valid repeat count
1069    and store its value in P.
1070    ARGNUM is the ARGV index of STR. */
1071
1072 static void
1073 parse_repeat_count (int argnum, struct control *p, char *str)
1074 {
1075   uintmax_t val;
1076   char *end;
1077
1078   end = str + strlen (str) - 1;
1079   if (*end != '}')
1080     error (EXIT_FAILURE, 0, _("%s: `}' is required in repeat count"), str);
1081   *end = '\0';
1082
1083   if (str+1 == end-1 && *(str+1) == '*')
1084     p->repeat_forever = true;
1085   else
1086     {
1087       if (xstrtoumax (str + 1, NULL, 10, &val, "") != LONGINT_OK)
1088         {
1089           error (EXIT_FAILURE, 0,
1090                  _("%s}: integer required between `{' and `}'"),
1091                  global_argv[argnum]);
1092         }
1093       p->repeat = val;
1094     }
1095
1096   *end = '}';
1097 }
1098
1099 /* Extract the regular expression from STR and check for a numeric offset.
1100    STR should start with the regexp delimiter character.
1101    Return a new control record for the regular expression.
1102    ARGNUM is the ARGV index of STR.
1103    Unless IGNORE is true, mark these lines for output. */
1104
1105 static struct control *
1106 extract_regexp (int argnum, bool ignore, char *str)
1107 {
1108   size_t len;                   /* Number of bytes in this regexp. */
1109   char delim = *str;
1110   char *closing_delim;
1111   struct control *p;
1112   const char *err;
1113
1114   closing_delim = strrchr (str + 1, delim);
1115   if (closing_delim == NULL)
1116     error (EXIT_FAILURE, 0,
1117            _("%s: closing delimiter `%c' missing"), str, delim);
1118
1119   len = closing_delim - str - 1;
1120   p = new_control_record ();
1121   p->argnum = argnum;
1122   p->ignore = ignore;
1123
1124   p->regexpr = xmalloc (len + 1);
1125   strncpy (p->regexpr, str + 1, len);
1126   p->re_compiled.allocated = len * 2;
1127   p->re_compiled.buffer = xmalloc (p->re_compiled.allocated);
1128   p->re_compiled.fastmap = xmalloc (1 << CHAR_BIT);
1129   p->re_compiled.translate = NULL;
1130   err = re_compile_pattern (p->regexpr, len, &p->re_compiled);
1131   if (err)
1132     {
1133       error (0, 0, _("%s: invalid regular expression: %s"), str, err);
1134       cleanup_fatal ();
1135     }
1136
1137   if (closing_delim[1])
1138     check_for_offset (p, str, closing_delim + 1);
1139
1140   return p;
1141 }
1142
1143 /* Extract the break patterns from args START through ARGC - 1 of ARGV.
1144    After each pattern, check if the next argument is a repeat count. */
1145
1146 static void
1147 parse_patterns (int argc, int start, char **argv)
1148 {
1149   int i;                        /* Index into ARGV. */
1150   struct control *p;            /* New control record created. */
1151   uintmax_t val;
1152   static uintmax_t last_val = 0;
1153
1154   for (i = start; i < argc; i++)
1155     {
1156       if (*argv[i] == '/' || *argv[i] == '%')
1157         {
1158           p = extract_regexp (i, *argv[i] == '%', argv[i]);
1159         }
1160       else
1161         {
1162           p = new_control_record ();
1163           p->argnum = i;
1164
1165           if (xstrtoumax (argv[i], NULL, 10, &val, "") != LONGINT_OK)
1166             error (EXIT_FAILURE, 0, _("%s: invalid pattern"), argv[i]);
1167           if (val == 0)
1168             error (EXIT_FAILURE, 0,
1169                    _("%s: line number must be greater than zero"),
1170                    argv[i]);
1171           if (val < last_val)
1172             {
1173               char buf[INT_BUFSIZE_BOUND (uintmax_t)];
1174               error (EXIT_FAILURE, 0,
1175                _("line number `%s' is smaller than preceding line number, %s"),
1176                      argv[i], umaxtostr (last_val, buf));
1177             }
1178
1179           if (val == last_val)
1180             error (0, 0,
1181            _("warning: line number `%s' is the same as preceding line number"),
1182                    argv[i]);
1183
1184           last_val = val;
1185
1186           p->lines_required = val;
1187         }
1188
1189       if (i + 1 < argc && *argv[i + 1] == '{')
1190         {
1191           /* We have a repeat count. */
1192           i++;
1193           parse_repeat_count (i, p, argv[i]);
1194         }
1195     }
1196 }
1197
1198 static unsigned int
1199 get_format_flags (char **format_ptr)
1200 {
1201   unsigned int count = 0;
1202
1203   for (; **format_ptr; (*format_ptr)++)
1204     {
1205       switch (**format_ptr)
1206         {
1207         case '-':
1208           break;
1209
1210         case '+':
1211         case ' ':
1212           count |= 1;
1213           break;
1214
1215         case '#':
1216           count |= 2;   /* Allow for 0x prefix preceding an `x' conversion.  */
1217           break;
1218
1219         default:
1220           return count;
1221         }
1222     }
1223   return count;
1224 }
1225
1226 static size_t
1227 get_format_width (char **format_ptr)
1228 {
1229   unsigned long int val = 0;
1230
1231   if (ISDIGIT (**format_ptr)
1232       && (xstrtoul (*format_ptr, format_ptr, 10, &val, NULL) != LONGINT_OK
1233           || SIZE_MAX < val))
1234     error (EXIT_FAILURE, 0, _("invalid format width"));
1235
1236   /* Allow for enough octal digits to represent the value of UINT_MAX,
1237      even if the field width is less than that.  */
1238   return MAX (val, (sizeof (unsigned int) * CHAR_BIT + 2) / 3);
1239 }
1240
1241 static size_t
1242 get_format_prec (char **format_ptr)
1243 {
1244   if (**format_ptr != '.')
1245     return 0;
1246   (*format_ptr)++;
1247
1248   if (! ISDIGIT (**format_ptr))
1249     return 0;
1250   else
1251     {
1252       unsigned long int val;
1253       if (xstrtoul (*format_ptr, format_ptr, 10, &val, NULL) != LONGINT_OK
1254           || SIZE_MAX < val)
1255         error (EXIT_FAILURE, 0, _("invalid format precision"));
1256       return val;
1257     }
1258 }
1259
1260 static void
1261 get_format_conv_type (char **format_ptr)
1262 {
1263   unsigned char ch = *(*format_ptr)++;
1264
1265   switch (ch)
1266     {
1267     case 'd':
1268     case 'i':
1269     case 'o':
1270     case 'u':
1271     case 'x':
1272     case 'X':
1273       break;
1274
1275     case 0:
1276       error (EXIT_FAILURE, 0, _("missing conversion specifier in suffix"));
1277       break;
1278
1279     default:
1280       if (ISPRINT (ch))
1281         error (EXIT_FAILURE, 0,
1282                _("invalid conversion specifier in suffix: %c"), ch);
1283       else
1284         error (EXIT_FAILURE, 0,
1285                _("invalid conversion specifier in suffix: \\%.3o"), ch);
1286     }
1287 }
1288
1289 static size_t
1290 max_out (char *format)
1291 {
1292   size_t out_count = 0;
1293   bool percent = false;
1294
1295   while (*format)
1296     {
1297       if (*format++ != '%')
1298         out_count++;
1299       else if (*format == '%')
1300         {
1301           format++;
1302           out_count++;
1303         }
1304       else
1305         {
1306           if (percent)
1307             error (EXIT_FAILURE, 0,
1308                    _("too many %% conversion specifications in suffix"));
1309           percent = true;
1310           out_count += get_format_flags (&format);
1311           {
1312             size_t width = get_format_width (&format);
1313             size_t prec = get_format_prec (&format);
1314
1315             out_count += MAX (width, prec);
1316           }
1317           get_format_conv_type (&format);
1318         }
1319     }
1320
1321   if (! percent)
1322     error (EXIT_FAILURE, 0,
1323            _("missing %% conversion specification in suffix"));
1324
1325   return out_count;
1326 }
1327
1328 int
1329 main (int argc, char **argv)
1330 {
1331   int optc;
1332   unsigned long int val;
1333
1334   initialize_main (&argc, &argv);
1335   program_name = argv[0];
1336   setlocale (LC_ALL, "");
1337   bindtextdomain (PACKAGE, LOCALEDIR);
1338   textdomain (PACKAGE);
1339
1340   atexit (close_stdout);
1341
1342   global_argv = argv;
1343   controls = NULL;
1344   control_used = 0;
1345   suppress_count = false;
1346   remove_files = true;
1347   prefix = DEFAULT_PREFIX;
1348
1349   while ((optc = getopt_long (argc, argv, "f:b:kn:sqz", longopts, NULL)) != -1)
1350     switch (optc)
1351       {
1352       case 'f':
1353         prefix = optarg;
1354         break;
1355
1356       case 'b':
1357         suffix = optarg;
1358         break;
1359
1360       case 'k':
1361         remove_files = false;
1362         break;
1363
1364       case 'n':
1365         if (xstrtoul (optarg, NULL, 10, &val, "") != LONGINT_OK
1366             || val > INT_MAX)
1367           error (EXIT_FAILURE, 0, _("%s: invalid number"), optarg);
1368         digits = val;
1369         break;
1370
1371       case 's':
1372       case 'q':
1373         suppress_count = true;
1374         break;
1375
1376       case 'z':
1377         elide_empty_files = true;
1378         break;
1379
1380       case_GETOPT_HELP_CHAR;
1381
1382       case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1383
1384       default:
1385         usage (EXIT_FAILURE);
1386       }
1387
1388   if (argc - optind < 2)
1389     {
1390       if (argc <= optind)
1391         error (0, 0, _("missing operand"));
1392       else
1393         error (0, 0, _("missing operand after %s"), quote (argv[argc - 1]));
1394       usage (EXIT_FAILURE);
1395     }
1396
1397   if (suffix)
1398     filename_space = xmalloc (strlen (prefix) + max_out (suffix) + 2);
1399   else
1400     filename_space = xmalloc (strlen (prefix) + digits + 2);
1401
1402   set_input_file (argv[optind++]);
1403
1404   parse_patterns (argc, optind, argv);
1405
1406   {
1407     int i;
1408     static int const sig[] = { SIGHUP, SIGINT, SIGQUIT, SIGTERM };
1409     enum { nsigs = sizeof sig / sizeof sig[0] };
1410
1411 #if SA_NOCLDSTOP
1412     struct sigaction act;
1413
1414     sigemptyset (&caught_signals);
1415     for (i = 0; i < nsigs; i++)
1416       {
1417         sigaction (sig[i], NULL, &act);
1418         if (act.sa_handler != SIG_IGN)
1419           sigaddset (&caught_signals, sig[i]);
1420       }
1421
1422     act.sa_handler = interrupt_handler;
1423     act.sa_mask = caught_signals;
1424     act.sa_flags = 0;
1425
1426     for (i = 0; i < nsigs; i++)
1427       if (sigismember (&caught_signals, sig[i]))
1428         sigaction (sig[i], &act, NULL);
1429 #else
1430     for (i = 0; i < nsigs; i++)
1431       if (signal (sig[i], SIG_IGN) != SIG_IGN)
1432         {
1433           signal (sig[i], interrupt_handler);
1434           siginterrupt (sig[i], 1);
1435         }
1436 #endif
1437   }
1438
1439   split_file ();
1440
1441   if (close (input_desc) < 0)
1442     {
1443       error (0, errno, _("read error"));
1444       cleanup_fatal ();
1445     }
1446
1447   exit (EXIT_SUCCESS);
1448 }
1449
1450 void
1451 usage (int status)
1452 {
1453   if (status != EXIT_SUCCESS)
1454     fprintf (stderr, _("Try `%s --help' for more information.\n"),
1455              program_name);
1456   else
1457     {
1458       printf (_("\
1459 Usage: %s [OPTION]... FILE PATTERN...\n\
1460 "),
1461               program_name);
1462       fputs (_("\
1463 Output pieces of FILE separated by PATTERN(s) to files `xx00', `xx01', ...,\n\
1464 and output byte counts of each piece to standard output.\n\
1465 \n\
1466 "), stdout);
1467       fputs (_("\
1468 Mandatory arguments to long options are mandatory for short options too.\n\
1469 "), stdout);
1470       fputs (_("\
1471   -b, --suffix-format=FORMAT use sprintf FORMAT instead of %02d\n\
1472   -f, --prefix=PREFIX        use PREFIX instead of `xx'\n\
1473   -k, --keep-files           do not remove output files on errors\n\
1474 "), stdout);
1475       fputs (_("\
1476   -n, --digits=DIGITS        use specified number of digits instead of 2\n\
1477   -s, --quiet, --silent      do not print counts of output file sizes\n\
1478   -z, --elide-empty-files    remove empty output files\n\
1479 "), stdout);
1480       fputs (HELP_OPTION_DESCRIPTION, stdout);
1481       fputs (VERSION_OPTION_DESCRIPTION, stdout);
1482       fputs (_("\
1483 \n\
1484 Read standard input if FILE is -.  Each PATTERN may be:\n\
1485 "), stdout);
1486       fputs (_("\
1487 \n\
1488   INTEGER            copy up to but not including specified line number\n\
1489   /REGEXP/[OFFSET]   copy up to but not including a matching line\n\
1490   %REGEXP%[OFFSET]   skip to, but not including a matching line\n\
1491   {INTEGER}          repeat the previous pattern specified number of times\n\
1492   {*}                repeat the previous pattern as many times as possible\n\
1493 \n\
1494 A line OFFSET is a required `+' or `-' followed by a positive integer.\n\
1495 "), stdout);
1496       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
1497     }
1498   exit (status);
1499 }