1 /* csplit - split a file into sections determined by context lines
2 Copyright (C) 91, 1995-2006 Free Software Foundation, Inc.
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)
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.
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 02110-1301, USA. */
18 /* Written by Stuart Kemp, cpsrk@groper.jcu.edu.au.
19 Modified by David MacKenzie, djm@gnu.ai.mit.edu. */
24 #include <sys/types.h>
32 #include "fd-reopen.h"
35 #include "safe-read.h"
39 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
42 # define SA_NOCLDSTOP 0
43 # define sigprocmask(How, Set, Oset) /* empty */
45 # if ! HAVE_SIGINTERRUPT
46 # define siginterrupt(sig, flag) /* empty */
50 /* The official name of this program (e.g., no `g' prefix). */
51 #define PROGRAM_NAME "csplit"
53 #define AUTHORS "Stuart Kemp", "David MacKenzie"
55 /* Increment size of area for control records. */
58 /* The default prefix for output file names. */
59 #define DEFAULT_PREFIX "xx"
61 /* A compiled pattern arg. */
64 intmax_t offset; /* Offset from regexp to split at. */
65 uintmax_t lines_required; /* Number of lines required. */
66 uintmax_t repeat; /* Repeat count. */
67 int argnum; /* ARGV index. */
68 bool repeat_forever; /* True if `*' used as a repeat count. */
69 bool ignore; /* If true, produce no output (for regexp). */
70 bool regexpr; /* True if regular expression was used. */
71 struct re_pattern_buffer re_compiled; /* Compiled regular expression. */
74 /* Initial size of data area in buffers. */
75 #define START_SIZE 8191
77 /* Increment size for data area. */
78 #define INCR_SIZE 2048
80 /* Number of lines kept in each node in line list. */
84 /* Some small values to test the algorithms. */
85 # define START_SIZE 200
90 /* A string with a length count. */
97 /* Pointers to the beginnings of lines in the buffer area.
98 These structures are linked together if needed. */
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. */
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. */
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;
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);
130 /* The name this program was run with. */
133 /* Start of buffer list. */
134 static struct buffer_record *head = NULL;
136 /* Partially read line. */
137 static char *hold_area = NULL;
139 /* Number of bytes in `hold_area'. */
140 static size_t hold_count = 0;
142 /* Number of the last line in the buffers. */
143 static uintmax_t last_line_number = 0;
145 /* Number of the line currently being examined. */
146 static uintmax_t current_line = 0;
148 /* If true, we have read EOF. */
149 static bool have_read_eof = false;
151 /* Name of output files. */
152 static char *volatile filename_space = NULL;
154 /* Prefix part of output file names. */
155 static char const *volatile prefix = NULL;
157 /* Suffix part of output file names. */
158 static char *volatile suffix = NULL;
160 /* Number of digits to use in output file names. */
161 static int volatile digits = 2;
163 /* Number of files created so far. */
164 static unsigned int volatile files_created = 0;
166 /* Number of bytes written to current file. */
167 static uintmax_t bytes_written;
169 /* Output file pointer. */
170 static FILE *output_stream = NULL;
172 /* Output file name. */
173 static char *output_filename = NULL;
175 /* Perhaps it would be cleaner to pass arg values instead of indexes. */
176 static char **global_argv;
178 /* If true, do not print the count of bytes in each output file. */
179 static bool suppress_count;
181 /* If true, remove output files on error. */
182 static bool volatile remove_files;
184 /* If true, remove all output files which have a zero length. */
185 static bool elide_empty_files;
187 /* The compiled pattern arguments, which determine how to split
189 static struct control *controls;
191 /* Number of elements in `controls'. */
192 static size_t control_used;
194 /* The set of signals that are caught. */
195 static sigset_t caught_signals;
197 static struct option const longopts[] =
199 {"digits", required_argument, NULL, 'n'},
200 {"quiet", no_argument, NULL, 'q'},
201 {"silent", no_argument, NULL, 's'},
202 {"keep-files", no_argument, NULL, 'k'},
203 {"elide-empty-files", no_argument, NULL, 'z'},
204 {"prefix", required_argument, NULL, 'f'},
205 {"suffix-format", required_argument, NULL, 'b'},
206 {GETOPT_HELP_OPTION_DECL},
207 {GETOPT_VERSION_OPTION_DECL},
211 /* Optionally remove files created so far; then exit.
212 Called when an error detected. */
219 close_output_file ();
221 sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
222 delete_all_files (false);
223 sigprocmask (SIG_SETMASK, &oldset, NULL);
226 static void cleanup_fatal (void) ATTRIBUTE_NORETURN;
237 error (0, 0, "%s", _("memory exhausted"));
242 interrupt_handler (int sig)
245 signal (sig, SIG_IGN);
247 delete_all_files (true);
249 signal (sig, SIG_DFL);
253 /* Keep track of NUM bytes of a partial line in buffer START.
254 These bytes will be retrieved later when another large buffer is read. */
257 save_to_hold_area (char *start, size_t num)
264 /* Read up to MAX_N_BYTES bytes from the input stream into DEST.
265 Return the number of bytes read. */
268 read_input (char *dest, size_t max_n_bytes)
272 if (max_n_bytes == 0)
275 bytes_read = safe_read (STDIN_FILENO, dest, max_n_bytes);
278 have_read_eof = true;
280 if (bytes_read == SAFE_READ_ERROR)
282 error (0, errno, _("read error"));
289 /* Initialize existing line record P. */
292 clear_line_control (struct line *p)
296 p->retrieve_index = 0;
299 /* Return a new, initialized line record. */
302 new_line_control (void)
304 struct line *p = xmalloc (sizeof *p);
307 clear_line_control (p);
312 /* Record LINE_START, which is the address of the start of a line
313 of length LINE_LEN in the large buffer, in the lines buffer of B. */
316 keep_new_line (struct buffer_record *b, char *line_start, size_t line_len)
320 /* If there is no existing area to keep line info, get some. */
321 if (b->line_start == NULL)
322 b->line_start = b->curr_line = new_line_control ();
324 /* If existing area for lines is full, get more. */
325 if (b->curr_line->used == CTRL_SIZE)
327 b->curr_line->next = new_line_control ();
328 b->curr_line = b->curr_line->next;
333 /* Record the start of the line, and update counters. */
334 l->starts[l->insert_index].str = line_start;
335 l->starts[l->insert_index].len = line_len;
340 /* Scan the buffer in B for newline characters
341 and record the line start locations and lengths in B.
342 Return the number of lines found in this buffer.
344 There may be an incomplete line at the end of the buffer;
345 a pointer is kept to this area, which will be used when
346 the next buffer is filled. */
349 record_line_starts (struct buffer_record *b)
351 char *line_start; /* Start of current line. */
352 char *line_end; /* End of each line found. */
353 size_t bytes_left; /* Length of incomplete last line. */
354 size_t lines; /* Number of lines found. */
355 size_t line_length; /* Length of each line found. */
357 if (b->bytes_used == 0)
361 line_start = b->buffer;
362 bytes_left = b->bytes_used;
366 line_end = memchr (line_start, '\n', bytes_left);
367 if (line_end == NULL)
369 line_length = line_end - line_start + 1;
370 keep_new_line (b, line_start, line_length);
371 bytes_left -= line_length;
372 line_start = line_end + 1;
376 /* Check for an incomplete last line. */
381 keep_new_line (b, line_start, bytes_left);
385 save_to_hold_area (xmemdup (line_start, bytes_left), bytes_left);
388 b->num_lines = lines;
389 b->first_available = b->start_line = last_line_number + 1;
390 last_line_number += lines;
395 /* Return a new buffer with room to store SIZE bytes, plus
396 an extra byte for safety. */
398 static struct buffer_record *
399 create_new_buffer (size_t size)
401 struct buffer_record *new_buffer = xmalloc (sizeof *new_buffer);
403 new_buffer->buffer = xmalloc (size + 1);
405 new_buffer->bytes_alloc = size;
406 new_buffer->line_start = new_buffer->curr_line = NULL;
411 /* Return a new buffer of at least MINSIZE bytes. If a buffer of at
412 least that size is currently free, use it, otherwise create a new one. */
414 static struct buffer_record *
415 get_new_buffer (size_t min_size)
417 struct buffer_record *new_buffer; /* Buffer to return. */
418 size_t alloc_size; /* Actual size that will be requested. */
420 alloc_size = START_SIZE;
421 if (alloc_size < min_size)
423 size_t s = min_size - alloc_size + INCR_SIZE - 1;
424 alloc_size += s - s % INCR_SIZE;
427 new_buffer = create_new_buffer (alloc_size);
429 new_buffer->num_lines = 0;
430 new_buffer->bytes_used = 0;
431 new_buffer->start_line = new_buffer->first_available = last_line_number + 1;
432 new_buffer->next = NULL;
438 free_buffer (struct buffer_record *buf)
444 /* Append buffer BUF to the linked list of buffers that contain
445 some data yet to be processed. */
448 save_buffer (struct buffer_record *buf)
450 struct buffer_record *p;
453 buf->curr_line = buf->line_start;
459 for (p = head; p->next; p = p->next)
465 /* Fill a buffer of input.
467 Set the initial size of the buffer to a default.
468 Fill the buffer (from the hold area and input stream)
469 and find the individual lines.
470 If no lines are found (the buffer is too small to hold the next line),
471 release the current buffer (whose contents would have been put in the
472 hold area) and repeat the process with another large buffer until at least
473 one entire line has been read.
475 Return true if a new buffer was obtained, otherwise false
476 (in which case end-of-file must have been encountered). */
481 struct buffer_record *b;
482 size_t bytes_wanted = START_SIZE; /* Minimum buffer size. */
483 size_t bytes_avail; /* Size of new buffer created. */
484 size_t lines_found; /* Number of lines in this new buffer. */
485 char *p; /* Place to load into buffer. */
490 /* We must make the buffer at least as large as the amount of data
491 in the partial line left over from the last call. */
492 if (bytes_wanted < hold_count)
493 bytes_wanted = hold_count;
497 b = get_new_buffer (bytes_wanted);
498 bytes_avail = b->bytes_alloc; /* Size of buffer returned. */
501 /* First check the `holding' area for a partial line. */
504 memcpy (p, hold_area, hold_count);
506 b->bytes_used += hold_count;
507 bytes_avail -= hold_count;
511 b->bytes_used += read_input (p, bytes_avail);
513 lines_found = record_line_starts (b);
517 if (lines_found || have_read_eof)
520 if (xalloc_oversized (2, b->bytes_alloc))
522 bytes_wanted = 2 * b->bytes_alloc;
530 return lines_found != 0;
533 /* Return the line number of the first line that has not yet been retrieved. */
536 get_first_line_in_buffer (void)
538 if (head == NULL && !load_buffer ())
539 error (EXIT_FAILURE, errno, _("input disappeared"));
541 return head->first_available;
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. */
548 static struct cstring *
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;
556 struct cstring *line; /* Return value. */
557 struct line *l; /* For convenience. */
561 free_buffer (prev_buf);
565 if (head == NULL && !load_buffer ())
568 if (current_line < head->first_available)
569 current_line = head->first_available;
571 ++(head->first_available);
575 line = &l->starts[l->retrieve_index];
577 /* Advance index to next line. */
578 if (++l->retrieve_index == l->used)
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)
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. */
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. */
598 static struct cstring *
599 find_line (uintmax_t linenum)
601 struct buffer_record *b;
603 if (head == NULL && !load_buffer ())
606 if (linenum < head->start_line)
611 if (linenum < b->start_line + b->num_lines)
613 /* The line is in this buffer. */
615 size_t offset; /* How far into the buffer the line is. */
618 offset = linenum - b->start_line;
619 /* Find the control record. */
620 while (offset >= CTRL_SIZE)
625 return &l->starts[offset];
627 if (b->next == NULL && !load_buffer ())
629 b = b->next; /* Try the next data block. */
633 /* Return true if at least one more line is available for input. */
638 return find_line (current_line + 1) == NULL;
641 /* Open NAME as standard input. */
644 set_input_file (const char *name)
646 if (! STREQ (name, "-") && fd_reopen (STDIN_FILENO, name, O_RDONLY, 0) < 0)
647 error (EXIT_FAILURE, errno, _("cannot open %s for reading"), quote (name));
650 /* Write all lines from the beginning of the buffer up to, but
651 not including, line LAST_LINE, to the current output file.
652 If IGNORE is true, do not output lines selected here.
653 ARGNUM is the index in ARGV of the current pattern. */
656 write_to_file (uintmax_t last_line, bool ignore, int argnum)
658 struct cstring *line;
659 uintmax_t first_line; /* First available input line. */
660 uintmax_t lines; /* Number of lines to output. */
663 first_line = get_first_line_in_buffer ();
665 if (first_line > last_line)
667 error (0, 0, _("%s: line number out of range"), global_argv[argnum]);
671 lines = last_line - first_line;
673 for (i = 0; i < lines; i++)
675 line = remove_line ();
678 error (0, 0, _("%s: line number out of range"), global_argv[argnum]);
682 save_line_to_file (line);
686 /* Output any lines left after all regexps have been processed. */
689 dump_rest_of_file (void)
691 struct cstring *line;
693 while ((line = remove_line ()) != NULL)
694 save_line_to_file (line);
697 /* Handle an attempt to read beyond EOF under the control of record P,
698 on iteration REPETITION if nonzero. */
700 static void handle_line_error (const struct control *, uintmax_t)
703 handle_line_error (const struct control *p, uintmax_t repetition)
705 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
707 fprintf (stderr, _("%s: %s: line number out of range"),
708 program_name, quote (umaxtostr (p->lines_required, buf)));
710 fprintf (stderr, _(" on repetition %s\n"), umaxtostr (repetition, buf));
712 fprintf (stderr, "\n");
717 /* Determine the line number that marks the end of this file,
718 then get those lines and save them to the output file.
719 P is the control record.
720 REPETITION is the repetition number. */
723 process_line_count (const struct control *p, uintmax_t repetition)
726 uintmax_t last_line_to_save = p->lines_required * (repetition + 1);
727 struct cstring *line;
729 create_output_file ();
731 linenum = get_first_line_in_buffer ();
733 while (linenum++ < last_line_to_save)
735 line = remove_line ();
737 handle_line_error (p, repetition);
738 save_line_to_file (line);
741 close_output_file ();
743 /* Ensure that the line number specified is not 1 greater than
744 the number of lines in the file. */
745 if (no_more_lines ())
746 handle_line_error (p, repetition);
749 static void regexp_error (struct control *, uintmax_t, bool) ATTRIBUTE_NORETURN;
751 regexp_error (struct control *p, uintmax_t repetition, bool ignore)
753 fprintf (stderr, _("%s: %s: match not found"),
754 program_name, quote (global_argv[p->argnum]));
758 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
759 fprintf (stderr, _(" on repetition %s\n"), umaxtostr (repetition, buf));
762 fprintf (stderr, "\n");
766 dump_rest_of_file ();
767 close_output_file ();
772 /* Read the input until a line matches the regexp in P, outputting
773 it unless P->IGNORE is true.
774 REPETITION is this repeat-count; 0 means the first time. */
777 process_regexp (struct control *p, uintmax_t repetition)
779 struct cstring *line; /* From input file. */
780 size_t line_len; /* To make "$" in regexps work. */
781 uintmax_t break_line; /* First line number of next file. */
782 bool ignore = p->ignore; /* If true, skip this section. */
786 create_output_file ();
788 /* If there is no offset for the regular expression, or
789 it is positive, then it is not necessary to buffer the lines. */
795 line = find_line (++current_line);
798 if (p->repeat_forever)
802 dump_rest_of_file ();
803 close_output_file ();
808 regexp_error (p, repetition, ignore);
810 line_len = line->len;
811 if (line->str[line_len - 1] == '\n')
813 ret = re_search (&p->re_compiled, line->str, line_len,
817 error (0, 0, _("error in regular expression search"));
822 line = remove_line ();
824 save_line_to_file (line);
832 /* Buffer the lines. */
835 line = find_line (++current_line);
838 if (p->repeat_forever)
842 dump_rest_of_file ();
843 close_output_file ();
848 regexp_error (p, repetition, ignore);
850 line_len = line->len;
851 if (line->str[line_len - 1] == '\n')
853 ret = re_search (&p->re_compiled, line->str, line_len,
857 error (0, 0, _("error in regular expression search"));
865 /* Account for any offset from this regexp. */
866 break_line = current_line + p->offset;
868 write_to_file (break_line, ignore, p->argnum);
871 close_output_file ();
874 current_line = break_line;
877 /* Split the input file according to the control records we have built. */
884 for (i = 0; i < control_used; i++)
887 if (controls[i].regexpr)
889 for (j = 0; (controls[i].repeat_forever
890 || j <= controls[i].repeat); j++)
891 process_regexp (&controls[i], j);
895 for (j = 0; (controls[i].repeat_forever
896 || j <= controls[i].repeat); j++)
897 process_line_count (&controls[i], j);
901 create_output_file ();
902 dump_rest_of_file ();
903 close_output_file ();
906 /* Return the name of output file number NUM.
908 This function is called from a signal handler, so it should invoke
909 only reentrant functions that are async-signal-safe. POSIX does
910 not guarantee this for the functions called below, but we don't
911 know of any hosts where this implementation isn't safe. */
914 make_filename (unsigned int num)
916 strcpy (filename_space, prefix);
918 sprintf (filename_space + strlen (prefix), suffix, num);
920 sprintf (filename_space + strlen (prefix), "%0*u", digits, num);
921 return filename_space;
924 /* Create the next output file. */
927 create_output_file (void)
933 output_filename = make_filename (files_created);
935 /* Create the output file in a critical section, to avoid races. */
936 sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
937 output_stream = fopen (output_filename, "w");
938 fopen_ok = (output_stream != NULL);
940 files_created += fopen_ok;
941 sigprocmask (SIG_SETMASK, &oldset, NULL);
945 error (0, fopen_errno, "%s", output_filename);
951 /* If requested, delete all the files we have created. This function
952 must be called only from critical sections. */
955 delete_all_files (bool in_signal_handler)
962 for (i = 0; i < files_created; i++)
964 const char *name = make_filename (i);
965 if (unlink (name) != 0 && !in_signal_handler)
966 error (0, errno, "%s", name);
972 /* Close the current output file and print the count
973 of characters in this file. */
976 close_output_file (void)
980 if (ferror (output_stream))
982 error (0, 0, _("write error for %s"), quote (output_filename));
983 output_stream = NULL;
986 if (fclose (output_stream) != 0)
988 error (0, errno, "%s", output_filename);
989 output_stream = NULL;
992 if (bytes_written == 0 && elide_empty_files)
998 /* Remove the output file in a critical section, to avoid races. */
999 sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
1000 unlink_ok = (unlink (output_filename) == 0);
1001 unlink_errno = errno;
1002 files_created -= unlink_ok;
1003 sigprocmask (SIG_SETMASK, &oldset, NULL);
1006 error (0, unlink_errno, "%s", output_filename);
1010 if (!suppress_count)
1012 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
1013 fprintf (stdout, "%s\n", umaxtostr (bytes_written, buf));
1016 output_stream = NULL;
1020 /* Save line LINE to the output file and
1021 increment the character count for the current file. */
1024 save_line_to_file (const struct cstring *line)
1026 fwrite (line->str, sizeof (char), line->len, output_stream);
1027 bytes_written += line->len;
1030 /* Return a new, initialized control record. */
1032 static struct control *
1033 new_control_record (void)
1035 static size_t control_allocated = 0; /* Total space allocated. */
1038 if (control_used == control_allocated)
1039 controls = X2NREALLOC (controls, &control_allocated);
1040 p = &controls[control_used++];
1043 p->repeat_forever = false;
1044 p->lines_required = 0;
1049 /* Check if there is a numeric offset after a regular expression.
1050 STR is the entire command line argument.
1051 P is the control record for this regular expression.
1052 NUM is the numeric part of STR. */
1055 check_for_offset (struct control *p, const char *str, const char *num)
1057 if (xstrtoimax (num, NULL, 10, &p->offset, "") != LONGINT_OK)
1058 error (EXIT_FAILURE, 0, _("%s: integer expected after delimiter"), str);
1061 /* Given that the first character of command line arg STR is '{',
1062 make sure that the rest of the string is a valid repeat count
1063 and store its value in P.
1064 ARGNUM is the ARGV index of STR. */
1067 parse_repeat_count (int argnum, struct control *p, char *str)
1072 end = str + strlen (str) - 1;
1074 error (EXIT_FAILURE, 0, _("%s: `}' is required in repeat count"), str);
1077 if (str+1 == end-1 && *(str+1) == '*')
1078 p->repeat_forever = true;
1081 if (xstrtoumax (str + 1, NULL, 10, &val, "") != LONGINT_OK)
1083 error (EXIT_FAILURE, 0,
1084 _("%s}: integer required between `{' and `}'"),
1085 global_argv[argnum]);
1093 /* Extract the regular expression from STR and check for a numeric offset.
1094 STR should start with the regexp delimiter character.
1095 Return a new control record for the regular expression.
1096 ARGNUM is the ARGV index of STR.
1097 Unless IGNORE is true, mark these lines for output. */
1099 static struct control *
1100 extract_regexp (int argnum, bool ignore, char const *str)
1102 size_t len; /* Number of bytes in this regexp. */
1104 char const *closing_delim;
1108 closing_delim = strrchr (str + 1, delim);
1109 if (closing_delim == NULL)
1110 error (EXIT_FAILURE, 0,
1111 _("%s: closing delimiter `%c' missing"), str, delim);
1113 len = closing_delim - str - 1;
1114 p = new_control_record ();
1119 p->re_compiled.buffer = NULL;
1120 p->re_compiled.allocated = 0;
1121 p->re_compiled.fastmap = xmalloc (UCHAR_MAX + 1);
1122 p->re_compiled.translate = NULL;
1124 RE_SYNTAX_POSIX_BASIC & ~RE_CONTEXT_INVALID_DUP & ~RE_NO_EMPTY_RANGES;
1125 err = re_compile_pattern (str + 1, len, &p->re_compiled);
1128 error (0, 0, _("%s: invalid regular expression: %s"), str, err);
1132 if (closing_delim[1])
1133 check_for_offset (p, str, closing_delim + 1);
1138 /* Extract the break patterns from args START through ARGC - 1 of ARGV.
1139 After each pattern, check if the next argument is a repeat count. */
1142 parse_patterns (int argc, int start, char **argv)
1144 int i; /* Index into ARGV. */
1145 struct control *p; /* New control record created. */
1147 static uintmax_t last_val = 0;
1149 for (i = start; i < argc; i++)
1151 if (*argv[i] == '/' || *argv[i] == '%')
1153 p = extract_regexp (i, *argv[i] == '%', argv[i]);
1157 p = new_control_record ();
1160 if (xstrtoumax (argv[i], NULL, 10, &val, "") != LONGINT_OK)
1161 error (EXIT_FAILURE, 0, _("%s: invalid pattern"), argv[i]);
1163 error (EXIT_FAILURE, 0,
1164 _("%s: line number must be greater than zero"),
1168 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
1169 error (EXIT_FAILURE, 0,
1170 _("line number %s is smaller than preceding line number, %s"),
1171 quote (argv[i]), umaxtostr (last_val, buf));
1174 if (val == last_val)
1176 _("warning: line number %s is the same as preceding line number"),
1181 p->lines_required = val;
1184 if (i + 1 < argc && *argv[i + 1] == '{')
1186 /* We have a repeat count. */
1188 parse_repeat_count (i, p, argv[i]);
1194 get_format_flags (char **format_ptr)
1196 unsigned int count = 0;
1198 for (; **format_ptr; (*format_ptr)++)
1200 switch (**format_ptr)
1211 count |= 2; /* Allow for 0x prefix preceding an `x' conversion. */
1222 get_format_width (char **format_ptr)
1224 unsigned long int val = 0;
1226 if (ISDIGIT (**format_ptr)
1227 && (xstrtoul (*format_ptr, format_ptr, 10, &val, NULL) != LONGINT_OK
1229 error (EXIT_FAILURE, 0, _("invalid format width"));
1231 /* Allow for enough octal digits to represent the value of UINT_MAX,
1232 even if the field width is less than that. */
1233 return MAX (val, (sizeof (unsigned int) * CHAR_BIT + 2) / 3);
1237 get_format_prec (char **format_ptr)
1239 if (**format_ptr != '.')
1243 if (! ISDIGIT (**format_ptr))
1247 unsigned long int val;
1248 if (xstrtoul (*format_ptr, format_ptr, 10, &val, NULL) != LONGINT_OK
1250 error (EXIT_FAILURE, 0, _("invalid format precision"));
1256 get_format_conv_type (char **format_ptr)
1258 unsigned char ch = *(*format_ptr)++;
1271 error (EXIT_FAILURE, 0, _("missing conversion specifier in suffix"));
1276 error (EXIT_FAILURE, 0,
1277 _("invalid conversion specifier in suffix: %c"), ch);
1279 error (EXIT_FAILURE, 0,
1280 _("invalid conversion specifier in suffix: \\%.3o"), ch);
1285 max_out (char *format)
1287 size_t out_count = 0;
1288 bool percent = false;
1292 if (*format++ != '%')
1294 else if (*format == '%')
1302 error (EXIT_FAILURE, 0,
1303 _("too many %% conversion specifications in suffix"));
1305 out_count += get_format_flags (&format);
1307 size_t width = get_format_width (&format);
1308 size_t prec = get_format_prec (&format);
1310 out_count += MAX (width, prec);
1312 get_format_conv_type (&format);
1317 error (EXIT_FAILURE, 0,
1318 _("missing %% conversion specification in suffix"));
1324 main (int argc, char **argv)
1327 unsigned long int val;
1329 initialize_main (&argc, &argv);
1330 program_name = argv[0];
1331 setlocale (LC_ALL, "");
1332 bindtextdomain (PACKAGE, LOCALEDIR);
1333 textdomain (PACKAGE);
1335 atexit (close_stdout);
1340 suppress_count = false;
1341 remove_files = true;
1342 prefix = DEFAULT_PREFIX;
1344 while ((optc = getopt_long (argc, argv, "f:b:kn:sqz", longopts, NULL)) != -1)
1356 remove_files = false;
1360 if (xstrtoul (optarg, NULL, 10, &val, "") != LONGINT_OK
1362 error (EXIT_FAILURE, 0, _("%s: invalid number"), optarg);
1368 suppress_count = true;
1372 elide_empty_files = true;
1375 case_GETOPT_HELP_CHAR;
1377 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1380 usage (EXIT_FAILURE);
1383 if (argc - optind < 2)
1386 error (0, 0, _("missing operand"));
1388 error (0, 0, _("missing operand after %s"), quote (argv[argc - 1]));
1389 usage (EXIT_FAILURE);
1393 filename_space = xmalloc (strlen (prefix) + max_out (suffix) + 2);
1395 filename_space = xmalloc (strlen (prefix) + digits + 2);
1397 set_input_file (argv[optind++]);
1399 parse_patterns (argc, optind, argv);
1403 static int const sig[] = { SIGHUP, SIGINT, SIGQUIT, SIGTERM };
1404 enum { nsigs = sizeof sig / sizeof sig[0] };
1407 struct sigaction act;
1409 sigemptyset (&caught_signals);
1410 for (i = 0; i < nsigs; i++)
1412 sigaction (sig[i], NULL, &act);
1413 if (act.sa_handler != SIG_IGN)
1414 sigaddset (&caught_signals, sig[i]);
1417 act.sa_handler = interrupt_handler;
1418 act.sa_mask = caught_signals;
1421 for (i = 0; i < nsigs; i++)
1422 if (sigismember (&caught_signals, sig[i]))
1423 sigaction (sig[i], &act, NULL);
1425 for (i = 0; i < nsigs; i++)
1426 if (signal (sig[i], SIG_IGN) != SIG_IGN)
1428 signal (sig[i], interrupt_handler);
1429 siginterrupt (sig[i], 1);
1436 if (close (STDIN_FILENO) != 0)
1438 error (0, errno, _("read error"));
1442 exit (EXIT_SUCCESS);
1448 if (status != EXIT_SUCCESS)
1449 fprintf (stderr, _("Try `%s --help' for more information.\n"),
1454 Usage: %s [OPTION]... FILE PATTERN...\n\
1458 Output pieces of FILE separated by PATTERN(s) to files `xx00', `xx01', ...,\n\
1459 and output byte counts of each piece to standard output.\n\
1463 Mandatory arguments to long options are mandatory for short options too.\n\
1466 -b, --suffix-format=FORMAT use sprintf FORMAT instead of %02d\n\
1467 -f, --prefix=PREFIX use PREFIX instead of `xx'\n\
1468 -k, --keep-files do not remove output files on errors\n\
1471 -n, --digits=DIGITS use specified number of digits instead of 2\n\
1472 -s, --quiet, --silent do not print counts of output file sizes\n\
1473 -z, --elide-empty-files remove empty output files\n\
1475 fputs (HELP_OPTION_DESCRIPTION, stdout);
1476 fputs (VERSION_OPTION_DESCRIPTION, stdout);
1479 Read standard input if FILE is -. Each PATTERN may be:\n\
1483 INTEGER copy up to but not including specified line number\n\
1484 /REGEXP/[OFFSET] copy up to but not including a matching line\n\
1485 %REGEXP%[OFFSET] skip to, but not including a matching line\n\
1486 {INTEGER} repeat the previous pattern specified number of times\n\
1487 {*} repeat the previous pattern as many times as possible\n\
1489 A line OFFSET is a required `+' or `-' followed by a positive integer.\n\
1491 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);