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