/* execute_cmd.c -- Execute a COMMAND structure. */
-/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2013 Free Software Foundation, Inc.
This file is part of GNU Bash, the Bourne Again SHell.
#include "filecntl.h"
#include "posixstat.h"
#include <signal.h>
-#ifndef _MINIX
+#if defined (HAVE_SYS_PARAM_H)
# include <sys/param.h>
#endif
extern int errno;
#endif
+#define NEED_FPURGE_DECL
+
#include "bashansi.h"
#include "bashintl.h"
# include "bashhist.h"
#endif
+extern int dollar_dollar_pid;
extern int posixly_correct;
extern int expand_aliases;
extern int autocd;
extern int breaking, continuing, loop_level;
-extern int parse_and_execute_level, running_trap;
+extern int parse_and_execute_level, running_trap, sourcelevel;
extern int command_string_index, line_number;
extern int dot_found_in_search;
extern int already_making_children;
extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
extern char **subshell_argv, **subshell_envp;
extern int subshell_argc;
+extern time_t shell_start_time;
#if 0
extern char *glob_argv_flags;
#endif
+extern int job_control; /* XXX */
+
extern int close __P((int));
/* Static functions defined and used in this file. */
static int execute_for_command __P((FOR_COM *));
#if defined (SELECT_COMMAND)
+static int displen __P((const char *));
static int print_index_and_element __P((int, int, WORD_LIST *));
static void indent __P((int, int));
static void print_select_list __P((WORD_LIST *, int, int, int));
int, int, int,
struct fd_bitmap *,
int));
-static void execute_disk_command __P((WORD_LIST *, REDIRECT *, char *,
+static int execute_disk_command __P((WORD_LIST *, REDIRECT *, char *,
int, int, int, struct fd_bitmap *, int));
static char *getinterp __P((char *, int, int *));
static int execute_connection __P((COMMAND *, int, int, int, struct fd_bitmap *));
-static int execute_intern_function __P((WORD_DESC *, COMMAND *));
+static int execute_intern_function __P((WORD_DESC *, FUNCTION_DEF *));
/* Set to 1 if fd 0 was the subject of redirection to a subshell. Global
so that reader_loop can set it to zero before executing a command. */
was terminated by a signal, and, if so, which one. */
int last_command_exit_signal;
+/* Are we currently ignoring the -e option for the duration of a builtin's
+ execution? */
+int builtin_ignoring_errexit = 0;
+
/* The list of redirections to perform which will undo the redirections
that I made in the shell. */
REDIRECT *redirection_undo_list = (REDIRECT *)NULL;
/* If non-zero, matches in case and [[ ... ]] are case-insensitive */
int match_ignore_case = 0;
+int executing_command_builtin = 0;
+
struct stat SB; /* used for debugging */
static int special_builtin_failed;
report the correct line number. Kind of a hack. */
static int showing_function_line;
-static int line_number_for_err_trap;
+/* $LINENO ($BASH_LINENO) for use by an ERR trap. Global so parse_and_execute
+ can save and restore it. */
+int line_number_for_err_trap;
+
+/* A sort of function nesting level counter */
+int funcnest = 0;
+int funcnest_max = 0; /* bash-4.2 */
+
+int lastpipe_opt = 0;
struct fd_bitmap *current_fds_to_close = (struct fd_bitmap *)NULL;
return currently_executing_command->value.Cond->line;
#endif
#if defined (DPAREN_ARITHMETIC)
- else if (currently_executing_command->type == cm_arith)
+ if (currently_executing_command->type == cm_arith)
return currently_executing_command->value.Arith->line;
#endif
#if defined (ARITH_FOR_COMMAND)
- else if (currently_executing_command->type == cm_arith_for)
+ if (currently_executing_command->type == cm_arith_for)
return currently_executing_command->value.ArithFor->line;
#endif
#define DESCRIBE_PID(pid) do { if (interactive) describe_pid (pid); } while (0)
-/* Execute the command passed in COMMAND, perhaps doing it asynchrounously.
+/* Execute the command passed in COMMAND, perhaps doing it asynchronously.
COMMAND is exactly what read_command () places into GLOBAL_COMMAND.
ASYNCHROUNOUS, if non-zero, says to do this command in the background.
PIPE_IN and PIPE_OUT are file descriptors saying where input comes
{
int exec_result, user_subshell, invert, ignore_return, was_error_trap;
REDIRECT *my_undo_list, *exec_undo_list;
+ char *tcmd;
volatile int last_pid;
volatile int save_line_number;
+#if defined (PROCESS_SUBSTITUTION)
+ volatile int ofifo, nfifo, osize, saved_fifo;
+ volatile char *ofifo_list;
+#endif
-#if 0
- if (command == 0 || breaking || continuing || read_but_dont_execute)
- return (EXECUTION_SUCCESS);
-#else
if (breaking || continuing)
return (last_command_exit_value);
if (command == 0 || read_but_dont_execute)
return (EXECUTION_SUCCESS);
-#endif
QUIT;
run_pending_traps ();
(pipe_out != NO_PIPE || pipe_in != NO_PIPE || asynchronous)))
{
pid_t paren_pid;
+ int s;
/* Fork a subshell, turn off the subshell bit, turn off job
control and call execute_command () on the command again. */
- paren_pid = make_child (savestring (make_command_string (command)),
- asynchronous);
+ line_number_for_err_trap = line_number;
+ tcmd = make_command_string (command);
+ paren_pid = make_child (savestring (tcmd), asynchronous);
+
+ if (user_subshell && signal_is_trapped (ERROR_TRAP) &&
+ signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
+ {
+ FREE (the_printed_command_except_trap);
+ the_printed_command_except_trap = savestring (the_printed_command);
+ }
+
if (paren_pid == 0)
- exit (execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close));
- /* NOTREACHED */
+ {
+ /* We want to run the exit trap for forced {} subshells, and we
+ want to note this before execute_in_subshell modifies the
+ COMMAND struct. Need to keep in mind that execute_in_subshell
+ runs the exit trap for () subshells itself. */
+ /* This handles { command; } & */
+ s = user_subshell == 0 && command->type == cm_group && pipe_in == NO_PIPE && pipe_out == NO_PIPE && asynchronous;
+ /* run exit trap for : | { ...; } and { ...; } | : */
+ /* run exit trap for : | ( ...; ) and ( ...; ) | : */
+ s += user_subshell == 0 && command->type == cm_group && (pipe_in != NO_PIPE || pipe_out != NO_PIPE) && asynchronous == 0;
+
+ last_command_exit_value = execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close);
+ if (s)
+ subshell_exit (last_command_exit_value);
+ else
+ exit (last_command_exit_value);
+ /* NOTREACHED */
+ }
else
{
close_pipes (pipe_in, pipe_out);
#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
- unlink_fifo_list ();
+ if (variable_context == 0) /* wait until shell function completes */
+ unlink_fifo_list ();
#endif
/* If we are part of a pipeline, and not the end of the pipeline,
then we should simply return and let the last command in the
invert = (command->flags & CMD_INVERT_RETURN) != 0;
ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
- last_command_exit_value = wait_for (paren_pid);
+ exec_result = wait_for (paren_pid);
/* If we have to, invert the return value. */
if (invert)
- exec_result = ((last_command_exit_value == EXECUTION_SUCCESS)
+ exec_result = ((exec_result == EXECUTION_SUCCESS)
? EXECUTION_FAILURE
: EXECUTION_SUCCESS);
- else
- exec_result = last_command_exit_value;
-
+ last_command_exit_value = exec_result;
if (user_subshell && was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
{
- last_command_exit_value = exec_result;
+ save_line_number = line_number;
+ line_number = line_number_for_err_trap;
run_error_trap ();
+ line_number = save_line_number;
}
if (user_subshell && ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
{
- last_command_exit_value = exec_result;
run_pending_traps ();
jump_to_top_level (ERREXIT);
}
- return (last_command_exit_value = exec_result);
+ return (last_command_exit_value);
}
else
{
run_pending_traps ();
+ /* Posix 2013 2.9.3.1: "the exit status of an asynchronous list
+ shall be zero." */
+ last_command_exit_value = 0;
return (EXECUTION_SUCCESS);
}
}
if (shell_control_structure (command->type) && command->redirects)
stdin_redir = stdin_redirects (command->redirects);
+#if defined (PROCESS_SUBSTITUTION)
+ if (variable_context != 0)
+ {
+ ofifo = num_fifos ();
+ ofifo_list = copy_fifo_list ((int *)&osize);
+ saved_fifo = 1;
+ }
+ else
+ saved_fifo = 0;
+#endif
+
/* Handle WHILE FOR CASE etc. with redirections. (Also '&' input
redirection.) */
if (do_redirections (command->redirects, RX_ACTIVE|RX_UNDOABLE) != 0)
cleanup_redirects (redirection_undo_list);
redirection_undo_list = (REDIRECT *)NULL;
dispose_exec_redirects ();
+#if defined (PROCESS_SUBSTITUTION)
+ if (saved_fifo)
+ free ((void *)ofifo_list);
+#endif
return (last_command_exit_value = EXECUTION_FAILURE);
}
if (redirection_undo_list)
{
+ /* XXX - why copy here? */
my_undo_list = (REDIRECT *)copy_redirects (redirection_undo_list);
dispose_redirects (redirection_undo_list);
redirection_undo_list = (REDIRECT *)NULL;
if (exec_redirection_undo_list)
{
+ /* XXX - why copy here? */
exec_undo_list = (REDIRECT *)copy_redirects (exec_redirection_undo_list);
dispose_redirects (exec_redirection_undo_list);
exec_redirection_undo_list = (REDIRECT *)NULL;
the child. */
/* XXX - this is something to watch out for if there are problems
- when the shell is compiled without job control. */
- if (already_making_children && pipe_out == NO_PIPE &&
- last_made_pid != last_pid)
+ when the shell is compiled without job control. Don't worry about
+ whether or not last_made_pid == last_pid; already_making_children
+ tells us whether or not there are unwaited-for children to wait
+ for and reap. */
+ if (already_making_children && pipe_out == NO_PIPE)
{
stop_pipeline (asynchronous, (COMMAND *)NULL);
if (was_error_trap && ignore_return == 0 && invert == 0 && pipe_in == NO_PIPE && pipe_out == NO_PIPE && exec_result != EXECUTION_SUCCESS)
{
last_command_exit_value = exec_result;
+ line_number = line_number_for_err_trap;
run_error_trap ();
+ line_number = save_line_number;
}
if (ignore_return == 0 && invert == 0 &&
#if defined (DPAREN_ARITHMETIC)
case cm_arith:
+ was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
if (ignore_return)
command->value.Arith->flags |= CMD_IGNORE_RETURN;
+ line_number_for_err_trap = save_line_number = line_number;
exec_result = execute_arith_command (command->value.Arith);
+ line_number = save_line_number;
+
+ if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
+ {
+ last_command_exit_value = exec_result;
+ save_line_number = line_number;
+ line_number = line_number_for_err_trap;
+ run_error_trap ();
+ line_number = save_line_number;
+ }
+
+ if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
+ {
+ last_command_exit_value = exec_result;
+ run_pending_traps ();
+ jump_to_top_level (ERREXIT);
+ }
+
break;
#endif
#if defined (COND_COMMAND)
case cm_cond:
+ was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
if (ignore_return)
command->value.Cond->flags |= CMD_IGNORE_RETURN;
- save_line_number = line_number;
+
+ line_number_for_err_trap = save_line_number = line_number;
exec_result = execute_cond_command (command->value.Cond);
line_number = save_line_number;
+
+ if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
+ {
+ last_command_exit_value = exec_result;
+ save_line_number = line_number;
+ line_number = line_number_for_err_trap;
+ run_error_trap ();
+ line_number = save_line_number;
+ }
+
+ if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
+ {
+ last_command_exit_value = exec_result;
+ run_pending_traps ();
+ jump_to_top_level (ERREXIT);
+ }
+
break;
#endif
case cm_function_def:
exec_result = execute_intern_function (command->value.Function_def->name,
- command->value.Function_def->command);
+ command->value.Function_def);
break;
default:
if (my_undo_list || exec_undo_list)
discard_unwind_frame ("loop_redirections");
+#if defined (PROCESS_SUBSTITUTION)
+ if (saved_fifo)
+ {
+ nfifo = num_fifos ();
+ if (nfifo > ofifo)
+ close_new_fifos ((char *)ofifo_list, osize);
+ free ((void *)ofifo_list);
+ }
+#endif
+
/* Invert the return value if we have to */
if (invert)
exec_result = (exec_result == EXECUTION_SUCCESS)
if (running_trap == 0)
#endif
currently_executing_command = (COMMAND *)NULL;
+
return (last_command_exit_value);
}
int asynchronous, pipe_in, pipe_out;
struct fd_bitmap *fds_to_close;
{
- int rv, posix_time, old_flags;
+ int rv, posix_time, old_flags, nullcmd;
time_t rs, us, ss;
int rsf, usf, ssf;
int cpu;
# endif
#endif
- posix_time = (command->flags & CMD_TIME_POSIX);
+ posix_time = command && (command->flags & CMD_TIME_POSIX);
+
+ nullcmd = (command == 0) || (command->type == cm_simple && command->value.Simple->words == 0 && command->value.Simple->redirects == 0);
+ if (posixly_correct && nullcmd)
+ {
+#if defined (HAVE_GETRUSAGE)
+ selfb.ru_utime.tv_sec = kidsb.ru_utime.tv_sec = selfb.ru_stime.tv_sec = kidsb.ru_stime.tv_sec = 0;
+ selfb.ru_utime.tv_usec = kidsb.ru_utime.tv_usec = selfb.ru_stime.tv_usec = kidsb.ru_stime.tv_usec = 0;
+ before.tv_sec = shell_start_time;
+ before.tv_usec = 0;
+#else
+ before.tms_utime = before.tms_stime = before.tms_cutime = before.tms_cstime = 0;
+ tbefore = shell_start_time;
+#endif
+ }
old_flags = command->flags;
command->flags &= ~(CMD_TIME_PIPELINE|CMD_TIME_POSIX);
if (posix_time)
time_format = POSIX_TIMEFORMAT;
else if ((time_format = get_string_value ("TIMEFORMAT")) == 0)
- time_format = BASH_TIMEFORMAT;
-
+ {
+ if (posixly_correct && nullcmd)
+ time_format = "user\t%2lU\nsys\t%2lS";
+ else
+ time_format = BASH_TIMEFORMAT;
+ }
if (time_format && *time_format)
print_formatted_time (stderr, time_format, rs, rsf, us, usf, ss, ssf, cpu);
{
int user_subshell, return_code, function_value, should_redir_stdin, invert;
int ois, user_coproc;
- COMMAND *tcom;
+ int result;
+ volatile COMMAND *tcom;
USE_VAR(user_subshell);
USE_VAR(user_coproc);
reset_terminating_signals (); /* in sig.c */
/* Cancel traps, in trap.c. */
- restore_original_signals ();
+ /* Reset the signal handlers in the child, but don't free the
+ trap strings. Set a flag noting that we have to free the
+ trap strings if we run trap to change a signal disposition. */
+ reset_signal_handlers ();
+ subshell_environment |= SUBSHELL_RESETTRAP;
/* Make sure restore_original_signals doesn't undo the work done by
make_child to ensure that asynchronous children are immune to SIGINT
if (user_subshell)
{
stdin_redir = stdin_redirects (command->redirects);
- restore_default_signal (0);
+ restore_default_signal (EXIT_TRAP);
}
/* If this is an asynchronous command (command &), we want to
invert = (tcom->flags & CMD_INVERT_RETURN) != 0;
tcom->flags &= ~CMD_INVERT_RETURN;
+ result = setjmp_nosigs (top_level);
+
/* If we're inside a function while executing this subshell, we
need to handle a possible `return'. */
function_value = 0;
if (return_catch_flag)
- function_value = setjmp (return_catch);
-
- if (function_value)
+ function_value = setjmp_nosigs (return_catch);
+
+ /* If we're going to exit the shell, we don't want to invert the return
+ status. */
+ if (result == EXITPROG)
+ invert = 0, return_code = last_command_exit_value;
+ else if (result)
+ return_code = EXECUTION_FAILURE;
+ else if (function_value)
return_code = return_catch_value;
else
- return_code = execute_command_internal (tcom, asynchronous, NO_PIPE, NO_PIPE, fds_to_close);
+ return_code = execute_command_internal ((COMMAND *)tcom, asynchronous, NO_PIPE, NO_PIPE, fds_to_close);
/* If we are asked to, invert the return value. */
if (invert)
struct cpelement *head;
struct cpelement *tail;
int ncoproc;
+ int lock;
}
cplist_t;
static struct cpelement *cpl_delete __P((pid_t));
static void cpl_reap __P((void));
static void cpl_flush __P((void));
+static void cpl_closeall __P((void));
static struct cpelement *cpl_search __P((pid_t));
-static struct cpelement *cpl_searchbyname __P((char *));
+static struct cpelement *cpl_searchbyname __P((const char *));
static void cpl_prune __P((void));
-Coproc sh_coproc = { 0, NO_PID, -1, -1, 0, 0 };
+static void coproc_free __P((struct coproc *));
+
+/* Will go away when there is fully-implemented support for multiple coprocs. */
+Coproc sh_coproc = { 0, NO_PID, -1, -1, 0, 0, 0, 0, 0 };
cplist_t coproc_list = {0, 0, 0};
static void
cpl_reap ()
{
- struct cpelement *prev, *p;
+ struct cpelement *p, *next, *nh, *nt;
- for (prev = p = coproc_list.head; p; prev = p, p = p->next)
- if (p->coproc->c_flags & COPROC_DEAD)
- {
- prev->next = p->next; /* remove from list */
-
- /* Housekeeping in the border cases. */
- if (p == coproc_list.head)
- coproc_list.head = coproc_list.head->next;
- else if (p == coproc_list.tail)
- coproc_list.tail = prev;
-
- coproc_list.ncoproc--;
- if (coproc_list.ncoproc == 0)
- coproc_list.head = coproc_list.tail = 0;
- else if (coproc_list.ncoproc == 1)
- coproc_list.tail = coproc_list.head; /* just to make sure */
+ /* Build a new list by removing dead coprocs and fix up the coproc_list
+ pointers when done. */
+ nh = nt = next = (struct cpelement *)0;
+ for (p = coproc_list.head; p; p = next)
+ {
+ next = p->next;
+ if (p->coproc->c_flags & COPROC_DEAD)
+ {
+ coproc_list.ncoproc--; /* keep running count, fix up pointers later */
#if defined (DEBUG)
- itrace("cpl_reap: deleting %d", p->coproc->c_pid);
+ itrace("cpl_reap: deleting %d", p->coproc->c_pid);
#endif
- coproc_dispose (p->coproc);
- cpe_dispose (p);
- }
+ coproc_dispose (p->coproc);
+ cpe_dispose (p);
+ }
+ else if (nh == 0)
+ nh = nt = p;
+ else
+ {
+ nt->next = p;
+ nt = nt->next;
+ }
+ }
+
+ if (coproc_list.ncoproc == 0)
+ coproc_list.head = coproc_list.tail = 0;
+ else
+ {
+ if (nt)
+ nt->next = 0;
+ coproc_list.head = nh;
+ coproc_list.tail = nt;
+ if (coproc_list.ncoproc == 1)
+ coproc_list.tail = coproc_list.head; /* just to make sure */
+ }
}
/* Clear out the list of saved statuses */
coproc_list.ncoproc = 0;
}
+static void
+cpl_closeall ()
+{
+ struct cpelement *cpe;
+
+ for (cpe = coproc_list.head; cpe; cpe = cpe->next)
+ coproc_close (cpe->coproc);
+}
+
+static void
+cpl_fdchk (fd)
+ int fd;
+{
+ struct cpelement *cpe;
+
+ for (cpe = coproc_list.head; cpe; cpe = cpe->next)
+ coproc_checkfd (cpe->coproc, fd);
+}
+
/* Search for PID in the list of coprocs; return the cpelement struct if
found. If not found, return NULL. */
static struct cpelement *
cpl_search (pid)
pid_t pid;
{
- struct cpelement *cp;
+ struct cpelement *cpe;
- for (cp = coproc_list.head ; cp; cp = cp->next)
- if (cp->coproc->c_pid == pid)
- return cp;
+ for (cpe = coproc_list.head ; cpe; cpe = cpe->next)
+ if (cpe->coproc->c_pid == pid)
+ return cpe;
return (struct cpelement *)NULL;
}
cpelement struct if found. If not found, return NULL. */
static struct cpelement *
cpl_searchbyname (name)
- char *name;
+ const char *name;
{
struct cpelement *cp;
getcoprocbypid (pid)
pid_t pid;
{
+#if MULTIPLE_COPROCS
+ struct cpelement *p;
+
+ p = cpl_search (pid);
+ return (p ? p->coproc : 0);
+#else
return (pid == sh_coproc.c_pid ? &sh_coproc : 0);
+#endif
}
struct coproc *
getcoprocbyname (name)
const char *name;
{
+#if MULTIPLE_COPROCS
+ struct cpelement *p;
+
+ p = cpl_searchbyname (name);
+ return (p ? p->coproc : 0);
+#else
return ((sh_coproc.c_name && STREQ (sh_coproc.c_name, name)) ? &sh_coproc : 0);
+#endif
}
void
cp->c_pid = NO_PID;
cp->c_rfd = cp->c_wfd = -1;
cp->c_rsave = cp->c_wsave = -1;
- cp->c_flags = cp->c_status = 0;
+ cp->c_flags = cp->c_status = cp->c_lock = 0;
}
struct coproc *
{
struct coproc *cp;
- cp = &sh_coproc; /* XXX */
+#if MULTIPLE_COPROCS
+ cp = (struct coproc *)xmalloc (sizeof (struct coproc));
+#else
+ cp = &sh_coproc;
+#endif
coproc_init (cp);
+ cp->c_lock = 2;
- cp->c_name = savestring (name);
cp->c_pid = pid;
-
+ cp->c_name = savestring (name);
+#if MULTIPLE_COPROCS
+ cpl_add (cp);
+#endif
+ cp->c_lock = 0;
return (cp);
}
+static void
+coproc_free (cp)
+ struct coproc *cp;
+{
+ free (cp);
+}
+
void
coproc_dispose (cp)
struct coproc *cp;
{
+ sigset_t set, oset;
+
if (cp == 0)
return;
+ BLOCK_SIGNAL (SIGCHLD, set, oset);
+ cp->c_lock = 3;
coproc_unsetvars (cp);
FREE (cp->c_name);
coproc_close (cp);
+#if MULTIPLE_COPROCS
+ coproc_free (cp);
+#else
coproc_init (cp);
+ cp->c_lock = 0;
+#endif
+ UNBLOCK_SIGNAL (oset);
}
-/* Placeholder for now. */
+/* Placeholder for now. Will require changes for multiple coprocs */
void
coproc_flush ()
{
+#if MULTIPLE_COPROCS
+ cpl_flush ();
+#else
coproc_dispose (&sh_coproc);
+#endif
}
void
void
coproc_closeall ()
{
- coproc_close (&sh_coproc);
+#if MULTIPLE_COPROCS
+ cpl_closeall ();
+#else
+ coproc_close (&sh_coproc); /* XXX - will require changes for multiple coprocs */
+#endif
}
void
coproc_reap ()
{
+#if MULTIPLE_COPROCS
+ cpl_reap ();
+#else
struct coproc *cp;
- cp = &sh_coproc;
+ cp = &sh_coproc; /* XXX - will require changes for multiple coprocs */
if (cp && (cp->c_flags & COPROC_DEAD))
coproc_dispose (cp);
+#endif
}
void
coproc_fdchk (fd)
int fd;
{
+#if MULTIPLE_COPROCS
+ cpl_fdchk (fd);
+#else
coproc_checkfd (&sh_coproc, fd);
+#endif
}
void
{
struct coproc *cp;
+#if MULTIPLE_COPROCS
+ struct cpelement *cpe;
+
+ cpe = cpl_delete (pid);
+ cp = cpe ? cpe->coproc : 0;
+#else
cp = getcoprocbypid (pid);
-#if 0
- if (cp)
- itrace("coproc_pidchk: pid %d has died", pid);
#endif
if (cp)
{
+ cp->c_lock = 4;
cp->c_status = status;
cp->c_flags |= COPROC_DEAD;
cp->c_flags &= ~COPROC_RUNNING;
-#if 0
- coproc_dispose (cp);
-#endif
+ /* Don't dispose the coproc or unset the COPROC_XXX variables because
+ this is executed in a signal handler context. Wait until coproc_reap
+ takes care of it. */
+ cp->c_lock = 0;
}
}
int pipe_in, pipe_out;
struct fd_bitmap *fds_to_close;
{
- int rpipe[2], wpipe[2];
+ int rpipe[2], wpipe[2], estat, invert;
pid_t coproc_pid;
Coproc *cp;
char *tcmd;
+ sigset_t set, oset;
- /* XXX -- will require changes to handle multiple coprocs */
+ /* XXX -- can be removed after changes to handle multiple coprocs */
+#if !MULTIPLE_COPROCS
if (sh_coproc.c_pid != NO_PID)
- {
-#if 0
- internal_error ("execute_coproc: coproc [%d:%s] already exists", sh_coproc.c_pid, sh_coproc.c_name);
- return (last_command_exit_value = EXECUTION_FAILURE);
-#else
- internal_warning ("execute_coproc: coproc [%d:%s] still exists", sh_coproc.c_pid, sh_coproc.c_name);
-#endif
- }
+ internal_warning ("execute_coproc: coproc [%d:%s] still exists", sh_coproc.c_pid, sh_coproc.c_name);
coproc_init (&sh_coproc);
+#endif
+ invert = (command->flags & CMD_INVERT_RETURN) != 0;
command_string_index = 0;
tcmd = make_command_string (command);
sh_openpipe ((int *)&rpipe); /* 0 = parent read, 1 = child write */
sh_openpipe ((int *)&wpipe); /* 0 = child read, 1 = parent write */
+ BLOCK_SIGNAL (SIGCHLD, set, oset);
+
coproc_pid = make_child (savestring (tcmd), 1);
+
if (coproc_pid == 0)
{
close (rpipe[0]);
close (wpipe[1]);
- exit (execute_in_subshell (command, 1, wpipe[0], rpipe[1], fds_to_close));
+ UNBLOCK_SIGNAL (oset);
+ estat = execute_in_subshell (command, 1, wpipe[0], rpipe[1], fds_to_close);
+
+ fflush (stdout);
+ fflush (stderr);
+
+ exit (estat);
}
close (rpipe[1]);
close (wpipe[0]);
+ /* XXX - possibly run Coproc->name through word expansion? */
cp = coproc_alloc (command->value.Coproc->name, coproc_pid);
cp->c_rfd = rpipe[0];
cp->c_wfd = wpipe[1];
coproc_setvars (cp);
+ UNBLOCK_SIGNAL (oset);
+
#if 0
itrace ("execute_coproc: [%d] %s", coproc_pid, the_printed_command);
#endif
DESCRIBE_PID (coproc_pid);
run_pending_traps ();
- return (EXECUTION_SUCCESS);
+ return (invert ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
}
#endif
+static void
+restore_stdin (s)
+ int s;
+{
+ dup2 (s, 0);
+ close (s);
+}
+
+/* Catch-all cleanup function for lastpipe code for unwind-protects */
+static void
+lastpipe_cleanup (s)
+ int s;
+{
+ unfreeze_jobs_list ();
+}
+
static int
execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close)
COMMAND *command;
struct fd_bitmap *fds_to_close;
{
int prev, fildes[2], new_bitmap_size, dummyfd, ignore_return, exec_result;
+ int lstdin, lastpipe_flag, lastpipe_jid;
COMMAND *cmd;
struct fd_bitmap *fd_bitmap;
+ pid_t lastpid;
#if defined (JOB_CONTROL)
sigset_t set, oset;
cmd = cmd->value.Connection->second;
}
+ lastpid = last_made_pid;
+
/* Now execute the rightmost command in the pipeline. */
if (ignore_return && cmd)
cmd->flags |= CMD_IGNORE_RETURN;
+
+ lastpipe_flag = 0;
+
+ begin_unwind_frame ("lastpipe-exec");
+ lstdin = -1;
+ /* If the `lastpipe' option is set with shopt, and job control is not
+ enabled, execute the last element of non-async pipelines in the
+ current shell environment. */
+ if (lastpipe_opt && job_control == 0 && asynchronous == 0 && pipe_out == NO_PIPE && prev > 0)
+ {
+ lstdin = move_to_high_fd (0, 1, -1);
+ if (lstdin > 0)
+ {
+ do_piping (prev, pipe_out);
+ prev = NO_PIPE;
+ add_unwind_protect (restore_stdin, lstdin);
+ lastpipe_flag = 1;
+ freeze_jobs_list ();
+ lastpipe_jid = stop_pipeline (0, (COMMAND *)NULL); /* XXX */
+ add_unwind_protect (lastpipe_cleanup, lastpipe_jid);
+ }
+ if (cmd)
+ cmd->flags |= CMD_LASTPIPE;
+ }
+ if (prev >= 0)
+ add_unwind_protect (close, prev);
+
exec_result = execute_command_internal (cmd, asynchronous, prev, pipe_out, fds_to_close);
+ if (lstdin > 0)
+ restore_stdin (lstdin);
+
if (prev >= 0)
close (prev);
#endif
QUIT;
+
+ if (lastpipe_flag)
+ {
+#if defined (JOB_CONTROL)
+ append_process (savestring (the_printed_command), dollar_dollar_pid, exec_result, lastpipe_jid);
+#endif
+ lstdin = wait_for (lastpid);
+#if defined (JOB_CONTROL)
+ exec_result = job_exit_status (lastpipe_jid);
+#endif
+ unfreeze_jobs_list ();
+ }
+
+ discard_unwind_frame ("lastpipe-exec");
+
return (exec_result);
}
int asynchronous, pipe_in, pipe_out;
struct fd_bitmap *fds_to_close;
{
- REDIRECT *rp;
COMMAND *tc, *second;
int ignore_return, exec_result, was_error_trap, invert;
+ volatile int save_line_number;
ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
if (tc == 0)
return (EXECUTION_SUCCESS);
- rp = tc->redirects;
-
if (ignore_return)
tc->flags |= CMD_IGNORE_RETURN;
tc->flags |= CMD_AMPERSAND;
invert = (command->flags & CMD_INVERT_RETURN) != 0;
ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
+ line_number_for_err_trap = line_number;
exec_result = execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close);
if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
{
last_command_exit_value = exec_result;
+ save_line_number = line_number;
+ line_number = line_number_for_err_trap;
run_error_trap ();
+ line_number = save_line_number;
}
if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
loop_level++;
identifier = for_command->name->word;
+ line_number = for_command->line; /* for expansion error messages */
list = releaser = expand_words_no_vars (for_command->map_list);
begin_unwind_frame ("for");
/* Save this command unless it's a trap command and we're not running
a debug trap. */
-#if 0
- if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
-#else
if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
-#endif
{
FREE (the_printed_command_except_trap);
the_printed_command_except_trap = savestring (the_printed_command);
#endif
this_command_name = (char *)NULL;
- v = bind_variable (identifier, list->word->word, 0);
+ /* XXX - special ksh93 for command index variable handling */
+ v = find_variable_last_nameref (identifier);
+ if (v && nameref_p (v))
+ {
+ v = bind_variable_value (v, list->word->word, 0);
+ }
+ else
+ v = bind_variable (identifier, list->word->word, 0);
if (readonly_p (v) || noassign_p (v))
{
line_number = save_line_number;
: 6)))))
static int
+displen (s)
+ const char *s;
+{
+#if defined (HANDLE_MULTIBYTE)
+ wchar_t *wcstr;
+ size_t slen;
+ int wclen;
+
+ wcstr = 0;
+ slen = mbstowcs (wcstr, s, 0);
+ if (slen == -1)
+ slen = 0;
+ wcstr = (wchar_t *)xmalloc (sizeof (wchar_t) * (slen + 1));
+ mbstowcs (wcstr, s, slen + 1);
+ wclen = wcswidth (wcstr, slen);
+ free (wcstr);
+ return (wclen < 0 ? STRLEN(s) : wclen);
+#else
+ return (STRLEN (s));
+#endif
+}
+
+static int
print_index_and_element (len, ind, list)
int len, ind;
WORD_LIST *list;
return (0);
for (i = ind, l = list; l && --i; l = l->next)
;
+ if (l == 0) /* don't think this can happen */
+ return (0);
fprintf (stderr, "%*d%s%s", len, ind, RP_SPACE, l->word->word);
- return (STRLEN (l->word->word));
+ return (displen (l->word->word));
}
static void
WORD_LIST *l;
char *repl_string, *t;
+#if 0
t = get_string_value ("LINES");
LINES = (t && *t) ? atoi (t) : 24;
+#endif
t = get_string_value ("COLUMNS");
COLS = (t && *t) ? atoi (t) : 80;
max_elem_len = 0;
for (l = list; l; l = l->next)
{
- len = STRLEN (l->word->word);
+ len = displen (l->word->word);
if (len > max_elem_len)
max_elem_len = len;
}
fflush (stderr);
QUIT;
- if (read_builtin ((WORD_LIST *)NULL) == EXECUTION_FAILURE)
+ if (read_builtin ((WORD_LIST *)NULL) != EXECUTION_SUCCESS)
{
putchar ('\n');
return ((char *)NULL);
for (l = list; l && --reply; l = l->next)
;
- return (l->word->word);
+ return (l->word->word); /* XXX - can't be null? */
}
}
retval = execute_command (clauses->action);
}
while ((clauses->flags & CASEPAT_FALLTHROUGH) && (clauses = clauses->next));
- if ((clauses->flags & CASEPAT_TESTNEXT) == 0)
+ if (clauses == 0 || (clauses->flags & CASEPAT_TESTNEXT) == 0)
EXIT_CASE ();
else
break;
static char * const nullstr = "";
+/* XXX - can COND ever be NULL when this is called? */
static int
execute_cond_node (cond)
COND_COM *cond;
{
- int result, invert, patmatch, rmatch, mflags;
+ int result, invert, patmatch, rmatch, mflags, ignore;
char *arg1, *arg2;
+#if 0
+ char *t1, *t2;
+#endif
invert = (cond->flags & CMD_INVERT_RETURN);
-
+ ignore = (cond->flags & CMD_IGNORE_RETURN);
+ if (ignore)
+ {
+ if (cond->left)
+ cond->left->flags |= CMD_IGNORE_RETURN;
+ if (cond->right)
+ cond->right->flags |= CMD_IGNORE_RETURN;
+ }
+
if (cond->type == COND_EXPR)
result = execute_cond_node (cond->left);
else if (cond->type == COND_OR)
}
else if (cond->type == COND_UNARY)
{
+ if (ignore)
+ comsub_ignore_return++;
arg1 = cond_expand_word (cond->left->op, 0);
+ if (ignore)
+ comsub_ignore_return--;
if (arg1 == 0)
arg1 = nullstr;
if (echo_command_at_execute)
else if (cond->type == COND_BINARY)
{
rmatch = 0;
- patmatch = ((cond->op->word[1] == '=') && (cond->op->word[2] == '\0') &&
- (cond->op->word[0] == '!' || cond->op->word[0] == '=') ||
+ patmatch = (((cond->op->word[1] == '=') && (cond->op->word[2] == '\0') &&
+ (cond->op->word[0] == '!' || cond->op->word[0] == '=')) ||
(cond->op->word[0] == '=' && cond->op->word[1] == '\0'));
#if defined (COND_REGEXP)
rmatch = (cond->op->word[0] == '=' && cond->op->word[1] == '~' &&
cond->op->word[2] == '\0');
#endif
+ if (ignore)
+ comsub_ignore_return++;
arg1 = cond_expand_word (cond->left->op, 0);
+ if (ignore)
+ comsub_ignore_return--;
if (arg1 == 0)
arg1 = nullstr;
+ if (ignore)
+ comsub_ignore_return++;
arg2 = cond_expand_word (cond->right->op,
(rmatch && shell_compatibility_level > 31) ? 2 : (patmatch ? 1 : 0));
+ if (ignore)
+ comsub_ignore_return--;
if (arg2 == 0)
arg2 = nullstr;
mflags |= SHMAT_SUBEXP;
#endif
+#if 0
+ t1 = strescape(arg1);
+ t2 = strescape(arg2);
+ itrace("execute_cond_node: sh_regmatch on `%s' and `%s'", t1, t2);
+ free(t1);
+ free(t2);
+#endif
+
result = sh_regmatch (arg1, arg2, mflags);
}
else
int oe;
oe = extended_glob;
extended_glob = 1;
- result = binary_test (cond->op->word, arg1, arg2, TEST_PATMATCH|TEST_ARITHEXP)
+ result = binary_test (cond->op->word, arg1, arg2, TEST_PATMATCH|TEST_ARITHEXP|TEST_LOCALE)
? EXECUTION_SUCCESS
: EXECUTION_FAILURE;
extended_glob = oe;
/* If we're in a function, update the line number information. */
if (variable_context && interactive_shell)
line_number -= function_line_number;
-
command_string_index = 0;
print_cond_command (cond_command);
int pipe_in, pipe_out, async;
{
int r;
+ int forcefork;
+ REDIRECT *rd;
+
+ for (forcefork = 0, rd = redirects; rd; rd = rd->next)
+ forcefork += rd->rflags & REDIR_VARASSIGN;
- if (pipe_in != NO_PIPE || pipe_out != NO_PIPE || async)
+ if (forcefork || pipe_in != NO_PIPE || pipe_out != NO_PIPE || async)
{
/* We have a null command, but we really want a subshell to take
care of it. Just fork, do piping and redirections, and exit. */
{
close_pipes (pipe_in, pipe_out);
#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
- unlink_fifo_list ();
+ if (pipe_out == NO_PIPE)
+ unlink_fifo_list ();
#endif
return (EXECUTION_SUCCESS);
}
fix_assignment_words (words)
WORD_LIST *words;
{
- WORD_LIST *w;
+ WORD_LIST *w, *wcmd;
struct builtin *b;
- int assoc;
+ int assoc, global, array, integer;
if (words == 0)
return;
b = 0;
- assoc = 0;
+ assoc = global = array = integer = 0;
+
+ /* Skip over assignment statements preceding a command name */
+ wcmd = words;
+ for (wcmd = words; wcmd; wcmd = wcmd->next)
+ if ((wcmd->word->flags & W_ASSIGNMENT) == 0)
+ break;
- for (w = words; w; w = w->next)
+ for (w = wcmd; w; w = w->next)
if (w->word->flags & W_ASSIGNMENT)
{
if (b == 0)
{
- b = builtin_address_internal (words->word->word, 0);
+ /* Posix (post-2008) says that `command' doesn't change whether
+ or not the builtin it shadows is a `declaration command', even
+ though it removes other special builtin properties. In Posix
+ mode, we skip over one or more instances of `command' and
+ deal with the next word as the assignment builtin. */
+ while (posixly_correct && wcmd && wcmd->word && wcmd->word->word && STREQ (wcmd->word->word, "command"))
+ wcmd = wcmd->next;
+ b = builtin_address_internal (wcmd->word->word, 0);
if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
return;
else if (b && (b->flags & ASSIGNMENT_BUILTIN))
- words->word->flags |= W_ASSNBLTIN;
+ wcmd->word->flags |= W_ASSNBLTIN;
}
w->word->flags |= (W_NOSPLIT|W_NOGLOB|W_TILDEEXP|W_ASSIGNARG);
#if defined (ARRAY_VARS)
if (assoc)
w->word->flags |= W_ASSIGNASSOC;
+ if (array)
+ w->word->flags |= W_ASSIGNARRAY;
#endif
+ if (global)
+ w->word->flags |= W_ASSNGLOBAL;
+ if (integer)
+ w->word->flags |= W_ASSIGNINT;
}
#if defined (ARRAY_VARS)
/* Note that we saw an associative array option to a builtin that takes
assignment statements. This is a bit of a kludge. */
- else if (w->word->word[0] == '-' && strchr (w->word->word, 'A'))
+ else if (w->word->word[0] == '-' && (strchr (w->word->word+1, 'A') || strchr (w->word->word+1, 'a') || strchr (w->word->word+1, 'g')))
+#else
+ else if (w->word->word[0] == '-' && strchr (w->word->word+1, 'g'))
+#endif
{
if (b == 0)
{
- b = builtin_address_internal (words->word->word, 0);
+ while (posixly_correct && wcmd && wcmd->word && wcmd->word->word && STREQ (wcmd->word->word, "command"))
+ wcmd = wcmd->next;
+ b = builtin_address_internal (wcmd->word->word, 0);
if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
return;
else if (b && (b->flags & ASSIGNMENT_BUILTIN))
- words->word->flags |= W_ASSNBLTIN;
+ wcmd->word->flags |= W_ASSNBLTIN;
}
- if (words->word->flags & W_ASSNBLTIN)
+ if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'A'))
assoc = 1;
+ else if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'a'))
+ array = 1;
+ if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'g'))
+ global = 1;
+ if ((wcmd->word->flags & W_ASSNBLTIN) && strchr (w->word->word+1, 'i'))
+ integer = 1;
}
-#endif
}
/* Return 1 if the file found by searching $PATH for PATHNAME, defaulting
char *pathname;
{
char *temp;
- temp = search_for_command (pathname);
- return (temp ? file_isdir (temp) : file_isdir (pathname));
+ int ret;
+
+ temp = search_for_command (pathname, 0);
+ ret = (temp ? file_isdir (temp) : file_isdir (pathname));
+ free (temp);
+ return ret;
}
/* The meaty part of all the executions. We have to start hacking the
pid_t old_last_async_pid;
sh_builtin_func_t *builtin;
SHELL_VAR *func;
+ volatile int old_builtin, old_command_builtin;
result = EXECUTION_SUCCESS;
special_builtin_failed = builtin_is_special = 0;
command_line = (char *)0;
+ QUIT;
+
/* If we're in a function, update the line number information. */
- if (variable_context && interactive_shell)
+ if (variable_context && interactive_shell && sourcelevel == 0)
line_number -= function_line_number;
/* Remember what this command line looks like at invocation. */
#endif
last_asynchronous_pid = old_last_async_pid;
+
+ CHECK_SIGTERM;
}
else
{
+ /* Don't let simple commands that aren't the last command in a
+ pipeline change $? for the rest of the pipeline (or at all). */
+ if (pipe_out != NO_PIPE)
+ result = last_command_exit_value;
close_pipes (pipe_in, pipe_out);
#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
- unlink_fifo_list ();
+ /* Close /dev/fd file descriptors in the parent after forking the
+ last child in a (possibly one-element) pipeline. Defer this
+ until any running shell function completes. */
+ if (pipe_out == NO_PIPE && variable_context == 0) /* XXX */
+ unlink_fifo_list (); /* XXX */
#endif
command_line = (char *)NULL; /* don't free this. */
bind_lastarg ((char *)NULL);
/* In POSIX mode, assignment errors in the temporary environment cause a
non-interactive shell to exit. */
- if (builtin_is_special && interactive_shell == 0 && tempenv_assign_error)
+ if (posixly_correct && builtin_is_special && interactive_shell == 0 && tempenv_assign_error)
{
last_command_exit_value = EXECUTION_FAILURE;
jump_to_top_level (ERREXIT);
}
+ tempenv_assign_error = 0; /* don't care about this any more */
add_unwind_protect (dispose_words, words);
QUIT;
goto return_result;
}
- /* One other possiblilty. The user may want to resume an existing job.
+ /* One other possibililty. The user may want to resume an existing job.
If they do, find out whether this word is a candidate for a running
job. */
if (job_control && already_forked == 0 && async == 0 &&
if (builtin || func)
{
if (builtin)
- unwind_protect_int (executing_builtin); /* modified in execute_builtin */
+ {
+ old_builtin = executing_builtin;
+ old_command_builtin = executing_command_builtin;
+ unwind_protect_int (executing_builtin); /* modified in execute_builtin */
+ unwind_protect_int (executing_command_builtin); /* ditto */
+ }
if (already_forked)
{
/* reset_terminating_signals (); */ /* XXX */
- /* Cancel traps, in trap.c. */
- restore_original_signals ();
+ /* Reset the signal handlers in the child, but don't free the
+ trap strings. Set a flag noting that we have to free the
+ trap strings if we run trap to change a signal disposition. */
+ reset_signal_handlers ();
+ subshell_environment |= SUBSHELL_RESETTRAP;
if (async)
{
{
if (result > EX_SHERRBASE)
{
+ switch (result)
+ {
+ case EX_REDIRFAIL:
+ case EX_BADASSIGN:
+ case EX_EXPFAIL:
+ /* These errors cause non-interactive posix mode shells to exit */
+ if (posixly_correct && builtin_is_special && interactive_shell == 0)
+ {
+ last_command_exit_value = EXECUTION_FAILURE;
+ jump_to_top_level (ERREXIT);
+ }
+ }
result = builtin_status (result);
if (builtin_is_special)
special_builtin_failed = 1;
}
if (command_line == 0)
- command_line = savestring (the_printed_command_except_trap);
+ command_line = savestring (the_printed_command_except_trap ? the_printed_command_except_trap : "");
#if defined (PROCESS_SUBSTITUTION)
if ((subshell_environment & SUBSHELL_COMSUB) && (simple_command->flags & CMD_NO_FORK) && fifos_pending() > 0)
simple_command->flags &= ~CMD_NO_FORK;
#endif
- execute_disk_command (words, simple_command->redirects, command_line,
+ result = execute_disk_command (words, simple_command->redirects, command_line,
pipe_in, pipe_out, async, fds_to_close,
simple_command->flags);
bind_lastarg (lastarg);
FREE (command_line);
dispose_words (words);
+ if (builtin)
+ {
+ executing_builtin = old_builtin;
+ executing_command_builtin = old_command_builtin;
+ }
discard_unwind_frame ("simple-command");
this_command_name = (char *)NULL; /* points to freed memory now */
return (result);
{
int old_e_flag, result, eval_unwind;
int isbltinenv;
+ char *error_trap;
-#if 0
- /* XXX -- added 12/11 */
- terminate_immediately++;
-#endif
-
+ error_trap = 0;
old_e_flag = exit_immediately_on_error;
+
/* The eval builtin calls parse_and_execute, which does not know about
the setting of flags, and always calls the execution functions with
flags that will exit the shell on an error if -e is set. If the
eval builtin is being called, and we're supposed to ignore the exit
- value of the command, we turn the -e flag off ourselves, then
- restore it when the command completes. This is also a problem (as
- below) for the command and source/. builtins. */
+ value of the command, we turn the -e flag off ourselves and disable
+ the ERR trap, then restore them when the command completes. This is
+ also a problem (as below) for the command and source/. builtins. */
if (subshell == 0 && (flags & CMD_IGNORE_RETURN) &&
(builtin == eval_builtin || builtin == command_builtin || builtin == source_builtin))
{
begin_unwind_frame ("eval_builtin");
unwind_protect_int (exit_immediately_on_error);
+ unwind_protect_int (builtin_ignoring_errexit);
+ error_trap = TRAP_STRING (ERROR_TRAP);
+ if (error_trap)
+ {
+ error_trap = savestring (error_trap);
+ add_unwind_protect (xfree, error_trap);
+ add_unwind_protect (set_error_trap, error_trap);
+ restore_default_signal (ERROR_TRAP);
+ }
exit_immediately_on_error = 0;
+ builtin_ignoring_errexit = 1;
eval_unwind = 1;
}
else
/* The temporary environment for a builtin is supposed to apply to
all commands executed by that builtin. Currently, this is a
- problem only with the `unset', `source' and `eval' builtins. */
-
- isbltinenv = (builtin == source_builtin || builtin == eval_builtin || builtin == unset_builtin);
+ problem only with the `unset', `source' and `eval' builtins.
+ `mapfile' is a special case because it uses evalstring (same as
+ eval or source) to run its callbacks. */
+ isbltinenv = (builtin == source_builtin || builtin == eval_builtin || builtin == unset_builtin || builtin == mapfile_builtin);
if (isbltinenv)
{
}
executing_builtin++;
+ executing_command_builtin |= builtin == command_builtin;
result = ((*builtin) (words->next));
/* This shouldn't happen, but in case `return' comes back instead of
if (eval_unwind)
{
- exit_immediately_on_error += old_e_flag;
+ exit_immediately_on_error = errexit_flag;
+ builtin_ignoring_errexit = 0;
+ if (error_trap)
+ {
+ set_error_trap (error_trap);
+ xfree (error_trap);
+ }
discard_unwind_frame ("eval_builtin");
}
-#if 0
- /* XXX -- added 12/11 */
- terminate_immediately--;
-#endif
-
return (result);
}
char *debug_trap, *error_trap, *return_trap;
#if defined (ARRAY_VARS)
SHELL_VAR *funcname_v, *nfv, *bash_source_v, *bash_lineno_v;
- ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;
+ ARRAY *funcname_a;
+ volatile ARRAY *bash_source_a;
+ volatile ARRAY *bash_lineno_a;
#endif
FUNCTION_DEF *shell_fn;
char *sfile, *t;
- static int funcnest = 0;
USE_VAR(fc);
+ if (funcnest_max > 0 && funcnest >= funcnest_max)
+ {
+ internal_error (_("%s: maximum function nesting level exceeded (%d)"), var->name, funcnest);
+ funcnest = 0; /* XXX - should we reset it somewhere else? */
+ jump_to_top_level (DISCARD);
+ }
+
#if defined (ARRAY_VARS)
GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
add_unwind_protect (dispose_command, (char *)tc);
unwind_protect_pointer (this_shell_function);
unwind_protect_int (loop_level);
+ unwind_protect_int (funcnest);
}
else
push_context (var->name, subshell, temporary_env); /* don't unwind-protect for subshells */
/* This is quite similar to the code in shell.c and elsewhere. */
shell_fn = find_function_def (this_shell_function->name);
sfile = shell_fn ? shell_fn->source_file : "";
- array_push (funcname_a, this_shell_function->name);
+ array_push ((ARRAY *)funcname_a, this_shell_function->name);
- array_push (bash_source_a, sfile);
+ array_push ((ARRAY *)bash_source_a, sfile);
t = itos (executing_line_number ());
- array_push (bash_lineno_a, t);
+ array_push ((ARRAY *)bash_lineno_a, t);
free (t);
#endif
fc = tc;
return_catch_flag++;
- return_val = setjmp (return_catch);
+ return_val = setjmp_nosigs (return_catch);
if (return_val)
{
if (subshell == 0)
run_unwind_frame ("function_calling");
- funcnest--;
#if defined (ARRAY_VARS)
/* These two variables cannot be unset, and cannot be affected by the
function. */
- array_pop (bash_source_a);
- array_pop (bash_lineno_a);
+ array_pop ((ARRAY *)bash_source_a);
+ array_pop ((ARRAY *)bash_lineno_a);
/* FUNCNAME can be unset, and so can potentially be changed by the
function. */
#endif
if (variable_context == 0 || this_shell_function == 0)
- make_funcname_visible (0);
-
+ {
+ make_funcname_visible (0);
+#if defined (PROCESS_SUBSTITUTION)
+ unlink_fifo_list ();
+#endif
+ }
+
return (result);
}
{
/* Give builtins a place to jump back to on failure,
so we don't go back up to main(). */
- result = setjmp (top_level);
+ result = setjmp_nosigs (top_level);
/* Give the return builtin a place to jump to when executed in a subshell
or pipeline */
funcvalue = 0;
if (return_catch_flag && builtin == return_builtin)
- funcvalue = setjmp (return_catch);
+ funcvalue = setjmp_nosigs (return_catch);
if (result == EXITPROG)
exit (last_command_exit_value);
{
int result;
REDIRECT *saved_undo_list;
- sh_builtin_func_t *saved_this_shell_builtin;
+#if defined (PROCESS_SUBSTITUTION)
+ int ofifo, nfifo, osize;
+ char *ofifo_list;
+#endif
+
+
+#if defined (PROCESS_SUBSTITUTION)
+ ofifo = num_fifos ();
+ ofifo_list = copy_fifo_list (&osize);
+#endif
if (do_redirections (redirects, RX_ACTIVE|RX_UNDOABLE) != 0)
{
cleanup_redirects (redirection_undo_list);
redirection_undo_list = (REDIRECT *)NULL;
dispose_exec_redirects ();
+#if defined (PROCESS_SUBSTITUTION)
+ free (ofifo_list);
+#endif
return (EX_REDIRFAIL); /* was EXECUTION_FAILURE */
}
- saved_this_shell_builtin = this_shell_builtin;
saved_undo_list = redirection_undo_list;
/* Calling the "exec" builtin changes redirections forever. */
and preserve the redirections. */
if (builtin == command_builtin && this_shell_builtin == exec_builtin)
{
+ int discard;
+
+ discard = 0;
if (saved_undo_list)
- dispose_redirects (saved_undo_list);
+ {
+ dispose_redirects (saved_undo_list);
+ discard = 1;
+ }
redirection_undo_list = exec_redirection_undo_list;
saved_undo_list = exec_redirection_undo_list = (REDIRECT *)NULL;
- discard_unwind_frame ("saved_redirects");
+ if (discard)
+ discard_unwind_frame ("saved redirects");
}
if (saved_undo_list)
redirection_undo_list = (REDIRECT *)NULL;
}
+#if defined (PROCESS_SUBSTITUTION)
+ /* Close any FIFOs created by this builtin or function. */
+ nfifo = num_fifos ();
+ if (nfifo > ofifo)
+ close_new_fifos (ofifo_list, osize);
+ free (ofifo_list);
+#endif
+
return (result);
}
if (job_control == 0)
#endif
{
+ /* Make sure we get the original signal dispositions now so we don't
+ confuse the trap builtin later if the subshell tries to use it to
+ reset SIGINT/SIGQUIT. Don't call set_signal_ignored; that sets
+ the value of original_signals to SIG_IGN. Posix interpretation 751. */
+ get_original_signal (SIGINT);
set_signal_handler (SIGINT, SIG_IGN);
- set_signal_ignored (SIGINT);
+
+ get_original_signal (SIGQUIT);
set_signal_handler (SIGQUIT, SIG_IGN);
- set_signal_ignored (SIGQUIT);
}
}
# define NOTFOUND_HOOK "command_not_found_handle"
#endif
-static void
+static int
execute_disk_command (words, redirects, command_line, pipe_in, pipe_out,
async, fds_to_close, cmdflags)
WORD_LIST *words;
int cmdflags;
{
char *pathname, *command, **args;
- int nofork;
+ int nofork, result;
pid_t pid;
SHELL_VAR *hookf;
WORD_LIST *wl;
nofork = (cmdflags & CMD_NO_FORK); /* Don't fork, just exec, if no pipes */
pathname = words->word->word;
+ result = EXECUTION_SUCCESS;
#if defined (RESTRICTED_SHELL)
command = (char *)NULL;
- if (restricted && xstrchr (pathname, '/'))
+ if (restricted && mbschr (pathname, '/'))
{
internal_error (_("%s: restricted: cannot specify `/' in command names"),
pathname);
- last_command_exit_value = EXECUTION_FAILURE;
+ result = last_command_exit_value = EXECUTION_FAILURE;
/* If we're not going to fork below, we must already be in a child
process or a context in which it's safe to call exit(2). */
}
#endif /* RESTRICTED_SHELL */
- command = search_for_command (pathname);
+ command = search_for_command (pathname, 1);
if (command)
{
{
int old_interactive;
-#if 0
- /* This has been disabled for the time being. */
-#if !defined (ARG_MAX) || ARG_MAX >= 10240
- if (posixly_correct == 0)
- put_gnu_argv_flags_into_env ((long)getpid (), glob_argv_flags);
-#endif
-#endif
-
+ reset_terminating_signals (); /* XXX */
/* Cancel traps, in trap.c. */
restore_original_signals ();
+ CHECK_SIGTERM;
+
/* restore_original_signals may have undone the work done
by make_child to ensure that SIGINT and SIGQUIT are ignored
in asynchronous children. */
hookf = find_function (NOTFOUND_HOOK);
if (hookf == 0)
{
+ /* Make sure filenames are displayed using printable characters */
+ if (ansic_shouldquote (pathname))
+ pathname = ansic_quote (pathname, 0, NULL);
internal_error (_("%s: command not found"), pathname);
exit (EX_NOTFOUND); /* Posix.2 says the exit status is 127 */
}
+#if defined (JOB_CONTROL)
+ /* May need to reinitialize more of the job control state here. */
+ kill_current_pipeline ();
+#endif
+
wl = make_word_list (make_word (NOTFOUND_HOOK), words);
exit (execute_shell_function (hookf, wl));
}
+ CHECK_SIGTERM;
+
/* Execve expects the command name to be in args[0]. So we
leave it there, in the same format that the user used to
type it in. */
else
{
parent_return:
+ QUIT;
+
/* Make sure that the pipes are closed in the parent. */
close_pipes (pipe_in, pipe_out);
#if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
- unlink_fifo_list ();
+ if (variable_context == 0)
+ unlink_fifo_list ();
#endif
FREE (command);
+ return (result);
}
}
parse_and_execute_level = 0; /* nothing left to restore it */
/* We're no longer inside a shell function. */
- variable_context = return_catch_flag = 0;
+ variable_context = return_catch_flag = funcnest = 0;
executing_list = 0; /* XXX */
if (i != ENOEXEC)
{
if (file_isdir (command))
+#if defined (EISDIR)
+ internal_error (_("%s: %s"), command, strerror (EISDIR));
+#else
internal_error (_("%s: is a directory"), command);
+#endif
else if (executable_file (command) == 0)
{
errno = i;
run it for some reason. See why. */
#if defined (HAVE_HASH_BANG_EXEC)
READ_SAMPLE_BUF (command, sample, sample_len);
+ sample[sample_len - 1] = '\0';
if (sample_len > 2 && sample[0] == '#' && sample[1] == '!')
{
char *interp;
#endif
if (check_binary_file (sample, sample_len))
{
- internal_error (_("%s: cannot execute binary file"), command);
+ internal_error (_("%s: cannot execute binary file: %s"), command, strerror (i));
return (EX_BINARY_FILE);
}
}
}
static int
-execute_intern_function (name, function)
+execute_intern_function (name, funcdef)
WORD_DESC *name;
- COMMAND *function;
+ FUNCTION_DEF *funcdef;
{
SHELL_VAR *var;
return (EXECUTION_FAILURE);
}
+ /* Posix interpretation 383 */
+ if (posixly_correct && find_special_builtin (name->word))
+ {
+ internal_error (_("`%s': is a special builtin"), name->word);
+ last_command_exit_value = EX_BADUSAGE;
+ jump_to_top_level (ERREXIT);
+ }
+
var = find_function (name->word);
if (var && (readonly_p (var) || noassign_p (var)))
{
return (EXECUTION_FAILURE);
}
- bind_function (name->word, function);
+#if defined (DEBUGGER)
+ bind_function_def (name->word, funcdef);
+#endif
+
+ bind_function (name->word, funcdef->command);
return (EXECUTION_SUCCESS);
}
dup_error (pipe_in, 0);
if (pipe_in > 0)
close (pipe_in);
+#ifdef __CYGWIN__
+ /* Let stdio know the fd may have changed from text to binary mode. */
+ freopen (NULL, "r", stdin);
+#endif /* __CYGWIN__ */
}
if (pipe_out != NO_PIPE)
{
if (dup2 (1, 2) < 0)
dup_error (1, 2);
}
+#ifdef __CYGWIN__
+ /* Let stdio know the fd may have changed from text to binary mode, and
+ make sure to preserve stdout line buffering. */
+ freopen (NULL, "w", stdout);
+ sh_setlinebuf (stdout);
+#endif /* __CYGWIN__ */
}
}
projects / platform / upstream / bash.git / blobdiff