This file is wait.def, from which is created wait.c.
It implements the builtin "wait" in Bash.

Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.

This file is part of GNU Bash, the Bourne Again SHell.

Bash 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 1, or (at your option) any later
version.

Bash 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 Bash; see the file COPYING.  If not, write to the Free Software
Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.


$BUILTIN wait
$FUNCTION wait_builtin
$DEPENDS_ON JOB_CONTROL
$PRODUCES wait.c
$SHORT_DOC wait [n]
Wait for the specified process and report its termination status.  If
N is not given, all currently active child processes are waited for,
and the return code is zero.  N may be a process ID or a job
specification; if a job spec is given, all processes in the job's
pipeline are waited for.
$END

$BUILTIN wait
$FUNCTION wait_builtin
$DEPENDS_ON !JOB_CONTROL
$SHORT_DOC wait [n]
Wait for the specified process and report its termination status.  If
N is not given, all currently active child processes are waited for,
and the return code is zero.  N is a process ID; if it is not given,
all child processes of the shell are waited for.
$END

#include <sys/types.h>
#include <signal.h>
#include "../shell.h"
#include "../jobs.h"

extern int interrupt_immediately;

/* Wait for the pid in LIST to stop or die.  If no arguments are given, then
   wait for all of the active background processes of the shell and return
   0.  If a list of pids or job specs are given, return the exit status of
   the last one waited for. */
wait_builtin (list)
     WORD_LIST *list;
{
  int status = EXECUTION_SUCCESS;

  begin_unwind_frame ("wait_builtin");
  unwind_protect_int (interrupt_immediately);
  interrupt_immediately++;

  /* We support jobs or pids.
     wait <pid-or-job> [pid-or-job ...] */

  /* But wait without any arguments means to wait for all of the shell's
     currently active background processes. */
  if (!list)
    {
      wait_for_background_pids ();
      status = EXECUTION_SUCCESS;
      goto return_status;
    }

  while (list)
    {
      pid_t pid;
      char *w;

      w = list->word->word;
      if (digit (*w))
	{
	  if (all_digits (w + 1))
	    {
	      pid = (pid_t)atoi (w);
	      status = wait_for_single_pid (pid);
	    }
	  else
	    {
	      builtin_error ("`%s' is not a pid or legal job spec", w);
	      status = EXECUTION_FAILURE;
	      goto return_status;
	    }
	}
#if defined (JOB_CONTROL)
      else if (job_control && *w)
	/* Must be a job spec.  Check it out. */
	{
	  int job;
	  sigset_t set, oset;

	  BLOCK_CHILD (set, oset);
	  job = get_job_spec (list);

	  if (job < 0 || job >= job_slots || !jobs[job])
	    {
	      if (job != DUP_JOB)
		builtin_error ("No such job %s", list->word->word);
	      UNBLOCK_CHILD (oset);
	      status = 127;	/* As per Posix.2, section 4.70.2 */
	      list = list->next;
	      continue;
	    }

	  /* Job spec used.  Wait for the last pid in the pipeline. */
	  UNBLOCK_CHILD (oset);
	  status = wait_for_job (job);
	}
#endif /* JOB_CONTROL */
      else
	{
	  builtin_error ("`%s' is not a pid or legal job spec", w);
	  status = EXECUTION_FAILURE;
	}
      list = list->next;
    }
 return_status:
  run_unwind_frame ("wait_builtin");
  return (status);
}
