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"
167 void error
PARAMS ((int status
, int errnum
, char *message
,...));
169 extern char *version_string
;
171 /* The name this program was run with. */
174 static FILE *input_stream
;
176 /* Buffer for reading arguments from input. */
177 static char *linebuf
;
179 static int keep_stdin
= 0;
181 /* Line number in stdin since the last command was executed. */
182 static int lineno
= 0;
184 static struct buildcmd_state bc_state
;
185 static struct buildcmd_control bc_ctl
;
187 /* Did we already complain about NUL characters in the input? */
188 static int nullwarning_given
= 0;
191 /* If nonzero, when this string is read on stdin it is treated as
193 IEEE Std 1003.1, 2004 Edition allows this to be NULL.
194 In findutils releases up to and including 4.2.8, this was "_".
196 static char *eof_str
= NULL
;
198 /* Number of chars in the initial args. */
199 /* static int initial_argv_chars = 0; */
201 /* true when building up initial arguments in `cmd_argv'. */
202 static boolean initial_args
= true;
204 /* If nonzero, the maximum number of child processes that can be running
206 static int proc_max
= 1;
208 /* Total number of child processes that have been executed. */
209 static int procs_executed
= 0;
211 /* The number of elements in `pids'. */
212 static int procs_executing
= 0;
214 /* List of child processes currently executing. */
215 static pid_t
*pids
= NULL
;
217 /* The number of allocated elements in `pids'. */
218 static int pids_alloc
= 0;
220 /* Exit status; nonzero if any child process exited with a
222 static volatile int child_error
= 0;
224 static volatile int original_exit_value
;
226 /* If true, print each command on stderr before executing it. */
227 static boolean print_command
= false; /* Option -t */
229 /* If true, query the user before executing each command, and only
230 execute the command if the user responds affirmatively. */
231 static boolean query_before_executing
= false;
233 /* The delimiter for input arguments. This is only consulted if the
234 * -0 or -d option had been given.
236 static char input_delimiter
= '\0';
239 static struct option
const longopts
[] =
241 {"null", no_argument
, NULL
, '0'},
242 {"arg-file", required_argument
, NULL
, 'a'},
243 {"delimiter", required_argument
, NULL
, 'd'},
244 {"eof", optional_argument
, NULL
, 'e'},
245 {"replace", optional_argument
, NULL
, 'I'},
246 {"max-lines", optional_argument
, NULL
, 'l'},
247 {"max-args", required_argument
, NULL
, 'n'},
248 {"interactive", no_argument
, NULL
, 'p'},
249 {"no-run-if-empty", no_argument
, NULL
, 'r'},
250 {"max-chars", required_argument
, NULL
, 's'},
251 {"verbose", no_argument
, NULL
, 't'},
252 {"show-limits", no_argument
, NULL
, 'S'},
253 {"exit", no_argument
, NULL
, 'x'},
254 {"max-procs", required_argument
, NULL
, 'P'},
255 {"version", no_argument
, NULL
, 'v'},
256 {"help", no_argument
, NULL
, 'h'},
257 {NULL
, no_argument
, NULL
, 0}
260 static int read_line
PARAMS ((void));
261 static int read_string
PARAMS ((void));
262 static boolean print_args
PARAMS ((boolean ask
));
263 /* static void do_exec PARAMS ((void)); */
264 static int xargs_do_exec (const struct buildcmd_control
*cl
, struct buildcmd_state
*state
);
265 static void exec_if_possible
PARAMS ((void));
266 static void add_proc
PARAMS ((pid_t pid
));
267 static void wait_for_proc
PARAMS ((boolean all
));
268 static void wait_for_proc_all
PARAMS ((void));
269 static long parse_num
PARAMS ((char *str
, int option
, long min
, long max
, int fatal
));
270 static void usage
PARAMS ((FILE * stream
));
275 get_char_oct_or_hex_escape(const char *s
)
282 assert('\\' == s
[0]);
290 else if (isdigit(s
[1]))
299 _("Invalid escape sequence %s in input delimiter specification."),
304 val
= strtoul(p
, &endp
, base
);
306 /* This if condition is carefully constructed to do
307 * the right thing if UCHAR_MAX has the same
308 * value as ULONG_MAX. IF UCHAR_MAX==ULONG_MAX,
309 * then val can never be greater than UCHAR_MAX.
311 if ((ULONG_MAX
== val
&& ERANGE
== errno
)
312 || (val
> UCHAR_MAX
))
317 _("Invalid escape sequence %s in input delimiter specification; character values must not exceed %lx."),
318 s
, (unsigned long)UCHAR_MAX
);
323 _("Invalid escape sequence %s in input delimiter specification; character values must not exceed %lo."),
324 s
, (unsigned long)UCHAR_MAX
);
328 /* check for trailing garbage */
332 _("Invalid escape sequence %s in input delimiter specification; trailing characters %s not recognised."),
341 get_input_delimiter(const char *s
)
371 return get_char_oct_or_hex_escape(s
);
377 _("Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \\."),
392 fail_due_to_env_size (void)
394 error (1, 0, _("environment is too large for exec"));
399 main (int argc
, char **argv
)
402 int show_limits
= 0; /* --show-limits */
403 int always_run_command
= 1;
404 char *input_file
= "-"; /* "-" is stdin */
405 char *default_cmd
= "/bin/echo";
406 int (*read_args
) PARAMS ((void)) = read_line
;
407 void (*act_on_init_result
)(void) = noop
;
409 enum BC_INIT_STATUS bcstatus
;
411 program_name
= argv
[0];
412 original_exit_value
= 0;
414 #ifdef HAVE_SETLOCALE
415 setlocale (LC_ALL
, "");
417 bindtextdomain (PACKAGE
, LOCALEDIR
);
418 textdomain (PACKAGE
);
419 atexit (close_stdout
);
420 atexit (wait_for_proc_all
);
422 bcstatus
= bc_init_controlinfo(&bc_ctl
);
424 /* The bc_init_controlinfo call may have determined that the
425 * environment is too big. In that case, we will fail with
426 * an error message after processing the command-line options,
427 * as "xargs --help" should still work even if the environment is
430 * Some of the argument processing depends on the contents of
431 * bc_ctl, which will be in an undefined state if bc_init_controlinfo()
434 if (BC_INIT_ENV_TOO_BIG
== bcstatus
)
436 act_on_init_result
= fail_due_to_env_size
;
440 /* IEEE Std 1003.1, 2003 specifies that the combined argument and
441 * environment list shall not exceed {ARG_MAX}-2048 bytes. It also
442 * specifies that it shall be at least LINE_MAX.
445 assert(bc_ctl
.arg_max
<= (ARG_MAX
-2048));
447 assert(bc_ctl
.arg_max
>= LINE_MAX
);
449 bc_ctl
.exec_callback
= xargs_do_exec
;
451 /* Start with a reasonable default size, though this can be
452 * adjusted via the -s option.
454 bc_use_sensible_arg_max(&bc_ctl
);
457 while ((optc
= getopt_long (argc
, argv
, "+0a:E:e::i::I:l::L:n:prs:txP:d:",
458 longopts
, (int *) 0)) != -1)
463 read_args
= read_string
;
464 input_delimiter
= '\0';
468 read_args
= read_string
;
469 input_delimiter
= get_input_delimiter(optarg
);
472 case 'E': /* POSIX */
473 case 'e': /* deprecated */
474 if (optarg
&& (strlen(optarg
) > 0))
484 case 'I': /* POSIX */
485 case 'i': /* deprecated */
487 bc_ctl
.replace_pat
= optarg
;
489 bc_ctl
.replace_pat
= "{}";
490 /* -i excludes -n -l. */
491 bc_ctl
.args_per_exec
= 0;
492 bc_ctl
.lines_per_exec
= 0;
495 case 'L': /* POSIX */
496 bc_ctl
.lines_per_exec
= parse_num (optarg
, 'L', 1L, -1L, 1);
497 /* -L excludes -i -n. */
498 bc_ctl
.args_per_exec
= 0;
499 bc_ctl
.replace_pat
= NULL
;
502 case 'l': /* deprecated */
504 bc_ctl
.lines_per_exec
= parse_num (optarg
, 'l', 1L, -1L, 1);
506 bc_ctl
.lines_per_exec
= 1;
507 /* -l excludes -i -n. */
508 bc_ctl
.args_per_exec
= 0;
509 bc_ctl
.replace_pat
= NULL
;
513 bc_ctl
.args_per_exec
= parse_num (optarg
, 'n', 1L, -1L, 1);
514 /* -n excludes -i -l. */
515 bc_ctl
.lines_per_exec
= 0;
516 if (bc_ctl
.args_per_exec
== 1 && bc_ctl
.replace_pat
)
517 /* ignore -n1 in '-i -n1' */
518 bc_ctl
.args_per_exec
= 0;
520 bc_ctl
.replace_pat
= NULL
;
523 /* The POSIX standard specifies that it is not an error
524 * for the -s option to specify a size that the implementation
525 * cannot support - in that case, the relevant limit is used.
530 act_on_init_result();
531 arg_size
= parse_num (optarg
, 's', 1L,
532 bc_ctl
.posix_arg_size_max
, 0);
533 if (arg_size
> bc_ctl
.posix_arg_size_max
)
536 _("warning: value %ld for -s option is too large, "
537 "using %ld instead"),
538 arg_size
, bc_ctl
.posix_arg_size_max
);
539 arg_size
= bc_ctl
.posix_arg_size_max
;
541 bc_ctl
.arg_max
= arg_size
;
550 print_command
= true;
554 bc_ctl
.exit_if_size_exceeded
= true;
558 query_before_executing
= true;
559 print_command
= true;
563 always_run_command
= 0;
567 proc_max
= parse_num (optarg
, 'P', 0L, -1L, 1);
575 printf (_("GNU xargs version %s\n"), version_string
);
584 /* If we had deferred failing due to problems in bc_init_controlinfo(),
587 * We issue this error message after processing command line
588 * arguments so that it is possible to use "xargs --help" even if
589 * the environment is too large.
591 act_on_init_result();
592 assert(BC_INIT_OK
== bcstatus
);
594 if (0 == strcmp (input_file
, "-"))
596 input_stream
= stdin
;
600 keep_stdin
= 1; /* see prep_child_for_exec() */
601 input_stream
= fopen (input_file
, "r");
602 if (NULL
== input_stream
)
605 _("Cannot open input file `%s'"),
610 if (bc_ctl
.replace_pat
|| bc_ctl
.lines_per_exec
)
611 bc_ctl
.exit_if_size_exceeded
= true;
620 /* We want to be able to print size_t values as unsigned long, so if
621 * the cast isn't value-preserving, we have a problem. This isn't a
622 * problem in C89, because size_t was known to be no wider than
623 * unsigned long. In C99 this is no longer the case, but there are
624 * special C99 ways to print such values. Unfortunately this
625 * program tries to work on both C89 and C99 systems.
627 #if defined(SIZE_MAX)
628 # if SIZE_MAX > ULONG_MAX
629 # error "I'm not sure how to print size_t values on your system"
632 /* Without SIZE_MAX (i.e. limits.h) this is probably
633 * close to the best we can do.
635 assert(sizeof(size_t) <= sizeof(unsigned long));
641 _("Your environment variables take up %lu bytes\n"),
642 (unsigned long)bc_size_of_environment());
644 _("POSIX lower and upper limits on argument length: %lu, %lu\n"),
645 (unsigned long)bc_ctl
.posix_arg_size_min
,
646 (unsigned long)bc_ctl
.posix_arg_size_max
);
648 _("Maximum length of command we could actually use: %ld\n"),
649 (unsigned long)(bc_ctl
.posix_arg_size_max
-
650 bc_size_of_environment()));
652 _("Size of command buffer we are actually using: %lu\n"),
653 (unsigned long)bc_ctl
.arg_max
);
655 if (isatty(STDIN_FILENO
))
659 "Execution of xargs will continue now, and it will "
660 "try to read its input and run commands; if this is "
661 "not what you wanted to happen, please type the "
662 "end-of-file keystroke.\n");
666 linebuf
= (char *) xmalloc (bc_ctl
.arg_max
+ 1);
667 bc_state
.argbuf
= (char *) xmalloc (bc_ctl
.arg_max
+ 1);
669 /* Make sure to listen for the kids. */
670 signal (SIGCHLD
, SIG_DFL
);
672 if (!bc_ctl
.replace_pat
)
674 for (; optind
< argc
; optind
++)
675 bc_push_arg (&bc_ctl
, &bc_state
,
676 argv
[optind
], strlen (argv
[optind
]) + 1,
679 initial_args
= false;
680 bc_ctl
.initial_argc
= bc_state
.cmd_argc
;
681 bc_state
.cmd_initial_argv_chars
= bc_state
.cmd_argv_chars
;
683 while ((*read_args
) () != -1)
684 if (bc_ctl
.lines_per_exec
&& lineno
>= bc_ctl
.lines_per_exec
)
686 xargs_do_exec (&bc_ctl
, &bc_state
);
690 /* SYSV xargs seems to do at least one exec, even if the
692 if (bc_state
.cmd_argc
!= bc_ctl
.initial_argc
693 || (always_run_command
&& procs_executed
== 0))
694 xargs_do_exec (&bc_ctl
, &bc_state
);
701 size_t *arglen
= (size_t *) xmalloc (sizeof (size_t) * argc
);
703 for (i
= optind
; i
< argc
; i
++)
704 arglen
[i
] = strlen(argv
[i
]);
705 bc_ctl
.rplen
= strlen (bc_ctl
.replace_pat
);
706 while ((len
= (*read_args
) ()) != -1)
708 /* Don't do insert on the command name. */
709 bc_clear_args(&bc_ctl
, &bc_state
);
710 bc_state
.cmd_argv_chars
= 0; /* begin at start of buffer */
712 bc_push_arg (&bc_ctl
, &bc_state
,
713 argv
[optind
], arglen
[optind
] + 1,
717 initial_args
= false;
719 for (i
= optind
+ 1; i
< argc
; i
++)
720 bc_do_insert (&bc_ctl
, &bc_state
,
725 xargs_do_exec (&bc_ctl
, &bc_state
);
729 original_exit_value
= child_error
;
734 /* Read a line of arguments from the input and add them to the list of
735 arguments to pass to the command. Ignore blank lines and initial blanks.
736 Single and double quotes and backslashes quote metacharacters and blanks
737 as they do in the shell.
738 Return -1 if eof (either physical or logical) is reached,
739 otherwise the length of the last string read (including the null). */
744 /* States for read_line. */
752 static boolean eof
= false;
753 /* Start out in mode SPACE to always strip leading spaces (even with -i). */
754 enum read_line_state state
= SPACE
; /* The type of character we last read. */
755 int prevc
; /* The previous value of c. */
756 int quotc
= 0; /* The last quote character read. */
758 boolean first
= true; /* true if reading first arg on line. */
759 boolean seen_arg
= false; /* true if we have seen any arg (or part of one) yet */
762 /* Including the NUL, the args must not grow past this point. */
763 char *endbuf
= linebuf
+ bc_ctl
.arg_max
- bc_state
.cmd_initial_argv_chars
- 1;
770 c
= getc (input_stream
);
774 /* COMPAT: SYSV seems to ignore stuff on a line that
775 ends without a \n; we don't. */
784 error (1, 0, _("unmatched %s quote; by default quotes are special to xargs unless you use the -0 option"),
785 quotc
== '"' ? _("double") : _("single"));
787 if (first
&& EOF_STR (linebuf
))
789 if (!bc_ctl
.replace_pat
)
790 bc_push_arg (&bc_ctl
, &bc_state
,
807 if (!ISBLANK (prevc
))
808 lineno
++; /* For -l. */
813 /* An empty argument, add it to the list as normal. */
824 if (EOF_STR (linebuf
))
827 return first
? -1 : len
;
829 if (!bc_ctl
.replace_pat
)
830 bc_push_arg (&bc_ctl
, &bc_state
,
838 /* POSIX: In the POSIX locale, the separators are <SPC> and
839 * <TAB>, but not <FF> or <VT>.
841 if (!bc_ctl
.replace_pat
&& ISBLANK (c
))
845 if (EOF_STR (linebuf
))
848 return first
? -1 : len
;
850 bc_push_arg (&bc_ctl
, &bc_state
,
877 error (1, 0, _("unmatched %s quote; by default quotes are special to xargs unless you use the -0 option"),
878 quotc
== '"' ? _("double") : _("single"));
883 seen_arg
= true; /* Makes a difference for e.g. just '' or "" as the first arg on a line */
893 if ( (0 == c
) && !nullwarning_given
)
895 /* This is just a warning message. We only issue it once. */
897 _("warning: a NUL character occurred in the input. "
898 "It cannot be passed through in the argument list. "
899 "Did you mean to use the --null option?"));
900 nullwarning_given
= 1;
907 error (1, 0, _("argument line too long"));
911 append_char_to_buf(&linebuf
, &endbuf
, &p
, c
);
916 /* Read a null-terminated string from the input and add it to the list of
917 arguments to pass to the command.
918 Return -1 if eof (either physical or logical) is reached,
919 otherwise the length of the string read (including the null). */
924 static boolean eof
= false;
927 /* Including the NUL, the args must not grow past this point. */
928 char *endbuf
= linebuf
+ bc_ctl
.arg_max
- bc_state
.cmd_initial_argv_chars
- 1;
934 int c
= getc (input_stream
);
942 if (!bc_ctl
.replace_pat
)
943 bc_push_arg (&bc_ctl
, &bc_state
,
949 if (c
== input_delimiter
)
951 lineno
++; /* For -l. */
954 if (!bc_ctl
.replace_pat
)
955 bc_push_arg (&bc_ctl
, &bc_state
,
964 error (1, 0, _("argument line too long"));
970 /* Print the arguments of the command to execute.
971 If ASK is nonzero, prompt the user for a response, and
972 if the user responds affirmatively, return true;
973 otherwise, return false. */
976 print_args (boolean ask
)
980 for (i
= 0; i
< bc_state
.cmd_argc
- 1; i
++)
981 fprintf (stderr
, "%s ", bc_state
.cmd_argv
[i
]);
984 static FILE *tty_stream
;
989 tty_stream
= fopen ("/dev/tty", "r");
991 error (1, errno
, "/dev/tty");
993 fputs ("?...", stderr
);
995 c
= savec
= getc (tty_stream
);
996 while (c
!= EOF
&& c
!= '\n')
997 c
= getc (tty_stream
);
998 if (savec
== 'y' || savec
== 'Y')
1002 putc ('\n', stderr
);
1008 /* Close stdin and attach /dev/null to it.
1009 * This resolves Savannah bug #3992.
1012 prep_child_for_exec (void)
1016 const char inputfile
[] = "/dev/null";
1017 /* fprintf(stderr, "attaching stdin to /dev/null\n"); */
1020 if (open(inputfile
, O_RDONLY
) < 0)
1022 /* This is not entirely fatal, since
1023 * executing the child with a closed
1024 * stdin is almost as good as executing it
1025 * with its stdin attached to /dev/null.
1027 error (0, errno
, "%s", inputfile
);
1033 /* Execute the command that has been built in `cmd_argv'. This may involve
1034 waiting for processes that were previously executed. */
1037 xargs_do_exec (const struct buildcmd_control
*ctl
, struct buildcmd_state
*state
)
1044 bc_push_arg (&bc_ctl
, &bc_state
,
1047 false); /* Null terminate the arg list. */
1049 if (!query_before_executing
|| print_args (true))
1051 if (proc_max
&& procs_executing
>= proc_max
)
1052 wait_for_proc (false);
1053 if (!query_before_executing
&& print_command
)
1055 /* If we run out of processes, wait for a child to return and
1057 while ((child
= fork ()) < 0 && errno
== EAGAIN
&& procs_executing
)
1058 wait_for_proc (false);
1062 error (1, errno
, _("cannot fork"));
1064 case 0: /* Child. */
1065 prep_child_for_exec();
1066 execvp (bc_state
.cmd_argv
[0], bc_state
.cmd_argv
);
1067 error (0, errno
, "%s", bc_state
.cmd_argv
[0]);
1068 _exit (errno
== ENOENT
? 127 : 126);
1074 bc_clear_args(&bc_ctl
, &bc_state
);
1075 return 1; /* Success */
1078 /* Execute the command if possible. */
1081 exec_if_possible (void)
1083 if (bc_ctl
.replace_pat
|| initial_args
||
1084 bc_state
.cmd_argc
== bc_ctl
.initial_argc
|| bc_ctl
.exit_if_size_exceeded
)
1086 xargs_do_exec (&bc_ctl
, &bc_state
);
1089 /* Add the process with id PID to the list of processes that have
1093 add_proc (pid_t pid
)
1097 /* Find an empty slot. */
1098 for (i
= 0; i
< pids_alloc
&& pids
[i
]; i
++)
1100 if (i
== pids_alloc
)
1102 if (pids_alloc
== 0)
1104 pids_alloc
= proc_max
? proc_max
: 64;
1105 pids
= (pid_t
*) xmalloc (sizeof (pid_t
) * pids_alloc
);
1110 pids
= (pid_t
*) xrealloc (pids
,
1111 sizeof (pid_t
) * pids_alloc
);
1113 memset (&pids
[i
], '\0', sizeof (pid_t
) * (pids_alloc
- i
));
1120 /* If ALL is true, wait for all child processes to finish;
1121 otherwise, wait for one child process to finish.
1122 Remove the processes that finish from the list of executing processes. */
1125 wait_for_proc (boolean all
)
1127 while (procs_executing
)
1135 while ((pid
= wait (&status
)) == (pid_t
) -1)
1137 error (1, errno
, _("error waiting for child process"));
1139 /* Find the entry in `pids' for the child process
1141 for (i
= 0; i
< pids_alloc
&& pid
!= pids
[i
]; i
++)
1144 while (i
== pids_alloc
); /* A child died that we didn't start? */
1146 /* Remove the child from the list. */
1150 if (WEXITSTATUS (status
) == 126 || WEXITSTATUS (status
) == 127)
1151 exit (WEXITSTATUS (status
)); /* Can't find or run the command. */
1152 if (WEXITSTATUS (status
) == 255)
1153 error (124, 0, _("%s: exited with status 255; aborting"), bc_state
.cmd_argv
[0]);
1154 if (WIFSTOPPED (status
))
1155 error (125, 0, _("%s: stopped by signal %d"), bc_state
.cmd_argv
[0], WSTOPSIG (status
));
1156 if (WIFSIGNALED (status
))
1157 error (125, 0, _("%s: terminated by signal %d"), bc_state
.cmd_argv
[0], WTERMSIG (status
));
1158 if (WEXITSTATUS (status
) != 0)
1166 /* Wait for all child processes to finish. */
1169 wait_for_proc_all (void)
1171 static boolean waiting
= false;
1177 wait_for_proc (true);
1180 if (original_exit_value
!= child_error
)
1182 /* wait_for_proc() changed the value of child_error(). This
1183 * function is registered via atexit(), and so may have been
1184 * called from exit(). We now know that the original value
1185 * passed to exit() is no longer the exit status we require.
1186 * The POSIX standard states that the behaviour if exit() is
1187 * called more than once is undefined. Therefore we now have to
1188 * exit with _exit() instead of exit().
1195 /* Return the value of the number represented in STR.
1196 OPTION is the command line option to which STR is the argument.
1197 If the value does not fall within the boundaries MIN and MAX,
1198 Print an error message mentioning OPTION. If FATAL is true,
1202 parse_num (char *str
, int option
, long int min
, long int max
, int fatal
)
1207 val
= strtol (str
, &eptr
, 10);
1208 if (eptr
== str
|| *eptr
)
1210 fprintf (stderr
, _("%s: invalid number for -%c option\n"),
1211 program_name
, option
);
1217 fprintf (stderr
, _("%s: value for -%c option should be >= %ld\n"),
1218 program_name
, option
, min
);
1229 else if (max
>= 0 && val
> max
)
1231 fprintf (stderr
, _("%s: value for -%c option should be < %ld\n"),
1232 program_name
, option
, max
);
1247 usage (FILE *stream
)
1249 fprintf (stream
, _("\
1250 Usage: %s [-0prtx] [--interactive] [--null] [-d|--delimiter=delim]\n\
1251 [-E eof-str] [-e[eof-str]] [--eof[=eof-str]]\n\
1252 [-L max-lines] [-l[max-lines]] [--max-lines[=max-lines]]\n\
1253 [-I replace-str] [-i[replace-str]] [--replace[=replace-str]]\n\
1254 [-n max-args] [--max-args=max-args]\n\
1255 [-s max-chars] [--max-chars=max-chars]\n\
1256 [-P max-procs] [--max-procs=max-procs] [--show-limits]\n\
1257 [--verbose] [--exit] [--no-run-if-empty] [--arg-file=file]\n\
1258 [--version] [--help] [command [initial-arguments]]\n"),
1260 fputs (_("\nReport bugs to <bug-findutils@gnu.org>.\n"), stream
);