1 /* xargs -- build and execute command lines from standard input
2 Copyright (C) 1990, 91, 92, 93, 94, 2000, 2003, 2004, 2005, 2006, 2007 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
16 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 /* Written by Mike Rendell <michael@cs.mun.ca>
21 and David MacKenzie <djm@gnu.org>.
30 # if defined PROTOTYPES || (defined __STDC__ && __STDC__)
31 # define PARAMS(Args) Args
33 # define PARAMS(Args) ()
39 #if !defined (isascii) || defined (STDC_HEADERS)
47 #define ISBLANK(c) (isascii (c) && isblank (c))
49 #define ISBLANK(c) ((c) == ' ' || (c) == '\t')
52 #define ISSPACE(c) (ISBLANK (c) || (c) == '\n' || (c) == '\r' \
53 || (c) == '\f' || (c) == '\v')
55 #include <sys/types.h>
61 #if defined(STDC_HEADERS)
65 #if defined(HAVE_STRING_H) || defined(STDC_HEADERS)
67 #if !defined(STDC_HEADERS)
72 #define memcpy(dest, source, count) (bcopy((source), (dest), (count)))
76 #include <sys/param.h>
84 #define LONG_MAX (~(1 << (sizeof (long) * 8 - 1)))
87 /* The presence of unistd.h is assumed by gnulib these days, so we
88 * might as well assume it too.
94 #if !defined(SIGCHLD) && defined(SIGCLD)
95 #define SIGCHLD SIGCLD
111 # include <libintl.h>
112 # define _(Text) gettext (Text)
114 # define _(Text) Text
115 #define textdomain(Domain)
116 #define bindtextdomain(Package, Directory)
119 # define N_(String) gettext_noop (String)
121 /* See locate.c for explanation as to why not use (String) */
122 # define N_(String) String
125 #include "buildcmd.h"
128 /* Return nonzero if S is the EOF string. */
129 #define EOF_STR(s) (eof_str && *eof_str == *s && !strcmp (eof_str, s))
131 /* Do multibyte processing if multibyte characters are supported,
132 unless multibyte sequences are search safe. Multibyte sequences
133 are search safe if searching for a substring using the byte
134 comparison function 'strstr' gives no false positives. All 8-bit
135 encodings and the UTF-8 multibyte encoding are search safe, but
136 the EUC encodings are not.
137 BeOS uses the UTF-8 encoding exclusively, so it is search safe. */
139 # define MULTIBYTE_IS_SEARCH_SAFE 1
141 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_SEARCH_SAFE)
147 /* Simulate mbrlen with mblen as best we can. */
148 # define mbstate_t int
149 # define mbrlen(s, n, ps) mblen (s, n)
153 /* Not char because of type promotion; NeXT gcc can't handle it. */
165 #include "closeout.h"
166 #include "gnulib-version.h"
168 void error
PARAMS ((int status
, int errnum
, char *message
,...));
170 extern char *version_string
;
172 /* The name this program was run with. */
175 static FILE *input_stream
;
177 /* Buffer for reading arguments from input. */
178 static char *linebuf
;
180 static int keep_stdin
= 0;
182 /* Line number in stdin since the last command was executed. */
183 static int lineno
= 0;
185 static struct buildcmd_state bc_state
;
186 static struct buildcmd_control bc_ctl
;
188 /* Did we already complain about NUL characters in the input? */
189 static int nullwarning_given
= 0;
192 /* If nonzero, when this string is read on stdin it is treated as
194 IEEE Std 1003.1, 2004 Edition allows this to be NULL.
195 In findutils releases up to and including 4.2.8, this was "_".
197 static char *eof_str
= NULL
;
199 /* Number of chars in the initial args. */
200 /* static int initial_argv_chars = 0; */
202 /* true when building up initial arguments in `cmd_argv'. */
203 static boolean initial_args
= true;
205 /* If nonzero, the maximum number of child processes that can be running
207 static int proc_max
= 1;
209 /* Total number of child processes that have been executed. */
210 static int procs_executed
= 0;
212 /* The number of elements in `pids'. */
213 static int procs_executing
= 0;
215 /* List of child processes currently executing. */
216 static pid_t
*pids
= NULL
;
218 /* The number of allocated elements in `pids'. */
219 static int pids_alloc
= 0;
221 /* Exit status; nonzero if any child process exited with a
223 static volatile int child_error
= 0;
225 static volatile int original_exit_value
;
227 /* If true, print each command on stderr before executing it. */
228 static boolean print_command
= false; /* Option -t */
230 /* If true, query the user before executing each command, and only
231 execute the command if the user responds affirmatively. */
232 static boolean query_before_executing
= false;
234 /* The delimiter for input arguments. This is only consulted if the
235 * -0 or -d option had been given.
237 static char input_delimiter
= '\0';
240 static struct option
const longopts
[] =
242 {"null", no_argument
, NULL
, '0'},
243 {"arg-file", required_argument
, NULL
, 'a'},
244 {"delimiter", required_argument
, NULL
, 'd'},
245 {"eof", optional_argument
, NULL
, 'e'},
246 {"replace", optional_argument
, NULL
, 'I'},
247 {"max-lines", optional_argument
, NULL
, 'l'},
248 {"max-args", required_argument
, NULL
, 'n'},
249 {"interactive", no_argument
, NULL
, 'p'},
250 {"no-run-if-empty", no_argument
, NULL
, 'r'},
251 {"max-chars", required_argument
, NULL
, 's'},
252 {"verbose", no_argument
, NULL
, 't'},
253 {"show-limits", no_argument
, NULL
, 'S'},
254 {"exit", no_argument
, NULL
, 'x'},
255 {"max-procs", required_argument
, NULL
, 'P'},
256 {"version", no_argument
, NULL
, 'v'},
257 {"help", no_argument
, NULL
, 'h'},
258 {NULL
, no_argument
, NULL
, 0}
261 static int read_line
PARAMS ((void));
262 static int read_string
PARAMS ((void));
263 static boolean print_args
PARAMS ((boolean ask
));
264 /* static void do_exec PARAMS ((void)); */
265 static int xargs_do_exec (const struct buildcmd_control
*cl
, struct buildcmd_state
*state
);
266 static void exec_if_possible
PARAMS ((void));
267 static void add_proc
PARAMS ((pid_t pid
));
268 static void wait_for_proc
PARAMS ((boolean all
));
269 static void wait_for_proc_all
PARAMS ((void));
270 static long parse_num
PARAMS ((char *str
, int option
, long min
, long max
, int fatal
));
271 static void usage
PARAMS ((FILE * stream
));
276 get_char_oct_or_hex_escape(const char *s
)
283 assert('\\' == s
[0]);
291 else if (isdigit(s
[1]))
299 p
= NULL
; /* Silence compiler warning. */
301 _("Invalid escape sequence %s in input delimiter specification."),
306 val
= strtoul(p
, &endp
, base
);
308 /* This if condition is carefully constructed to do
309 * the right thing if UCHAR_MAX has the same
310 * value as ULONG_MAX. IF UCHAR_MAX==ULONG_MAX,
311 * then val can never be greater than UCHAR_MAX.
313 if ((ULONG_MAX
== val
&& ERANGE
== errno
)
314 || (val
> UCHAR_MAX
))
319 _("Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx."),
320 s
, (unsigned long)UCHAR_MAX
);
325 _("Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo."),
326 s
, (unsigned long)UCHAR_MAX
);
330 /* check for trailing garbage */
334 _("Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised."),
343 get_input_delimiter(const char *s
)
373 return get_char_oct_or_hex_escape(s
);
379 _("Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \\."),
394 fail_due_to_env_size (void)
396 error (1, 0, _("environment is too large for exec"));
401 main (int argc
, char **argv
)
404 int show_limits
= 0; /* --show-limits */
405 int always_run_command
= 1;
406 char *input_file
= "-"; /* "-" is stdin */
407 char *default_cmd
= "/bin/echo";
408 int (*read_args
) PARAMS ((void)) = read_line
;
409 void (*act_on_init_result
)(void) = noop
;
410 enum BC_INIT_STATUS bcstatus
;
412 program_name
= argv
[0];
413 original_exit_value
= 0;
415 #ifdef HAVE_SETLOCALE
416 setlocale (LC_ALL
, "");
418 bindtextdomain (PACKAGE
, LOCALEDIR
);
419 textdomain (PACKAGE
);
420 atexit (close_stdout
);
421 atexit (wait_for_proc_all
);
423 bcstatus
= bc_init_controlinfo(&bc_ctl
);
425 /* The bc_init_controlinfo call may have determined that the
426 * environment is too big. In that case, we will fail with
427 * an error message after processing the command-line options,
428 * as "xargs --help" should still work even if the environment is
431 * Some of the argument processing depends on the contents of
432 * bc_ctl, which will be in an undefined state if bc_init_controlinfo()
435 if (BC_INIT_ENV_TOO_BIG
== bcstatus
)
437 act_on_init_result
= fail_due_to_env_size
;
441 /* IEEE Std 1003.1, 2003 specifies that the combined argument and
442 * environment list shall not exceed {ARG_MAX}-2048 bytes. It also
443 * specifies that it shall be at least LINE_MAX.
446 assert(bc_ctl
.arg_max
<= (ARG_MAX
-2048));
448 assert(bc_ctl
.arg_max
>= LINE_MAX
);
450 bc_ctl
.exec_callback
= xargs_do_exec
;
452 /* Start with a reasonable default size, though this can be
453 * adjusted via the -s option.
455 bc_use_sensible_arg_max(&bc_ctl
);
458 while ((optc
= getopt_long (argc
, argv
, "+0a:E:e::i::I:l::L:n:prs:txP:d:",
459 longopts
, (int *) 0)) != -1)
464 read_args
= read_string
;
465 input_delimiter
= '\0';
469 read_args
= read_string
;
470 input_delimiter
= get_input_delimiter(optarg
);
473 case 'E': /* POSIX */
474 case 'e': /* deprecated */
475 if (optarg
&& (strlen(optarg
) > 0))
485 case 'I': /* POSIX */
486 case 'i': /* deprecated */
488 bc_ctl
.replace_pat
= optarg
;
490 bc_ctl
.replace_pat
= "{}";
491 /* -i excludes -n -l. */
492 bc_ctl
.args_per_exec
= 0;
493 bc_ctl
.lines_per_exec
= 0;
496 case 'L': /* POSIX */
497 bc_ctl
.lines_per_exec
= parse_num (optarg
, 'L', 1L, -1L, 1);
498 /* -L excludes -i -n. */
499 bc_ctl
.args_per_exec
= 0;
500 bc_ctl
.replace_pat
= NULL
;
503 case 'l': /* deprecated */
505 bc_ctl
.lines_per_exec
= parse_num (optarg
, 'l', 1L, -1L, 1);
507 bc_ctl
.lines_per_exec
= 1;
508 /* -l excludes -i -n. */
509 bc_ctl
.args_per_exec
= 0;
510 bc_ctl
.replace_pat
= NULL
;
514 bc_ctl
.args_per_exec
= parse_num (optarg
, 'n', 1L, -1L, 1);
515 /* -n excludes -i -l. */
516 bc_ctl
.lines_per_exec
= 0;
517 if (bc_ctl
.args_per_exec
== 1 && bc_ctl
.replace_pat
)
518 /* ignore -n1 in '-i -n1' */
519 bc_ctl
.args_per_exec
= 0;
521 bc_ctl
.replace_pat
= NULL
;
524 /* The POSIX standard specifies that it is not an error
525 * for the -s option to specify a size that the implementation
526 * cannot support - in that case, the relevant limit is used.
531 act_on_init_result();
532 arg_size
= parse_num (optarg
, 's', 1L,
533 bc_ctl
.posix_arg_size_max
, 0);
534 if (arg_size
> bc_ctl
.posix_arg_size_max
)
537 _("warning: value %ld for -s option is too large, "
538 "using %ld instead"),
539 arg_size
, bc_ctl
.posix_arg_size_max
);
540 arg_size
= bc_ctl
.posix_arg_size_max
;
542 bc_ctl
.arg_max
= arg_size
;
551 print_command
= true;
555 bc_ctl
.exit_if_size_exceeded
= true;
559 query_before_executing
= true;
560 print_command
= true;
564 always_run_command
= 0;
568 proc_max
= parse_num (optarg
, 'P', 0L, -1L, 1);
576 printf (_("GNU xargs version %s\n"), version_string
);
577 printf (_("Built using GNU gnulib version %s\n"), gnulib_version
);
586 /* If we had deferred failing due to problems in bc_init_controlinfo(),
589 * We issue this error message after processing command line
590 * arguments so that it is possible to use "xargs --help" even if
591 * the environment is too large.
593 act_on_init_result();
594 assert(BC_INIT_OK
== bcstatus
);
596 if (0 == strcmp (input_file
, "-"))
598 input_stream
= stdin
;
602 keep_stdin
= 1; /* see prep_child_for_exec() */
603 input_stream
= fopen (input_file
, "r");
604 if (NULL
== input_stream
)
607 _("Cannot open input file `%s'"),
612 if (bc_ctl
.replace_pat
|| bc_ctl
.lines_per_exec
)
613 bc_ctl
.exit_if_size_exceeded
= true;
622 /* We want to be able to print size_t values as unsigned long, so if
623 * the cast isn't value-preserving, we have a problem. This isn't a
624 * problem in C89, because size_t was known to be no wider than
625 * unsigned long. In C99 this is no longer the case, but there are
626 * special C99 ways to print such values. Unfortunately this
627 * program tries to work on both C89 and C99 systems.
629 #if defined(SIZE_MAX)
630 # if SIZE_MAX > ULONG_MAX
631 # error "I'm not sure how to print size_t values on your system"
634 /* Without SIZE_MAX (i.e. limits.h) this is probably
635 * close to the best we can do.
637 assert(sizeof(size_t) <= sizeof(unsigned long));
643 _("Your environment variables take up %lu bytes\n"),
644 (unsigned long)bc_size_of_environment());
646 _("POSIX lower and upper limits on argument length: %lu, %lu\n"),
647 (unsigned long)bc_ctl
.posix_arg_size_min
,
648 (unsigned long)bc_ctl
.posix_arg_size_max
);
650 _("Maximum length of command we could actually use: %ld\n"),
651 (unsigned long)(bc_ctl
.posix_arg_size_max
-
652 bc_size_of_environment()));
654 _("Size of command buffer we are actually using: %lu\n"),
655 (unsigned long)bc_ctl
.arg_max
);
657 if (isatty(STDIN_FILENO
))
661 "Execution of xargs will continue now, and it will "
662 "try to read its input and run commands; if this is "
663 "not what you wanted to happen, please type the "
664 "end-of-file keystroke.\n"));
665 if (always_run_command
)
668 _("Warning: %s will be run at least once. "
669 "If you do not want that to happen, then press "
670 "the interrupt keystroke.\n"),
676 linebuf
= (char *) xmalloc (bc_ctl
.arg_max
+ 1);
677 bc_state
.argbuf
= (char *) xmalloc (bc_ctl
.arg_max
+ 1);
679 /* Make sure to listen for the kids. */
680 signal (SIGCHLD
, SIG_DFL
);
682 if (!bc_ctl
.replace_pat
)
684 for (; optind
< argc
; optind
++)
685 bc_push_arg (&bc_ctl
, &bc_state
,
686 argv
[optind
], strlen (argv
[optind
]) + 1,
689 initial_args
= false;
690 bc_ctl
.initial_argc
= bc_state
.cmd_argc
;
691 bc_state
.cmd_initial_argv_chars
= bc_state
.cmd_argv_chars
;
693 while ((*read_args
) () != -1)
694 if (bc_ctl
.lines_per_exec
&& lineno
>= bc_ctl
.lines_per_exec
)
696 xargs_do_exec (&bc_ctl
, &bc_state
);
700 /* SYSV xargs seems to do at least one exec, even if the
702 if (bc_state
.cmd_argc
!= bc_ctl
.initial_argc
703 || (always_run_command
&& procs_executed
== 0))
704 xargs_do_exec (&bc_ctl
, &bc_state
);
711 size_t *arglen
= (size_t *) xmalloc (sizeof (size_t) * argc
);
713 for (i
= optind
; i
< argc
; i
++)
714 arglen
[i
] = strlen(argv
[i
]);
715 bc_ctl
.rplen
= strlen (bc_ctl
.replace_pat
);
716 while ((len
= (*read_args
) ()) != -1)
718 /* Don't do insert on the command name. */
719 bc_clear_args(&bc_ctl
, &bc_state
);
720 bc_state
.cmd_argv_chars
= 0; /* begin at start of buffer */
722 bc_push_arg (&bc_ctl
, &bc_state
,
723 argv
[optind
], arglen
[optind
] + 1,
727 initial_args
= false;
729 for (i
= optind
+ 1; i
< argc
; i
++)
730 bc_do_insert (&bc_ctl
, &bc_state
,
735 xargs_do_exec (&bc_ctl
, &bc_state
);
739 original_exit_value
= child_error
;
744 /* Read a line of arguments from the input and add them to the list of
745 arguments to pass to the command. Ignore blank lines and initial blanks.
746 Single and double quotes and backslashes quote metacharacters and blanks
747 as they do in the shell.
748 Return -1 if eof (either physical or logical) is reached,
749 otherwise the length of the last string read (including the null). */
754 /* States for read_line. */
762 static boolean eof
= false;
763 /* Start out in mode SPACE to always strip leading spaces (even with -i). */
764 enum read_line_state state
= SPACE
; /* The type of character we last read. */
765 int prevc
; /* The previous value of c. */
766 int quotc
= 0; /* The last quote character read. */
768 boolean first
= true; /* true if reading first arg on line. */
769 boolean seen_arg
= false; /* true if we have seen any arg (or part of one) yet */
772 /* Including the NUL, the args must not grow past this point. */
773 char *endbuf
= linebuf
+ bc_ctl
.arg_max
- bc_state
.cmd_initial_argv_chars
- 1;
780 c
= getc (input_stream
);
784 /* COMPAT: SYSV seems to ignore stuff on a line that
785 ends without a \n; we don't. */
794 error (1, 0, _("unmatched %s quote; by default quotes are special to xargs unless you use the -0 option"),
795 quotc
== '"' ? _("double") : _("single"));
797 if (first
&& EOF_STR (linebuf
))
799 if (!bc_ctl
.replace_pat
)
800 bc_push_arg (&bc_ctl
, &bc_state
,
817 if (!ISBLANK (prevc
))
818 lineno
++; /* For -l. */
823 /* An empty argument, add it to the list as normal. */
834 if (EOF_STR (linebuf
))
837 return first
? -1 : len
;
839 if (!bc_ctl
.replace_pat
)
840 bc_push_arg (&bc_ctl
, &bc_state
,
848 /* POSIX: In the POSIX locale, the separators are <SPC> and
849 * <TAB>, but not <FF> or <VT>.
851 if (!bc_ctl
.replace_pat
&& ISBLANK (c
))
855 if (EOF_STR (linebuf
))
858 return first
? -1 : len
;
860 bc_push_arg (&bc_ctl
, &bc_state
,
887 error (1, 0, _("unmatched %s quote; by default quotes are special to xargs unless you use the -0 option"),
888 quotc
== '"' ? _("double") : _("single"));
893 seen_arg
= true; /* Makes a difference for e.g. just '' or "" as the first arg on a line */
903 if ( (0 == c
) && !nullwarning_given
)
905 /* This is just a warning message. We only issue it once. */
907 _("warning: a NUL character occurred in the input. "
908 "It cannot be passed through in the argument list. "
909 "Did you mean to use the --null option?"));
910 nullwarning_given
= 1;
917 error (1, 0, _("argument line too long"));
921 append_char_to_buf(&linebuf
, &endbuf
, &p
, c
);
926 /* Read a null-terminated string from the input and add it to the list of
927 arguments to pass to the command.
928 Return -1 if eof (either physical or logical) is reached,
929 otherwise the length of the string read (including the null). */
934 static boolean eof
= false;
937 /* Including the NUL, the args must not grow past this point. */
938 char *endbuf
= linebuf
+ bc_ctl
.arg_max
- bc_state
.cmd_initial_argv_chars
- 1;
944 int c
= getc (input_stream
);
952 if (!bc_ctl
.replace_pat
)
953 bc_push_arg (&bc_ctl
, &bc_state
,
959 if (c
== input_delimiter
)
961 lineno
++; /* For -l. */
964 if (!bc_ctl
.replace_pat
)
965 bc_push_arg (&bc_ctl
, &bc_state
,
974 error (1, 0, _("argument line too long"));
980 /* Print the arguments of the command to execute.
981 If ASK is nonzero, prompt the user for a response, and
982 if the user responds affirmatively, return true;
983 otherwise, return false. */
986 print_args (boolean ask
)
990 for (i
= 0; i
< bc_state
.cmd_argc
- 1; i
++)
991 fprintf (stderr
, "%s ", bc_state
.cmd_argv
[i
]);
994 static FILE *tty_stream
;
999 tty_stream
= fopen ("/dev/tty", "r");
1001 error (1, errno
, "/dev/tty");
1003 fputs ("?...", stderr
);
1005 c
= savec
= getc (tty_stream
);
1006 while (c
!= EOF
&& c
!= '\n')
1007 c
= getc (tty_stream
);
1008 if (savec
== 'y' || savec
== 'Y')
1012 putc ('\n', stderr
);
1018 /* Close stdin and attach /dev/null to it.
1019 * This resolves Savannah bug #3992.
1022 prep_child_for_exec (void)
1026 const char inputfile
[] = "/dev/null";
1027 /* fprintf(stderr, "attaching stdin to /dev/null\n"); */
1030 if (open(inputfile
, O_RDONLY
) < 0)
1032 /* This is not entirely fatal, since
1033 * executing the child with a closed
1034 * stdin is almost as good as executing it
1035 * with its stdin attached to /dev/null.
1037 error (0, errno
, "%s", inputfile
);
1043 /* Execute the command that has been built in `cmd_argv'. This may involve
1044 waiting for processes that were previously executed. */
1047 xargs_do_exec (const struct buildcmd_control
*ctl
, struct buildcmd_state
*state
)
1054 bc_push_arg (&bc_ctl
, &bc_state
,
1057 false); /* Null terminate the arg list. */
1059 if (!query_before_executing
|| print_args (true))
1061 if (proc_max
&& procs_executing
>= proc_max
)
1062 wait_for_proc (false);
1063 if (!query_before_executing
&& print_command
)
1065 /* If we run out of processes, wait for a child to return and
1067 while ((child
= fork ()) < 0 && errno
== EAGAIN
&& procs_executing
)
1068 wait_for_proc (false);
1072 error (1, errno
, _("cannot fork"));
1074 case 0: /* Child. */
1075 prep_child_for_exec();
1076 execvp (bc_state
.cmd_argv
[0], bc_state
.cmd_argv
);
1077 error (0, errno
, "%s", bc_state
.cmd_argv
[0]);
1078 _exit (errno
== ENOENT
? 127 : 126);
1084 bc_clear_args(&bc_ctl
, &bc_state
);
1085 return 1; /* Success */
1088 /* Execute the command if possible. */
1091 exec_if_possible (void)
1093 if (bc_ctl
.replace_pat
|| initial_args
||
1094 bc_state
.cmd_argc
== bc_ctl
.initial_argc
|| bc_ctl
.exit_if_size_exceeded
)
1096 xargs_do_exec (&bc_ctl
, &bc_state
);
1099 /* Add the process with id PID to the list of processes that have
1103 add_proc (pid_t pid
)
1107 /* Find an empty slot. */
1108 for (i
= 0; i
< pids_alloc
&& pids
[i
]; i
++)
1110 if (i
== pids_alloc
)
1112 if (pids_alloc
== 0)
1114 pids_alloc
= proc_max
? proc_max
: 64;
1115 pids
= (pid_t
*) xmalloc (sizeof (pid_t
) * pids_alloc
);
1120 pids
= (pid_t
*) xrealloc (pids
,
1121 sizeof (pid_t
) * pids_alloc
);
1123 memset (&pids
[i
], '\0', sizeof (pid_t
) * (pids_alloc
- i
));
1130 /* If ALL is true, wait for all child processes to finish;
1131 otherwise, wait for one child process to finish.
1132 Remove the processes that finish from the list of executing processes. */
1135 wait_for_proc (boolean all
)
1137 while (procs_executing
)
1145 while ((pid
= wait (&status
)) == (pid_t
) -1)
1147 error (1, errno
, _("error waiting for child process"));
1149 /* Find the entry in `pids' for the child process
1151 for (i
= 0; i
< pids_alloc
&& pid
!= pids
[i
]; i
++)
1154 while (i
== pids_alloc
); /* A child died that we didn't start? */
1156 /* Remove the child from the list. */
1160 if (WEXITSTATUS (status
) == 126 || WEXITSTATUS (status
) == 127)
1161 exit (WEXITSTATUS (status
)); /* Can't find or run the command. */
1162 if (WEXITSTATUS (status
) == 255)
1163 error (124, 0, _("%s: exited with status 255; aborting"), bc_state
.cmd_argv
[0]);
1164 if (WIFSTOPPED (status
))
1165 error (125, 0, _("%s: stopped by signal %d"), bc_state
.cmd_argv
[0], WSTOPSIG (status
));
1166 if (WIFSIGNALED (status
))
1167 error (125, 0, _("%s: terminated by signal %d"), bc_state
.cmd_argv
[0], WTERMSIG (status
));
1168 if (WEXITSTATUS (status
) != 0)
1176 /* Wait for all child processes to finish. */
1179 wait_for_proc_all (void)
1181 static boolean waiting
= false;
1187 wait_for_proc (true);
1190 if (original_exit_value
!= child_error
)
1192 /* wait_for_proc() changed the value of child_error(). This
1193 * function is registered via atexit(), and so may have been
1194 * called from exit(). We now know that the original value
1195 * passed to exit() is no longer the exit status we require.
1196 * The POSIX standard states that the behaviour if exit() is
1197 * called more than once is undefined. Therefore we now have to
1198 * exit with _exit() instead of exit().
1205 /* Return the value of the number represented in STR.
1206 OPTION is the command line option to which STR is the argument.
1207 If the value does not fall within the boundaries MIN and MAX,
1208 Print an error message mentioning OPTION. If FATAL is true,
1212 parse_num (char *str
, int option
, long int min
, long int max
, int fatal
)
1217 val
= strtol (str
, &eptr
, 10);
1218 if (eptr
== str
|| *eptr
)
1220 fprintf (stderr
, _("%s: invalid number for -%c option\n"),
1221 program_name
, option
);
1227 fprintf (stderr
, _("%s: value for -%c option should be >= %ld\n"),
1228 program_name
, option
, min
);
1239 else if (max
>= 0 && val
> max
)
1241 fprintf (stderr
, _("%s: value for -%c option should be < %ld\n"),
1242 program_name
, option
, max
);
1257 usage (FILE *stream
)
1259 fprintf (stream
, _("\
1260 Usage: %s [-0prtx] [--interactive] [--null] [-d|--delimiter=delim]\n\
1261 [-E eof-str] [-e[eof-str]] [--eof[=eof-str]]\n\
1262 [-L max-lines] [-l[max-lines]] [--max-lines[=max-lines]]\n\
1263 [-I replace-str] [-i[replace-str]] [--replace[=replace-str]]\n\
1264 [-n max-args] [--max-args=max-args]\n\
1265 [-s max-chars] [--max-chars=max-chars]\n\
1266 [-P max-procs] [--max-procs=max-procs] [--show-limits]\n\
1267 [--verbose] [--exit] [--no-run-if-empty] [--arg-file=file]\n\
1268 [--version] [--help] [command [initial-arguments]]\n"),
1270 fputs (_("\nReport bugs to <bug-findutils@gnu.org>.\n"), stream
);