Use minix xargs instead, and update docs accordingly

 -Erik

1 files changed, 106 insertions, 913 deletions

diff --git a/findutils/xargs.c b/findutils/xargs.c
index adf1f134c..be1fada78 100644
--- a/findutils/xargs.c
+++ b/findutils/xargs.c
@@ -1,923 +1,116 @@
-/* xargs for busybox  -- using GNU xargs till we can get something
- * better.  minix xargs is a bit smaller... */
+/* minix xargs - Make and execute commands	     
+ * Author: Ian Nicholls:  1 Mar 90 */
+
+/*
+ * xargs  - Accept words from stdin until, combined with the arguments
+ *	    given on the command line, just fit into the command line limit.
+ *	    Then, execute the result.
+ * 		e.g.    ls | xargs compress
+ *			find . -name '*.s' -print | xargs ar qv libc.a
+ *
+ * flags: -t		Print the command just before it is run
+ *	  -l len	Use len as maximum line length (default 490, max 1023)
+ *	  -e ending	Append ending to the command before executing it.
+ *
+ * Exits with:	0  No errors.
+ *		1  If any system(3) call returns a nonzero status.
+ *		2  Usage error
+ *		3  Line length too short to contain some single argument.
+ *
+ * Examples:	xargs ar qv libc.a < liborder		# Create a new libc.a
+ *		find . -name '*.s' -print | xargs rm	# Remove all .s files
+ *		find . -type f ! -name '*.Z' \		# Compress old files.
+ *		       -atime +60 -print  | xargs compress -v
+ *
+ * Bugs:  If the command contains unquoted wildflags, then the system(3) call
+ *		call may expand this to larger than the maximum line size.
+ *	  The command is not executed if nothing was read from stdin.
+ *	  xargs may give up too easily when the command returns nonzero.
+ */
+#define USAGE "usage: xargs [-t] [-l len] [-e endargs] command [args...]\n"
 
-/* xargs -- build and execute command lines from standard input
-   Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify
-   it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-/* Written by Mike Rendell <michael@cs.mun.ca>
-   and David MacKenzie <djm@gnu.ai.mit.edu>.  */
-
-#include "internal.h"
-
-#define HAVE_STRING_H 1
-#define HAVE_SYS_WAIT_H 1
-#define HAVE_UNISTD_H 1
-#define HAVE_LIMITS_H 1
-#define STDC_HEADERS 1
-
-#include <sys/types.h>		/* For pid_t. */
-#if HAVE_SYS_WAIT_H
-#include <sys/wait.h>
-#endif
-
-#ifndef WIFSTOPPED
-#define WIFSTOPPED(w) (((w) & 0xff) == 0x7f)
-#endif
-#ifndef WIFSIGNALED
-#define WIFSIGNALED(w) (((w) & 0xff) != 0x7f && ((w) & 0xff) != 0)
-#endif
-#ifndef WIFEXITED
-#define WIFEXITED(w) (((w) & 0xff) == 0)
-#endif
-
-#ifndef WSTOPSIG
-#define WSTOPSIG(w) (((w) >> 8) & 0xff)
-#endif
-#ifndef WTERMSIG
-#define WTERMSIG(w) ((w) & 0x7f)
-#endif
-#ifndef WEXITSTATUS
-#define WEXITSTATUS(w) (((w) >> 8) & 0xff)
-#endif
-
-#if __STDC__
-#define P_(s) s
-#else
-#define P_(s) ()
-#endif
-
-#include <ctype.h>
-
-#if !defined (isascii) || defined (STDC_HEADERS)
-#ifdef isascii
-#undef isascii
-#endif
-#define isascii(c) 1
-#endif
-
-#ifdef isblank
-#define ISBLANK(c) (isascii (c) && isblank (c))
-#else
-#define ISBLANK(c) ((c) == ' ' || (c) == '\t')
-#endif
-
-#define ISSPACE(c) (ISBLANK (c) || (c) == '\n' || (c) == '\r' \
-		    || (c) == '\f' || (c) == '\v')
-
-#include <stdio.h>
 #include <errno.h>
