~ubuntu-branches/ubuntu/raring/findutils/raring

/* xargs -- build and execute command lines from standard input

 

   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

*/

 

/* Written by Mike Rendell <michael@cs.mun.ca>

        Dmitry V. Levin

*/

 

#include <getopt.h>

#include <fcntl.h>

 

#include <assert.h>

#endif

 

#include <string.h>

#include <memory.h>

#endif

#else

#define SIGCHLD SIGCLD

#endif

 

#include "wait.h"

 

 

#ifdef STDC_HEADERS

#include <stdlib.h>

static struct buildcmd_state bc_state;

static struct buildcmd_control bc_ctl;

 

 

/* If nonzero, when this string is read on stdin it is treated as

   end of file.

 

/* If nonzero, the maximum number of child processes that can be running

   at once.  */

 

 

/* The number of elements in `pids'.  */

 

/* List of child processes currently executing.  */

static pid_t *pids = NULL;

 

/* The number of allocated elements in `pids'. */

 

/* Exit status; nonzero if any child process exited with a

   status of 1-125.  */

static int xargs_do_exec (const struct buildcmd_control *cl, struct buildcmd_state *state);

static void exec_if_possible PARAMS ((void));

static void add_proc PARAMS ((pid_t pid));

static void wait_for_proc_all PARAMS ((void));

static long parse_num PARAMS ((char *str, int option, long min, long max, int fatal));

static void usage PARAMS ((FILE * stream));

  unsigned long val;

  char *endp;

 

  

  if ('x' == s[1])

    {

    }

  else

    {

      error(1, 0,

            _("Invalid escape sequence %s in input delimiter specification."),

            s);

          error(1, 0,

                _("Invalid input delimiter specification %s: the delimiter must be either a single character or an escape sequence starting with \\."),

                s);

        }

    }

}

  int (*read_args) PARAMS ((void)) = read_line;

  void (*act_on_init_result)(void) = noop;

  enum BC_INIT_STATUS bcstatus;

  program_name = argv[0];

  original_exit_value = 0;

  

  atexit (close_stdin);

  atexit (wait_for_proc_all);

 

  /* The bc_init_controlinfo call may have determined that the 

   * environment is too big.  In that case, we will fail with 

   * an error message after processing the command-line options,

    {

      act_on_init_result = fail_due_to_env_size;

    }

  else

    {

      /* IEEE Std 1003.1, 2003 specifies that the combined argument and 

       * environment list shall not exceed {ARG_MAX}-2048 bytes.  It also 

       * specifies that it shall be at least LINE_MAX.

       */

#endif

#ifdef LINE_MAX

#endif

      

      bc_ctl.exec_callback = xargs_do_exec;

            if (arg_size > bc_ctl.posix_arg_size_max)

              {

                error (0, 0,

                         "using %ld instead"),

                       arg_size, bc_ctl.posix_arg_size_max);

                arg_size = bc_ctl.posix_arg_size_max;

          break;

 

        case 'P':

          break;

 

        case 'a':

          break;

 

        case 'v':

          return 0;

 

        default:

   * the environment is too large. 

   */

  act_on_init_result();

 

  if (0 == strcmp (input_file, "-"))

    {

      if (NULL == input_stream)

        {

          error (1, errno,

        }

    }

 

   * special C99 ways to print such values.  Unfortunately this

   * program tries to work on both C89 and C99 systems.

   */

# if SIZE_MAX > ULONG_MAX

# error "I'm not sure how to print size_t values on your system"

# endif

  /* Without SIZE_MAX (i.e. limits.h) this is probably 

   * close to the best we can do.

   */

#endif

  if (show_limits)

    {

      fprintf(stderr,

              _("Your environment variables take up %lu bytes\n"),

              (unsigned long)bc_size_of_environment());

      fprintf(stderr,

              (unsigned long)bc_ctl.posix_arg_size_max);

      fprintf(stderr,

              _("Maximum length of command we could actually use: %ld\n"),

              (unsigned long)(bc_ctl.posix_arg_size_max -

                              bc_size_of_environment()));

      fprintf(stderr,

              _("Size of command buffer we are actually using: %lu\n"),

              (unsigned long)bc_ctl.arg_max);

      if (isatty(STDIN_FILENO))

        {

          fprintf(stderr,

        }

    }

  

 

  /* Make sure to listen for the kids.  */

  signal (SIGCHLD, SIG_DFL);

      /* SYSV xargs seems to do at least one exec, even if the

         input is empty.  */

      if (bc_state.cmd_argc != bc_ctl.initial_argc

        xargs_do_exec (&bc_ctl, &bc_state);

 

    }

    {

      int i;

      size_t len;

 

      for (i = optind; i < argc; i++)

        arglen[i] = strlen(argv[i]);

static int

read_line (void)

{

  static boolean eof = false;

  /* Start out in mode SPACE to always strip leading spaces (even with -i).  */

  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 + bc_ctl.arg_max - bc_state.cmd_initial_argv_chars - 1;

  if (eof)

    return -1;

  while (1)

    {

      prevc = c;

      c = getc (input_stream);

      if (c == EOF)

        {

          /* COMPAT: SYSV seems to ignore stuff on a line that

                lineno++;       /* For -l.  */

              if (p == linebuf)

                {

                }

              *p++ = '\0';

              len = p - linebuf;

                             initial_args);

              return len;

            }

            {

              *p++ = '\0';

              len = p - linebuf;

          if (c == quotc)

            {

              state = NORM;

              continue;

            }

          break;

          state = NORM;

          break;

        }

#if 1

      if (p >= endbuf)

        {

           * stdin is almost as good as executing it

           * with its stdin attached to /dev/null.

           */

        }

    }

}

{

  pid_t child;

 

  bc_push_arg (&bc_ctl, &bc_state,

               (char *) NULL, 0,

               NULL, 0,

  

  if (!query_before_executing || print_args (true))

    {

      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)

      switch (child)

        {

        case -1:

static void

add_proc (pid_t pid)

{

 

  /* Find an empty slot.  */

  for (i = 0; i < pids_alloc && pids[i]; i++)

    ;

  if (i == pids_alloc)

    {

    }

  pids[i] = pid;

  procs_executing++;

}

 

/* If ALL is true, wait for all child processes to finish;

   Remove the processes that finish from the list of executing processes.  */

 

static void

{

  while (procs_executing)

    {

 

      do

        {

          /* Find the entry in `pids' for the child process

             that exited.  */

        }

 

      /* 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.  */

        error (125, 0, _("%s: terminated by signal %d"), bc_state.cmd_argv[0], WTERMSIG (status));

      if (WEXITSTATUS (status) != 0)

        child_error = 123;

    }

}

 

    return;

 

  waiting = true;

  waiting = false;

  

  if (original_exit_value != child_error)

  return val;

}

 

static void

usage (FILE *stream)

{