1 /* xargs -- build and execute command lines from standard input
2 Copyright (C) 1990, 91, 92, 93, 94, 2000,2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
20 /* Written by Mike Rendell <michael@cs.mun.ca>
21 and David MacKenzie <djm@gnu.ai.mit.edu>. */
26 # if defined PROTOTYPES || (defined __STDC__ && __STDC__)
27 # define PARAMS(Args) Args
29 # define PARAMS(Args) ()
35 #if !defined (isascii) || defined (STDC_HEADERS)
43 #define ISBLANK(c) (isascii (c) && isblank (c))
45 #define ISBLANK(c) ((c) == ' ' || (c) == '\t')
48 #define ISSPACE(c) (ISBLANK (c) || (c) == '\n' || (c) == '\r' \
49 || (c) == '\f' || (c) == '\v')
51 #include <sys/types.h>
57 #if defined(HAVE_STRING_H) || defined(STDC_HEADERS)
59 #if !defined(STDC_HEADERS)
64 #define memcpy(dest, source, count) (bcopy((source), (dest), (count)))
68 #include <sys/param.h>
76 #define LONG_MAX (~(1 << (sizeof (long) * 8 - 1)))
85 #if !defined(SIGCHLD) && defined(SIGCLD)
86 #define SIGCHLD SIGCLD
89 /* COMPAT: SYSV version defaults size (and has a max value of) to 470.
90 We try to make it as large as possible. */
91 #if !defined(ARG_MAX) && defined(_SC_ARG_MAX)
92 #define ARG_MAX sysconf (_SC_ARG_MAX)
95 #define ARG_MAX NCARGS
100 /* States for read_line. */
116 # include <libintl.h>
117 # define _(Text) gettext (Text)
119 # define _(Text) Text
120 #define textdomain(Domain)
121 #define bindtextdomain(Package, Directory)
124 # define N_(String) gettext_noop (String)
126 /* See locate.c for explanation as to why not use (String) */
127 # define N_(String) String
130 /* Return nonzero if S is the EOF string. */
131 #define EOF_STR(s) (eof_str && *eof_str == *s && !strcmp (eof_str, s))
133 extern char **environ
;
135 /* Do multibyte processing if multibyte characters are supported,
136 unless multibyte sequences are search safe. Multibyte sequences
137 are search safe if searching for a substring using the byte
138 comparison function 'strstr' gives no false positives. All 8-bit
139 encodings and the UTF-8 multibyte encoding are search safe, but
140 the EUC encodings are not.
141 BeOS uses the UTF-8 encoding exclusively, so it is search safe. */
143 # define MULTIBYTE_IS_SEARCH_SAFE 1
145 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_SEARCH_SAFE)
151 /* Simulate mbrlen with mblen as best we can. */
152 # define mbstate_t int
153 # define mbrlen(s, n, ps) mblen (s, n)
157 /* Not char because of type promotion; NeXT gcc can't handle it. */
169 void error
PARAMS ((int status
, int errnum
, char *message
,...));
171 extern char *version_string
;
173 /* The name this program was run with. */
176 static FILE *input_stream
;
178 /* Buffer for reading arguments from input. */
179 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 /* If nonzero, then instead of putting the args from stdin at
186 the end of the command argument list, they are each stuck into the
187 initial args, replacing each occurrence of the `replace_pat' in the
189 static char *replace_pat
= NULL
;
191 /* The length of `replace_pat'. */
192 static size_t rplen
= 0;
194 /* If nonzero, when this string is read on stdin it is treated as
196 IEEE Std 1003.1, 2004 Edition allows this to be NULL.
197 In findutils releases up to and including 4.2.8, this was "_".
199 static char *eof_str
= NULL
;
201 /* If nonzero, the maximum number of nonblank lines from stdin to use
203 static long lines_per_exec
= 0;
205 /* The maximum number of arguments to use per command line. */
206 static long args_per_exec
= 1024;
208 /* If true, exit if lines_per_exec or args_per_exec is exceeded. */
209 static boolean exit_if_size_exceeded
= false;
211 /* The maximum number of characters that can be used per command line. */
214 /* Storage for elements of `cmd_argv'. */
217 /* The list of args being built. */
218 static char **cmd_argv
= NULL
;
220 /* Number of elements allocated for `cmd_argv'. */
221 static int cmd_argv_alloc
= 0;
223 /* Number of valid elements in `cmd_argv'. */
224 static int cmd_argc
= 0;
226 /* Number of chars being used in `cmd_argv'. */
227 static int cmd_argv_chars
= 0;
229 /* Number of initial arguments given on the command line. */
230 static int initial_argc
= 0;
232 /* Number of chars in the initial args. */
233 static int initial_argv_chars
= 0;
235 /* true when building up initial arguments in `cmd_argv'. */
236 static boolean initial_args
= true;
238 /* If nonzero, the maximum number of child processes that can be running
240 static int proc_max
= 1;
242 /* Total number of child processes that have been executed. */
243 static int procs_executed
= 0;
245 /* The number of elements in `pids'. */
246 static int procs_executing
= 0;
248 /* List of child processes currently executing. */
249 static pid_t
*pids
= NULL
;
251 /* The number of allocated elements in `pids'. */
252 static int pids_alloc
= 0;
254 /* Exit status; nonzero if any child process exited with a
256 static int child_error
= 0;
258 /* If true, print each command on stderr before executing it. */
259 static boolean print_command
= false; /* Option -t */
261 /* If true, query the user before executing each command, and only
262 execute the command if the user responds affirmatively. */
263 static boolean query_before_executing
= false;
265 static struct option
const longopts
[] =
267 {"null", no_argument
, NULL
, '0'},
268 {"arg-file", required_argument
, NULL
, 'a'},
269 {"eof", optional_argument
, NULL
, 'e'},
270 {"replace", optional_argument
, NULL
, 'I'},
271 {"max-lines", optional_argument
, NULL
, 'l'},
272 {"max-args", required_argument
, NULL
, 'n'},
273 {"interactive", no_argument
, NULL
, 'p'},
274 {"no-run-if-empty", no_argument
, NULL
, 'r'},
275 {"max-chars", required_argument
, NULL
, 's'},
276 {"verbose", no_argument
, NULL
, 't'},
277 {"show-limits", no_argument
, NULL
, 'S'},
278 {"exit", no_argument
, NULL
, 'x'},
279 {"max-procs", required_argument
, NULL
, 'P'},
280 {"version", no_argument
, NULL
, 'v'},
281 {"help", no_argument
, NULL
, 'h'},
282 {NULL
, no_argument
, NULL
, 0}
285 static int read_line
PARAMS ((void));
286 static int read_string
PARAMS ((void));
287 static char *mbstrstr
PARAMS ((const char *haystack
, const char *needle
));
288 static void do_insert
PARAMS ((char *arg
, size_t arglen
, size_t lblen
));
289 static void push_arg
PARAMS ((char *arg
, size_t len
));
290 static boolean print_args
PARAMS ((boolean ask
));
291 static void do_exec
PARAMS ((void));
292 static void add_proc
PARAMS ((pid_t pid
));
293 static void wait_for_proc
PARAMS ((boolean all
));
294 static long parse_num
PARAMS ((char *str
, int option
, long min
, long max
, int fatal
));
295 static long env_size
PARAMS ((char **envp
));
296 static void usage
PARAMS ((FILE * stream
));
305 val
= sysconf(_SC_LINE_MAX
);
313 /* either _SC_LINE_MAX was not available or
314 * there is no particular limit.
323 return 2048L; /* a reasonable guess. */
332 val
= sysconf(_SC_ARG_MAX
);
340 /* either _SC_ARG_MAX was not available or
341 * there is no particular limit.
350 /* The value returned by this function bounds the
351 * value applied as the ceiling for the -s option.
352 * Hence it the system won't tell us what its limit
353 * is, we allow the user to specify more or less
354 * whatever value they like.
361 main (int argc
, char **argv
)
364 int show_limits
= 0; /* --show-limits */
365 int always_run_command
= 1;
366 char *input_file
= "-"; /* "-" is stdin */
367 long posix_arg_size_max
;
368 long posix_arg_size_min
;
370 long size_of_environment
= env_size(environ
);
371 char *default_cmd
= "/bin/echo";
372 int (*read_args
) PARAMS ((void)) = read_line
;
374 program_name
= argv
[0];
376 #ifdef HAVE_SETLOCALE
377 setlocale (LC_ALL
, "");
379 bindtextdomain (PACKAGE
, LOCALEDIR
);
380 textdomain (PACKAGE
);
382 /* IEE Std 1003.1, 2003 specifies that the combined argument and
383 * environment list shall not exceed {ARG_MAX}-2048 bytes. It also
384 * specifies that it shall be at least LINE_MAX.
386 posix_arg_size_min
= get_line_max();
387 posix_arg_size_max
= get_arg_max();
388 posix_arg_size_max
-= 2048; /* POSIX.2 requires subtracting 2048. */
389 arg_max
= posix_arg_size_max
;
391 /* Start with a reasonable default size, though this can be
392 * adjusted via the -s option.
394 arg_size
= (128 * 1024) + size_of_environment
;
396 /* Take the size of the environment into account. */
397 if (size_of_environment
> posix_arg_size_max
)
399 error (1, 0, _("environment is too large for exec"));
403 arg_max
= posix_arg_size_max
- size_of_environment
;
406 /* Check against the upper and lower limits. */
407 if (arg_size
> arg_max
)
409 if (arg_size
< posix_arg_size_min
)
410 arg_size
= posix_arg_size_min
;
415 while ((optc
= getopt_long (argc
, argv
, "+0a:E:e::i::I:l::L:n:prs:txP:",
416 longopts
, (int *) 0)) != -1)
421 read_args
= read_string
;
424 case 'E': /* POSIX */
425 case 'e': /* deprecated */
426 if (optarg
&& (strlen(optarg
) > 0))
436 case 'I': /* POSIX */
437 case 'i': /* deprecated */
439 replace_pat
= optarg
;
442 /* -i excludes -n -l. */
447 case 'L': /* POSIX */
448 case 'l': /* deprecated */
450 lines_per_exec
= parse_num (optarg
, 'l', 1L, -1L, 1);
453 /* -l excludes -i -n. */
459 args_per_exec
= parse_num (optarg
, 'n', 1L, -1L, 1);
460 /* -n excludes -i -l. */
462 if (args_per_exec
== 1 && replace_pat
)
463 /* ignore -n1 in '-i -n1' */
469 /* The POSIX standard specifies that it is not an error
470 * for the -s option to specify a size that the implementation
471 * cannot support - in that case, the relevant limit is used.
474 arg_size
= parse_num (optarg
, 's', 1L, posix_arg_size_max
, 0);
475 if (arg_size
> posix_arg_size_max
)
477 error (0, 0, "warning: value %ld for -s option is too large, using %ld instead", arg_size
, posix_arg_size_max
);
478 arg_size
= posix_arg_size_max
;
487 print_command
= true;
491 exit_if_size_exceeded
= true;
495 query_before_executing
= true;
496 print_command
= true;
500 always_run_command
= 0;
504 proc_max
= parse_num (optarg
, 'P', 0L, -1L, 1);
512 printf (_("GNU xargs version %s\n"), version_string
);
521 if (0 == strcmp (input_file
, "-"))
523 input_stream
= stdin
;
527 keep_stdin
= 1; /* see prep_child_for_exec() */
528 input_stream
= fopen (input_file
, "r");
529 if (NULL
== input_stream
)
532 _("Cannot open input file `%s'"),
537 if (replace_pat
|| lines_per_exec
)
538 exit_if_size_exceeded
= true;
547 /* Taking into account the size of the environment,
548 * figure out how large a buffer we need to
549 * hold all the arguments. We cannot use ARG_MAX
550 * directly since that may be arbitrarily large.
551 * This is from a patch by Bob Prolux, <bob@proulx.com>.
553 if (arg_max
> arg_size
)
558 _("Reducing arg_max (%ld) to arg_size (%ld)\n"),
567 _("Your environment variables take up %ld bytes\n"),
568 size_of_environment
);
570 _("POSIX lower and upper limits on argument length: %ld, %ld\n"),
574 _("Maximum length of command we could actually use: %ld\n"),
575 (posix_arg_size_max
- size_of_environment
));
577 _("Size of command buffer we are actually using: %ld\n"),
581 linebuf
= (char *) xmalloc (arg_max
+ 1);
582 argbuf
= (char *) xmalloc (arg_max
+ 1);
584 /* Make sure to listen for the kids. */
585 signal (SIGCHLD
, SIG_DFL
);
589 for (; optind
< argc
; optind
++)
590 push_arg (argv
[optind
], strlen (argv
[optind
]) + 1);
591 initial_args
= false;
592 initial_argc
= cmd_argc
;
593 initial_argv_chars
= cmd_argv_chars
;
595 while ((*read_args
) () != -1)
596 if (lines_per_exec
&& lineno
>= lines_per_exec
)
602 /* SYSV xargs seems to do at least one exec, even if the
604 if (cmd_argc
!= initial_argc
605 || (always_run_command
&& procs_executed
== 0))
612 size_t *arglen
= (size_t *) xmalloc (sizeof (size_t) * argc
);
614 for (i
= optind
; i
< argc
; i
++)
615 arglen
[i
] = strlen(argv
[i
]);
616 rplen
= strlen (replace_pat
);
617 while ((len
= (*read_args
) ()) != -1)
619 /* Don't do insert on the command name. */
620 push_arg (argv
[optind
], arglen
[optind
] + 1);
622 for (i
= optind
+ 1; i
< argc
; i
++)
623 do_insert (argv
[i
], arglen
[i
], len
);
628 wait_for_proc (true);
634 append_char_to_buf(char **pbuf
, char **pend
, char **pp
, int c
)
636 char *end_of_buffer
= *pend
;
637 char *start_of_buffer
= *pbuf
;
639 if (p
>= end_of_buffer
)
643 size_t len
= end_of_buffer
- start_of_buffer
;
644 size_t offset
= p
- start_of_buffer
;
646 start_of_buffer
= xrealloc(start_of_buffer
, len
*2);
647 if (NULL
!= start_of_buffer
)
649 end_of_buffer
= start_of_buffer
+ len
;
650 p
= start_of_buffer
+ offset
;
653 /* Update the caller's idea of where the buffer is. */
654 *pbuf
= start_of_buffer
;
655 *pend
= end_of_buffer
;
662 /* Failed to reallocate. */
668 /* I suspect that this can never happen now, because append_char_to_buf()
669 * should only be called wen replace_pat is true.
671 error (1, 0, _("argument line too long"));
678 /* Enough space remains. */
687 /* Read a line of arguments from the input and add them to the list of
688 arguments to pass to the command. Ignore blank lines and initial blanks.
689 Single and double quotes and backslashes quote metacharacters and blanks
690 as they do in the shell.
691 Return -1 if eof (either physical or logical) is reached,
692 otherwise the length of the last string read (including the null). */
697 static boolean eof
= false;
698 /* Start out in mode SPACE to always strip leading spaces (even with -i). */
699 int state
= SPACE
; /* The type of character we last read. */
700 int prevc
; /* The previous value of c. */
701 int quotc
= 0; /* The last quote character read. */
703 boolean first
= true; /* true if reading first arg on line. */
706 /* Including the NUL, the args must not grow past this point. */
707 char *endbuf
= linebuf
+ arg_max
- initial_argv_chars
- 1;
714 c
= getc (input_stream
);
717 /* COMPAT: SYSV seems to ignore stuff on a line that
718 ends without a \n; we don't. */
724 /* FIXME we don't check for unterminated quotes here. */
725 if (first
&& EOF_STR (linebuf
))
728 push_arg (linebuf
, len
);
742 if (!ISBLANK (prevc
))
743 lineno
++; /* For -l. */
752 if (EOF_STR (linebuf
))
755 return first
? -1 : len
;
758 push_arg (linebuf
, len
);
761 if (!replace_pat
&& ISSPACE (c
))
765 if (EOF_STR (linebuf
))
768 return first
? -1 : len
;
770 push_arg (linebuf
, len
);
792 error (1, 0, _("unmatched %s quote; by default quotes are special to xargs unless you use the -0 option"),
793 quotc
== '"' ? _("double") : _("single"));
807 error (1, 0, _("argument line too long"));
810 append_char_to_buf(&linebuf
, &endbuf
, &p
, c
);
815 /* Read a null-terminated string from the input and add it to the list of
816 arguments to pass to the command.
817 Return -1 if eof (either physical or logical) is reached,
818 otherwise the length of the string read (including the null). */
823 static boolean eof
= false;
826 /* Including the NUL, the args must not grow past this point. */
827 char *endbuf
= linebuf
+ arg_max
- initial_argv_chars
- 1;
833 int c
= getc (input_stream
);
842 push_arg (linebuf
, len
);
847 lineno
++; /* For -l. */
851 push_arg (linebuf
, len
);
855 error (1, 0, _("argument line too long"));
860 /* Finds the first occurrence of the substring NEEDLE in the string
861 HAYSTACK. Both strings can be multibyte strings. */
864 mbstrstr (const char *haystack
, const char *needle
)
869 size_t hlen
= strlen (haystack
);
870 size_t nlen
= strlen (needle
);
874 memset (&mbstate
, 0, sizeof (mbstate_t));
877 if (memcmp (haystack
, needle
, nlen
) == 0)
878 return (char *) haystack
;
879 step
= mbrlen (haystack
, hlen
, &mbstate
);
888 return strstr (haystack
, needle
);
891 /* Replace all instances of `replace_pat' in ARG with `linebuf',
892 and add the resulting string to the list of arguments for the command
894 ARGLEN is the length of ARG, not including the null.
895 LBLEN is the length of `linebuf', not including the null.
897 COMPAT: insertions on the SYSV version are limited to 255 chars per line,
898 and a max of 5 occurrences of replace_pat in the initial-arguments.
899 Those restrictions do not exist here. */
902 do_insert (char *arg
, size_t arglen
, size_t lblen
)
904 /* Temporary copy of each arg with the replace pattern replaced by the
906 static char *insertbuf
;
908 int bytes_left
= arg_max
- 1; /* Bytes left on the command line. */
911 insertbuf
= (char *) xmalloc (arg_max
+ 1);
916 size_t len
; /* Length in ARG before `replace_pat'. */
917 char *s
= mbstrstr (arg
, replace_pat
);
926 strncpy (p
, arg
, len
);
944 error (1, 0, _("command too long"));
946 push_arg (insertbuf
, p
- insertbuf
);
949 /* Add ARG to the end of the list of arguments `cmd_argv' to pass
951 LEN is the length of ARG, including the terminating null.
952 If this brings the list up to its maximum size, execute the command. */
955 push_arg (char *arg
, size_t len
)
959 if (cmd_argv_chars
+ len
> arg_max
)
961 if (initial_args
|| cmd_argc
== initial_argc
)
962 error (1, 0, _("can not fit single argument within argument list size limit"));
963 /* option -i (replace_pat) implies -x (exit_if_size_exceeded) */
965 || (exit_if_size_exceeded
&&
966 (lines_per_exec
|| args_per_exec
)))
967 error (1, 0, _("argument list too long"));
970 if (!initial_args
&& args_per_exec
&&
971 cmd_argc
- initial_argc
== args_per_exec
)
975 if (cmd_argc
>= cmd_argv_alloc
)
980 cmd_argv
= (char **) xmalloc (sizeof (char *) * cmd_argv_alloc
);
985 cmd_argv
= (char **) xrealloc (cmd_argv
,
986 sizeof (char *) * cmd_argv_alloc
);
991 cmd_argv
[cmd_argc
++] = NULL
;
994 cmd_argv
[cmd_argc
++] = argbuf
+ cmd_argv_chars
;
995 strcpy (argbuf
+ cmd_argv_chars
, arg
);
996 cmd_argv_chars
+= len
;
998 /* If we have now collected enough arguments,
999 * do the exec immediately. This must be
1000 * conditional on arg!=NULL, since do_exec()
1001 * actually calls push_arg(NULL, 0).
1005 && (cmd_argc
- initial_argc
) == args_per_exec
)
1010 /* Print the arguments of the command to execute.
1011 If ASK is nonzero, prompt the user for a response, and
1012 if the user responds affirmatively, return true;
1013 otherwise, return false. */
1016 print_args (boolean ask
)
1020 for (i
= 0; i
< cmd_argc
- 1; i
++)
1021 fprintf (stderr
, "%s ", cmd_argv
[i
]);
1024 static FILE *tty_stream
;
1029 tty_stream
= fopen ("/dev/tty", "r");
1031 error (1, errno
, "/dev/tty");
1033 fputs ("?...", stderr
);
1035 c
= savec
= getc (tty_stream
);
1036 while (c
!= EOF
&& c
!= '\n')
1037 c
= getc (tty_stream
);
1038 if (savec
== 'y' || savec
== 'Y')
1042 putc ('\n', stderr
);
1048 /* Close stdin and attach /dev/null to it.
1049 * This resolves Savannah bug #3992.
1052 prep_child_for_exec (void)
1056 const char inputfile
[] = "/dev/null";
1057 /* fprintf(stderr, "attaching stdin to /dev/null\n"); */
1060 if (open(inputfile
, O_RDONLY
) < 0)
1062 /* This is not entirely fatal, since
1063 * executing the child with a closed
1064 * stdin is almost as good as executing it
1065 * with its stdin attached to /dev/null.
1067 error (0, errno
, "%s", inputfile
);
1073 /* Execute the command that has been built in `cmd_argv'. This may involve
1074 waiting for processes that were previously executed. */
1081 push_arg ((char *) NULL
, 0); /* Null terminate the arg list. */
1082 if (!query_before_executing
|| print_args (true))
1084 if (proc_max
&& procs_executing
>= proc_max
)
1085 wait_for_proc (false);
1086 if (!query_before_executing
&& print_command
)
1088 /* If we run out of processes, wait for a child to return and
1090 while ((child
= fork ()) < 0 && errno
== EAGAIN
&& procs_executing
)
1091 wait_for_proc (false);
1095 error (1, errno
, _("cannot fork"));
1097 case 0: /* Child. */
1098 prep_child_for_exec();
1099 execvp (cmd_argv
[0], cmd_argv
);
1100 error (0, errno
, "%s", cmd_argv
[0]);
1101 _exit (errno
== ENOENT
? 127 : 126);
1107 cmd_argc
= initial_argc
;
1108 cmd_argv_chars
= initial_argv_chars
;
1111 /* Add the process with id PID to the list of processes that have
1115 add_proc (pid_t pid
)
1119 /* Find an empty slot. */
1120 for (i
= 0; i
< pids_alloc
&& pids
[i
]; i
++)
1122 if (i
== pids_alloc
)
1124 if (pids_alloc
== 0)
1126 pids_alloc
= proc_max
? proc_max
: 64;
1127 pids
= (pid_t
*) xmalloc (sizeof (pid_t
) * pids_alloc
);
1132 pids
= (pid_t
*) xrealloc (pids
,
1133 sizeof (pid_t
) * pids_alloc
);
1135 memset (&pids
[i
], '\0', sizeof (pid_t
) * (pids_alloc
- i
));
1142 /* If ALL is true, wait for all child processes to finish;
1143 otherwise, wait for one child process to finish.
1144 Remove the processes that finish from the list of executing processes. */
1147 wait_for_proc (boolean all
)
1149 while (procs_executing
)
1157 while ((pid
= wait (&status
)) == (pid_t
) -1)
1159 error (1, errno
, _("error waiting for child process"));
1161 /* Find the entry in `pids' for the child process
1163 for (i
= 0; i
< pids_alloc
&& pid
!= pids
[i
]; i
++)
1166 while (i
== pids_alloc
); /* A child died that we didn't start? */
1168 /* Remove the child from the list. */
1172 if (WEXITSTATUS (status
) == 126 || WEXITSTATUS (status
) == 127)
1173 exit (WEXITSTATUS (status
)); /* Can't find or run the command. */
1174 if (WEXITSTATUS (status
) == 255)
1175 error (124, 0, _("%s: exited with status 255; aborting"), cmd_argv
[0]);
1176 if (WIFSTOPPED (status
))
1177 error (125, 0, _("%s: stopped by signal %d"), cmd_argv
[0], WSTOPSIG (status
));
1178 if (WIFSIGNALED (status
))
1179 error (125, 0, _("%s: terminated by signal %d"), cmd_argv
[0], WTERMSIG (status
));
1180 if (WEXITSTATUS (status
) != 0)
1188 /* Return the value of the number represented in STR.
1189 OPTION is the command line option to which STR is the argument.
1190 If the value does not fall within the boundaries MIN and MAX,
1191 Print an error message mentioning OPTION. If FATAL is true,
1195 parse_num (char *str
, int option
, long int min
, long int max
, int fatal
)
1200 val
= strtol (str
, &eptr
, 10);
1201 if (eptr
== str
|| *eptr
)
1203 fprintf (stderr
, _("%s: invalid number for -%c option\n"),
1204 program_name
, option
);
1210 fprintf (stderr
, _("%s: value for -%c option should be >= %ld\n"),
1211 program_name
, option
, min
);
1222 else if (max
>= 0 && val
> max
)
1224 fprintf (stderr
, _("%s: value for -%c option should be < %ld\n"),
1225 program_name
, option
, max
);
1239 /* Return how much of ARG_MAX is used by the environment. */
1242 env_size (char **envp
)
1247 len
+= strlen (*envp
++) + 1;
1253 usage (FILE *stream
)
1255 fprintf (stream
, _("\
1256 Usage: %s [-0prtx] [-e[eof-str]] [-i[replace-str]] [-l[max-lines]]\n\
1257 [-n max-args] [-s max-chars] [-P max-procs] [--null] [--eof[=eof-str]]\n\
1258 [--replace[=replace-str]] [--max-lines[=max-lines]] [--interactive]\n\
1259 [--max-chars=max-chars] [--verbose] [--exit] [--max-procs=max-procs]\n\
1260 [--max-args=max-args] [--no-run-if-empty] [--arg-file=file]\n\
1261 [--version] [--help] [command [initial-arguments]]\n"),
1263 fputs (_("\nReport bugs to <bug-findutils@gnu.org>.\n"), stream
);