-#include <getopt.h>
-
-#if defined(HAVE_STRING_H) || defined(STDC_HEADERS)
+#include <stdlib.h>
 #include <string.h>
-#if !defined(STDC_HEADERS)
-#include <memory.h>
-#endif
-#else
-#include <strings.h>
-#define memcpy(dest, source, count) (bcopy((source), (dest), (count)))
-#endif
-
-#ifndef _POSIX_SOURCE
-#include <sys/param.h>
-#endif
-
-#ifdef HAVE_LIMITS_H
-#include <limits.h>
-#endif
-
-#ifndef LONG_MAX
-#define LONG_MAX (~(1 << (sizeof (long) * 8 - 1)))
-#endif
-
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif
-
-#include <signal.h>
-
-#if !defined(SIGCHLD) && defined(SIGCLD)
-#define SIGCHLD SIGCLD
-#endif
-
-/* COMPAT:  SYSV version defaults size (and has a max value of) to 470.
-   We try to make it as large as possible. */
-#if !defined(ARG_MAX) && defined(_SC_ARG_MAX)
-#define ARG_MAX sysconf (_SC_ARG_MAX)
-#endif
-#ifndef ARG_MAX
-#define ARG_MAX NCARGS
-#endif
-
-/* States for read_line. */
-#define NORM 0
-#define SPACE 1
-#define QUOTE 2
-#define BACKSLASH 3
+#include <stdio.h>
+#include <getopt.h>
 
-#ifdef STDC_HEADERS
-#include <stdlib.h>
-#else
-extern int errno;
+#ifndef MAX_ARGLINE
+# define MAX_ARGLINE 1023
 #endif
-
-/* Return nonzero if S is the EOF string.  */
-#define EOF_STR(s) (eof_str && *eof_str == *s && !strcmp (eof_str, s))
-
-extern char **environ;
-
-/* Not char because of type promotion; NeXT gcc can't handle it.  */
-typedef int boolean;
-#define		true    1
-#define		false	0
-
-#if __STDC__
-#define VOID void
-#else
-#define VOID char
+#ifndef min
+# define min(a,b) ((a) < (b) ? (a) : (b))
 #endif
 
-VOID *xmalloc P_ ((size_t n));
-VOID *xrealloc P_ ((VOID * p, size_t n));
-
-/* The name this program was run with.  */
-char *program_name;
-
-/* Buffer for reading arguments from stdin.  */
-static char *linebuf;
-
-/* Line number in stdin since the last command was executed.  */
-static int lineno = 0;
-
-/* If nonzero, then instead of putting the args from stdin at
-   the end of the command argument list, they are each stuck into the
-   initial args, replacing each occurrence of the `replace_pat' in the
-   initial args.  */
-static char *replace_pat = NULL;
-
-/* The length of `replace_pat'.  */
-static size_t rplen = 0;
-
-/* If nonzero, when this string is read on stdin it is treated as
-   end of file.
-   I don't like this - it should default to NULL.  */
-static char *eof_str = "_";
-
-/* If nonzero, the maximum number of nonblank lines from stdin to use
-   per command line.  */
-static long lines_per_exec = 0;
-
-/* The maximum number of arguments to use per command line.  */
-static long args_per_exec = 1024;
-
-/* If true, exit if lines_per_exec or args_per_exec is exceeded.  */
-static boolean exit_if_size_exceeded = false;
-
-/* The maximum number of characters that can be used per command line.  */
-static long arg_max;
-
-/* Storage for elements of `cmd_argv'.  */
-static char *argbuf;
-
-/* The list of args being built.  */
-static char **cmd_argv = NULL;
-
-/* Number of elements allocated for `cmd_argv'.  */
-static int cmd_argv_alloc = 0;
-
-/* Number of valid elements in `cmd_argv'.  */
-static int cmd_argc = 0;
+char outlin[MAX_ARGLINE];
+char inlin[MAX_ARGLINE];
+char startlin[MAX_ARGLINE];
+char *ending = NULL;
+char traceflag = 0;
 
