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.
+Copyright (C) 1987-2013 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 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 3 of the License, 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.
+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.
+You should have received a copy of the GNU General Public License
+along with Bash. If not, see <http://www.gnu.org/licenses/>.
$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.
+$SHORT_DOC wait [-n] [id ...]
+Wait for job completion and return exit status.
+
+Waits for each process identified by an ID, which may be a process ID or a
+job specification, and reports its termination status. If ID is not
+given, waits for all currently active child processes, and the return
+status is zero. If ID is a a job specification, waits for all processes
+in that job's pipeline.
+
+If the -n option is supplied, waits for the next job to terminate and
+returns its exit status.
+
+Exit Status:
+Returns the status of the last ID; fails if ID is invalid or an invalid
+option is given.
$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.
+$SHORT_DOC wait [pid ...]
+Wait for process completion and return exit status.
+
+Waits for each process specified by a PID and reports its termination status.
+If PID is not given, waits for all currently active child processes,
+and the return status is zero. PID must be a process ID.
+
+Exit Status:
+Returns the status of the last PID; fails if PID is invalid or an invalid
+option is given.
$END
#include <config.h>
# include <unistd.h>
#endif
+#include <chartypes.h>
+
#include "../bashansi.h"
#include "../shell.h"
#include "common.h"
#include "bashgetopt.h"
-extern int interrupt_immediately;
+extern int wait_signal_received;
+
+procenv_t wait_intr_buf;
/* 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. */
-#define WAIT_RETURN(s) do { run_unwind_frame ("wait_builtin"); return (s); } while (0)
+#define WAIT_RETURN(s) \
+ do \
+ { \
+ interrupt_immediately = old_interrupt_immediately;\
+ wait_signal_received = 0; \
+ return (s);\
+ } \
+ while (0)
int
wait_builtin (list)
WORD_LIST *list;
{
- int status;
+ int status, code, opt, nflag;
+ volatile int old_interrupt_immediately;
- if (no_options (list))
- return (EX_USAGE);
- if (list != loptend)
- list = loptend;
+ USE_VAR(list);
+
+ nflag = 0;
+ reset_internal_getopt ();
+ while ((opt = internal_getopt (list, "n")) != -1)
+ {
+ switch (opt)
+ {
+#if defined (JOB_CONTROL)
+ case 'n':
+ nflag = 1;
+ break;
+#endif
+ default:
+ builtin_usage ();
+ return (EX_USAGE);
+ }
+ }
+ list = loptend;
- begin_unwind_frame ("wait_builtin");
- unwind_protect_int (interrupt_immediately);
+ old_interrupt_immediately = interrupt_immediately;
+#if 0
interrupt_immediately++;
+#endif
+
+ /* POSIX.2 says: When the shell is waiting (by means of the wait utility)
+ for asynchronous commands to complete, the reception of a signal for
+ which a trap has been set shall cause the wait utility to return
+ immediately with an exit status greater than 128, after which the trap
+ associated with the signal shall be taken.
+
+ We handle SIGINT here; it's the only one that needs to be treated
+ specially (I think), since it's handled specially in {no,}jobs.c. */
+ code = setjmp (wait_intr_buf);
+ if (code)
+ {
+ status = 128 + wait_signal_received;
+ WAIT_RETURN (status);
+ }
/* We support jobs or pids.
wait <pid-or-job> [pid-or-job ...] */
+#if defined (JOB_CONTROL)
+ if (nflag)
+ {
+ status = wait_for_any_job ();
+ if (status < 0)
+ status = 127;
+ WAIT_RETURN (status);
+ }
+#endif
+
/* But wait without any arguments means to wait for all of the shell's
currently active background processes. */
if (list == 0)
{
pid_t pid;
char *w;
+ intmax_t pid_value;
w = list->word->word;
- if (digit (*w))
+ if (DIGIT (*w))
{
- if (all_digits (w + 1))
+ if (legal_number (w, &pid_value) && pid_value == (pid_t)pid_value)
{
- pid = (pid_t)atoi (w);
+ pid = (pid_t)pid_value;
status = wait_for_single_pid (pid);
}
else
{
- builtin_error ("`%s' is not a pid or valid job spec", w);
+ sh_badpid (w);
WAIT_RETURN (EXECUTION_FAILURE);
}
}
#if defined (JOB_CONTROL)
- else if (job_control && *w)
+ else if (*w && *w == '%')
/* Must be a job spec. Check it out. */
{
int job;
BLOCK_CHILD (set, oset);
job = get_job_spec (list);
- if (job < 0 || job >= job_slots || !jobs[job])
+ if (INVALID_JOB (job))
{
if (job != DUP_JOB)
- builtin_error ("%s: no such job", list->word->word);
+ sh_badjob (list->word->word);
UNBLOCK_CHILD (oset);
status = 127; /* As per Posix.2, section 4.70.2 */
list = list->next;
UNBLOCK_CHILD (oset);
status = wait_for_job (job);
}
- else if (job_control == 0 && *w == '%')
- {
- /* can't use jobspecs as arguments if job control is not active. */
- builtin_error ("job control not enabled");
- status = EXECUTION_FAILURE;
- }
#endif /* JOB_CONTROL */
else
{
- builtin_error ("`%s' is not a pid or valid job spec", w);
+ sh_badpid (w);
status = EXECUTION_FAILURE;
}
list = list->next;
projects / platform / upstream / bash.git / blobdiff