-/* Number of chars being used in `cmd_argv'.  */
-static int cmd_argv_chars = 0;
-
-/* Number of initial arguments given on the command line.  */
-static int initial_argc = 0;
-
-/* Number of chars in the initial args.  */
-static int initial_argv_chars = 0;
-
-/* true when building up initial arguments in `cmd_argv'.  */
-static boolean initial_args = true;
-
-/* If nonzero, the maximum number of child processes that can be running
-   at once.  */
-static int proc_max = 1;
-
-/* Total number of child processes that have been executed.  */
-static int procs_executed = 0;
-
-/* The number of elements in `pids'.  */
-static int procs_executing = 0;
-
-/* List of child processes currently executing.  */
-static pid_t *pids = NULL;
-
-/* The number of allocated elements in `pids'. */
-static int pids_alloc = 0;
-
-/* Exit status; nonzero if any child process exited with a
-   status of 1-125.  */
-static int child_error = 0;
-
-/* If true, print each command on stderr before executing it.  */
-static boolean print_command = false;
-
-/* If true, query the user before executing each command, and only
-   execute the command if the user responds affirmatively.  */
-static boolean query_before_executing = false;
-
-static struct option const longopts[] =
-{
-  {"null", no_argument, NULL, '0'},
-  {"eof", optional_argument, NULL, 'e'},
-  {"replace", optional_argument, NULL, 'i'},
-  {"max-lines", optional_argument, NULL, 'l'},
-  {"max-args", required_argument, NULL, 'n'},
-  {"interactive", no_argument, NULL, 'p'},
-  {"no-run-if-empty", no_argument, NULL, 'r'},
-  {"max-chars", required_argument, NULL, 's'},
-  {"verbose", no_argument, NULL, 't'},
-  {"exit", no_argument, NULL, 'x'},
-  {"max-procs", required_argument, NULL, 'P'},
-  {"help", no_argument, NULL, 'h'},
-  {NULL, no_argument, NULL, 0}
-};
-
-static int read_line P_ ((void));
-static int read_string P_ ((void));
-static void do_insert P_ ((char *arg, size_t arglen, size_t lblen));
-static void push_arg P_ ((char *arg, size_t len));
-static boolean print_args P_ ((boolean ask));
-static void do_exec P_ ((void));
-static void add_proc P_ ((pid_t pid));
-static void wait_for_proc P_ ((boolean all));
-static long parse_num P_ ((char *str, int option, long min, long max));
-static long env_size P_ ((char **envp));
-
-int xargs_main (argc, argv)
-     int argc;
-     char **argv;
+int xargs_main(int ac, char **av)
 {
-  int optc;
-  int always_run_command = 1;
-  long orig_arg_max;
-  char *default_cmd = "/bin/echo";
-  int (*read_args) P_ ((void)) = read_line;
-
-  program_name = argv[0];
-
-  orig_arg_max = ARG_MAX;
-  if (orig_arg_max == -1)
-    orig_arg_max = LONG_MAX;
-  orig_arg_max -= 2048; /* POSIX.2 requires subtracting 2048.  */
-  arg_max = orig_arg_max;
-
-  /* Sanity check for systems with huge ARG_MAX defines (e.g., Suns which
-     have it at 1 meg).  Things will work fine with a large ARG_MAX but it
-     will probably hurt the system more than it needs to; an array of this
-     size is allocated.  */
-  if (arg_max > 20 * 1024)
-    arg_max = 20 * 1024;
-
-  /* Take the size of the environment into account.  */
-  arg_max -= env_size (environ);
-  if (arg_max <= 0)
-    fatalError("environment is too large for exec");
-
-  while ((optc = getopt_long (argc, argv, "+0e::i::l::n:prs:txP:",
-			      longopts, (int *) 0)) != -1)
-    {
-      switch (optc)
-	{
-	case '0':
-	  read_args = read_string;
-	  break;
-
-	case 'e':
-	  if (optarg)
-	    eof_str = optarg;
-	  else
-	    eof_str = 0;
-	  break;
-
-	case 'h':
-	  usage (xargs_usage);
-
-	case 'i':
-	  if (optarg)
-	    replace_pat = optarg;
-	  else
-	    replace_pat = "{}";
-	  /* -i excludes -n -l.  */
-	  args_per_exec = 0;
-	  lines_per_exec = 0;
-	  break;
-
-	case 'l':
-	  if (optarg)
-	    lines_per_exec = parse_num (optarg, 'l', 1L, -1L);
-	  else
-	    lines_per_exec = 1;
-	  /* -l excludes -i -n.  */
-	  args_per_exec = 0;
-	  replace_pat = NULL;
-	  break;
-
-	case 'n':
-	  args_per_exec = parse_num (optarg, 'n', 1L, -1L);
-	  /* -n excludes -i -l.  */
-	  lines_per_exec = 0;
-	  replace_pat = NULL;
-	  break;
-
-	case 's':
-	  arg_max = parse_num (optarg, 's', 1L, orig_arg_max);
-	  break;
-
-	case 't':
-	  print_command = true;
-	  break;
-
-	case 'x':
-	  exit_if_size_exceeded = true;
-	  break;
-
-	case 'p':
-	  query_before_executing = true;
-	  print_command = true;
-	  break;
-
-	case 'r':
-	  always_run_command = 0;
-	  break;
-
-	case 'P':
-	  proc_max = parse_num (optarg, 'P', 0L, -1L);
-	  break;
-
-	default:
-	  usage (xargs_usage);
-	}
-    }
-
-  if (replace_pat || lines_per_exec)
-    exit_if_size_exceeded = true;
-
-  if (optind == argc)
-    {
-      optind = 0;
-      argc = 1;
-      argv = &default_cmd;
-    }
-
-  linebuf = (char *) xmalloc (arg_max + 1);
-  argbuf = (char *) xmalloc (arg_max + 1);
-
-  /* Make sure to listen for the kids.  */
-  signal (SIGCHLD, SIG_DFL);
-
-  if (!replace_pat)
-    {
-      for (; optind < argc; optind++)
-	push_arg (argv[optind], strlen (argv[optind]) + 1);
-      initial_args = false;
-      initial_argc = cmd_argc;
-      initial_argv_chars = cmd_argv_chars;
-
-      while ((*read_args) () != -1)
-	if (lines_per_exec && lineno >= lines_per_exec)
-	  {
-	    do_exec ();
-	    lineno = 0;
-	  }
-
-      /* SYSV xargs seems to do at least one exec, even if the
-         input is empty.  */
-      if (cmd_argc != initial_argc
-	  || (always_run_command && procs_executed == 0))
-	do_exec ();
-    }
-  else
-    {
-      int i;
-      size_t len;
-      size_t *arglen = (size_t *) xmalloc (sizeof (size_t) * argc);
-
-      for (i = optind; i < argc; i++)
-	arglen[i] = strlen(argv[i]);
-      rplen = strlen (replace_pat);
-      while ((len = (*read_args) ()) != -1)
-	{
-	  /* Don't do insert on the command name.  */
-	  push_arg (argv[optind], arglen[optind] + 1);
-	  len--;
-	  for (i = optind + 1; i < argc; i++)
-	    do_insert (argv[i], arglen[i], len);
-	  do_exec ();
-	}
-    }
-
-  wait_for_proc (true);
-  exit (child_error);
+   int outlen, inlen, startlen, endlen=0, i;
+   char errflg = 0;
+   int maxlin = MAX_ARGLINE;
+
+   while ((i = getopt(ac, av, "tl:e:")) != EOF)
+       switch (i) {
+	   case 't': traceflag = 1;	  break;
+	   case 'l': maxlin = min(MAX_ARGLINE, atoi(optarg)); break;
+	   case 'e': ending = optarg;	  break;
+	   case '?': errflg++;		  break;
+       }
+   if (errflg)	{
+       fprintf(stderr, USAGE);
+       exit(2);
+   }
+
+   startlin[0] = 0;
+   if (optind == ac) {
+       strcat(startlin, "echo ");
+   }
+   else for ( ; optind < ac; optind++) {
+       strcat(startlin, av[optind]);
+       strcat(startlin, " ");
+   }
+   startlen = strlen(startlin);
+   if (ending) endlen = strlen(ending);
+   maxlin = maxlin - 1 - endlen;	/* Pre-compute */
+
+   strcpy(outlin, startlin);
+   outlen = startlen;
+
+   while (gets(inlin) != NULL) {
+       inlen = strlen(inlin);
+       if (maxlin <= (outlen + inlen)) {
+	   if (outlen == startlen) {
+	       fprintf(stderr, "%s: Line length too short to process '%s'\n",
+		       av[0], inlin);
+	       exit(3);
+	   }
+	   if (ending) strcat(outlin, ending);
+	   if (traceflag) fputs(outlin,stderr);
+	   errno = 0;
+	   if (0 != system(outlin)) {
+	       if (errno != 0) perror("xargs");
+	       exit(1);
+	   }
+	   strcpy(outlin, startlin);
+	   outlen = startlen;
+       }
+       strcat(outlin, inlin);
+       strcat(outlin, " ");
+       outlen = outlen + inlen + 1;
+   }
+   if (outlen != startlen) {
+       if (ending) strcat(outlin, ending);
+       if (traceflag) fputs(outlin,stderr);
+       errno = 0;
+       if (0 != system(outlin)) {
+	   if (errno != 0) perror("xargs");
+	   exit(1);
+       }
+   }    
+   return 0;
 }
-
-/* Read a line of arguments from stdin and add them to the list of
-   arguments to pass to the command.  Ignore blank lines and initial blanks.
-   Single and double quotes and backslashes quote metacharacters and blanks
-   as they do in the shell.
-   Return -1 if eof (either physical or logical) is reached,
-   otherwise the length of the last string read (including the null).  */
-
-static int
-read_line ()
-{
-  static boolean eof = false;
-  /* Start out in mode SPACE to always strip leading spaces (even with -i).  */
-  int state = SPACE;		/* The type of character we last read.  */
-  int prevc;			/* The previous value of c.  */
-  int quotc = 0;		/* The last quote character read.  */
-  int c = EOF;
-  boolean first = true;		/* true if reading first arg on line.  */
-  int len;
-  char *p = linebuf;
-  /* Including the NUL, the args must not grow past this point.  */
-  char *endbuf = linebuf + arg_max - initial_argv_chars - 1;
-
-  if (eof)
-    return -1;
-  while (1)
-    {
-      prevc = c;
-      c = getc (stdin);
-      if (c == EOF)
-	{
-	  /* COMPAT: SYSV seems to ignore stuff on a line that
-	     ends without a \n; we don't.  */
-	  eof = true;
-	  if (p == linebuf)
-	    return -1;
-	  *p++ = '\0';
-	  len = p - linebuf;
-	  /* FIXME we don't check for unterminated quotes here.  */
-	  if (first && EOF_STR (linebuf))
-	    return -1;
-	  if (!replace_pat)
-	    push_arg (linebuf, len);
-	  return len;
-	}
-      switch (state)
-	{
-	case SPACE:
-	  if (ISSPACE (c))
-	    continue;
-	  state = NORM;
-	  /* aaahhhh....  */
-
-	case NORM:
-	  if (c == '\n')
-	    {
-	      if (!ISBLANK (prevc))
-		lineno++;	/* For -l.  */
-	      if (p == linebuf)
-		{
-		  /* Blank line.  */
-		  state = SPACE;
-		  continue;
-		}
-	      *p++ = '\0';
-	      len = p - linebuf;
-	      if (EOF_STR (linebuf))
-		{
-		  eof = true;
-		  return first ? -1 : len;
-		}
-	      if (!replace_pat)
-		push_arg (linebuf, len);
-	      return len;
-	    }
-	  if (!replace_pat && ISSPACE (c))
-	    {
-	      *p++ = '\0';
-	      len = p - linebuf;
-	      if (EOF_STR (linebuf))
-		{
-		  eof = true;
-		  return first ? -1 : len;
-		}
-	      push_arg (linebuf, len);
-	      p = linebuf;
-	      state = SPACE;
-	      first = false;
-	      continue;
-	    }
-	  switch (c)
-	    {
-	    case '\\':
-	      state = BACKSLASH;
-	      continue;
-
-	    case '\'':
-	    case '"':
-	      state = QUOTE;
-	      quotc = c;
-	      continue;
-	    }
-	  break;
-
-	case QUOTE:
-	  if (c == '\n')
-	    fatalError ("unmatched %s quote", quotc == '"' ? "double" : "single");
-	  if (c == quotc)
-	    {
-	      state = NORM;
-	      continue;
-	    }
-	  break;
-
-	case BACKSLASH:
-	  state = NORM;
-	  break;
-	}
-      if (p >= endbuf)
-	fatalError ("argument line too long");
-      *p++ = c;
-    }
-}
-
-/* Read a null-terminated string from stdin and add it to the list of
-   arguments to pass to the command.
-   Return -1 if eof (either physical or logical) is reached,
-   otherwise the length of the string read (including the null).  */
-
-static int
-read_string ()
-{
-  static boolean eof = false;
-  int len;
-  char *p = linebuf;
-  /* Including the NUL, the args must not grow past this point.  */
-  char *endbuf = linebuf + arg_max - initial_argv_chars - 1;
-
-  if (eof)
-    return -1;
-  while (1)
-    {
-      int c = getc (stdin);
-      if (c == EOF)
-	{
-	  eof = true;
-	  if (p == linebuf)
-	    return -1;
-	  *p++ = '\0';
-	  len = p - linebuf;
-	  if (!replace_pat)
-	    push_arg (linebuf, len);
-	  return len;
-	}
-      if (c == '\0')
-	{
-	  lineno++;		/* For -l.  */
-	  *p++ = '\0';
-	  len = p - linebuf;
-	  if (!replace_pat)
-	    push_arg (linebuf, len);
-	  return len;
-	}
-      if (p >= endbuf)
-	fatalError ("argument line too long");
-      *p++ = c;
-    }
-}
-
-/* Replace all instances of `replace_pat' in ARG with `linebuf',
-   and add the resulting string to the list of arguments for the command
-   to execute.
-   ARGLEN is the length of ARG, not including the null.
-   LBLEN is the length of `linebuf', not including the null.
-
-   COMPAT: insertions on the SYSV version are limited to 255 chars per line,
-   and a max of 5 occurences of replace_pat in the initial-arguments.
-   Those restrictions do not exist here.  */
-
-static void
-do_insert (arg, arglen, lblen)
-     char *arg;
-     size_t arglen;
-     size_t lblen;
-{
-  /* Temporary copy of each arg with the replace pattern replaced by the
-     real arg.  */
-  static char *insertbuf;
-  char *p;
-  int bytes_left = arg_max - 1;	/* Bytes left on the command line.  */
-
-  if (!insertbuf)
-    insertbuf = (char *) xmalloc (arg_max + 1);
-  p = insertbuf;
-
-  do
-    {
-      size_t len;		/* Length in ARG before `replace_pat'.  */
-      char *s = strstr (arg, replace_pat);
-      if (s)
-	len = s - arg;
-      else
-	len = arglen;
-      bytes_left -= len;
-      if (bytes_left <= 0)
-	break;
-
-      strncpy (p, arg, len);
-      p += len;
-      arg += len;
-      arglen -= len;
-
-      if (s)
-	{
-	  bytes_left -= lblen;
-	  if (bytes_left <= 0)
-	    break;
-	  strcpy (p, linebuf);
-	  arg += rplen;
-	  arglen -= rplen;
-	  p += lblen;
-	}
-    }
-  while (*arg);
-  if (*arg)
-    fatalError ("command too long");
-  *p++ = '\0';
-  push_arg (insertbuf, p - insertbuf);
-}
-
-/* Add ARG to the end of the list of arguments `cmd_argv' to pass
-   to the command.
-   LEN is the length of ARG, including the terminating null.
-   If this brings the list up to its maximum size, execute the command.  */
-
-static void
-push_arg (arg, len)
-     char *arg;
-     size_t len;
-{
-  if (arg)
-    {
-      if (cmd_argv_chars + len > arg_max)
-	{
-	  if (initial_args || cmd_argc == initial_argc)
-	    fatalError ("can not fit single argument within argument list size limit");
-	  if (replace_pat
-	      || (exit_if_size_exceeded &&
-		  (lines_per_exec || args_per_exec)))
-	    fatalError ("argument list too long");
-	  do_exec ();
-	}
-      if (!initial_args && args_per_exec &&
-	  cmd_argc - initial_argc == args_per_exec)
-	do_exec ();
-    }
-
-  if (cmd_argc >= cmd_argv_alloc)
-    {
-      if (!cmd_argv)
-	{
-	  cmd_argv_alloc = 64;
-	  cmd_argv = (char **) xmalloc (sizeof (char *) * cmd_argv_alloc);
-	}
-      else
-	{
-	  cmd_argv_alloc *= 2;
-	  cmd_argv = (char **) xrealloc (cmd_argv,
-					 sizeof (char *) * cmd_argv_alloc);
-	}
-    }
-
-  if (!arg)
-    cmd_argv[cmd_argc++] = NULL;
-  else
-    {
-      cmd_argv[cmd_argc++] = argbuf + cmd_argv_chars;
-      strcpy (argbuf + cmd_argv_chars, arg);
-      cmd_argv_chars += len;
-    }
-}
-
-/* Print the arguments of the command to execute.
-   If ASK is nonzero, prompt the user for a response, and
-   if the user responds affirmatively, return true;
-   otherwise, return false.  */
-
-static boolean
-print_args (ask)
-     boolean ask;
-{
-  int i;
-
-  for (i = 0; i < cmd_argc - 1; i++)
-    fprintf (stderr, "%s ", cmd_argv[i]);
-  if (ask)
-    {
-      static FILE *tty_stream;
-      int c, savec;
-
-      if (!tty_stream)
-	{
-	  tty_stream = fopen ("/dev/tty", "r");
-	  if (!tty_stream)
-	    fatalError (" Could not open /dev/tty");
-	}
-      fputs ("?...", stderr);
-      fflush (stderr);
-      c = savec = getc (tty_stream);
-      while (c != EOF && c != '\n')
-	c = getc (tty_stream);
-      if (savec == 'y' || savec == 'Y')
-	return true;
-    }
-  else
-    putc ('\n', stderr);
-
-  return false;
-}
-
-/* Execute the command that has been built in `cmd_argv'.  This may involve
-   waiting for processes that were previously executed.  */
-
-static void
-do_exec ()
-{
-  pid_t child;
-
-  push_arg ((char *) NULL, 0);	/* Null terminate the arg list.  */
-  if (!query_before_executing || print_args (true))
-    {
-      if (proc_max && procs_executing >= proc_max)
-	wait_for_proc (false);
-      if (!query_before_executing && print_command)
-	print_args (false);
-      /* If we run out of processes, wait for a child to return and
-         try again.  */
-      while ((child = fork ()) < 0 && errno == EAGAIN && procs_executing)
-	wait_for_proc (false);
-      switch (child)
-	{
-	case -1:
-	  fatalError ("cannot fork");
-
-	case 0:		/* Child.  */
-	  execvp (cmd_argv[0], cmd_argv);
-	  errorMsg ("failed to exec '%s'", cmd_argv[0]);
-	  _exit (errno == ENOENT ? 127 : 126);
-	}
-      add_proc (child);
-    }
-
-  cmd_argc = initial_argc;
-  cmd_argv_chars = initial_argv_chars;
-}
-
-/* Add the process with id PID to the list of processes that have
-   been executed.  */
-
-static void
-add_proc (pid)
-     pid_t pid;
-{
-  int i;
-
-  /* Find an empty slot.  */
-  for (i = 0; i < pids_alloc && pids[i]; i++)
-    ;
-  if (i == pids_alloc)
-    {
-      if (pids_alloc == 0)
-	{
-	  pids_alloc = proc_max ? proc_max : 64;
-	  pids = (pid_t *) xmalloc (sizeof (pid_t) * pids_alloc);
-	}
-      else
-	{
-	  pids_alloc *= 2;
-	  pids = (pid_t *) xrealloc (pids,
-				     sizeof (pid_t) * pids_alloc);
-	}
-      memset (&pids[i], '\0', sizeof (pid_t) * (pids_alloc - i));
-    }
-  pids[i] = pid;
-  procs_executing++;
-  procs_executed++;
-}
-
-/* If ALL is true, wait for all child processes to finish;
-   otherwise, wait for one child process to finish.
-   Remove the processes that finish from the list of executing processes.  */
-
-static void
-wait_for_proc (all)
-     boolean all;
-{
-  while (procs_executing)
-    {
-      int i, status;
-
-      do
-	{
-	  pid_t pid;
-
-	  pid = wait (&status);
-	  if (pid < 0)
-	    fatalError ("error waiting for child process");
-
-	  /* Find the entry in `pids' for the child process
-	     that exited.  */
-	  for (i = 0; i < pids_alloc && pid != pids[i]; i++)
-	    ;
-	}
-      while (i == pids_alloc);	/* A child died that we didn't start? */
-
-      /* Remove the child from the list.  */
-      pids[i] = 0;
-      procs_executing--;
-
-      if (WEXITSTATUS (status) == 126 || WEXITSTATUS (status) == 127)
-	exit (WEXITSTATUS (status));	/* Can't find or run the command.  */
-      if (WEXITSTATUS (status) == 255)
-	fatalError ( "%s: exited with status 255; aborting", cmd_argv[0]);
-      if (WIFSTOPPED (status))
-	fatalError ( "%s: stopped by signal %d", cmd_argv[0], WSTOPSIG (status));
-      if (WIFSIGNALED (status))
-	fatalError ("%s: terminated by signal %d", cmd_argv[0], WTERMSIG (status));
-      if (WEXITSTATUS (status) != 0)
-	child_error = 123;
-
-      if (!all)
-	break;
-    }
-}
-
-/* Return the value of the number represented in STR.
-   OPTION is the command line option to which STR is the argument.
-   If the value does not fall within the boundaries MIN and MAX,
-   Print an error message mentioning OPTION and exit.  */
-
-static long
-parse_num (str, option, min, max)
-     char *str;
-     int option;
-     long min;
-     long max;
-{
-  char *eptr;
-  long val;
-
-  val = strtol (str, &eptr, 10);
-  if (eptr == str || *eptr)
-    {
-      fprintf (stderr, "%s: invalid number for -%c option\n",
-	       program_name, option);
-      usage (xargs_usage);
-    }
-  else if (val < min)
-    {
-      fprintf (stderr, "%s: value for -%c option must be >= %ld\n",
-	       program_name, option, min);
-      usage (xargs_usage);
-    }
-  else if (max >= 0 && val > max)
-    {
-      fprintf (stderr, "%s: value for -%c option must be < %ld\n",
-	       program_name, option, max);
-      usage (xargs_usage);
-    }
-  return val;
-}
-
-/* Return how much of ARG_MAX is used by the environment.  */
-
-static long
-env_size (envp)
-     char **envp;
-{
-  long len = 0;
-
-  while (*envp)
-    len += strlen (*envp++) + 1;
-
-  return len;
-}
-