1 /* execute_cmd.c -- Execute a COMMAND structure. */
3 /* Copyright (C) 1987-2009 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
23 #if !defined (__GNUC__) && !defined (HAVE_ALLOCA_H) && defined (_AIX)
25 #endif /* _AIX && RISC6000 && !__GNUC__ */
28 #include "chartypes.h"
29 #include "bashtypes.h"
30 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
31 # include <sys/file.h>
34 #include "posixstat.h"
37 # include <sys/param.h>
40 #if defined (HAVE_UNISTD_H)
44 #include "posixtime.h"
46 #if defined (HAVE_SYS_RESOURCE_H) && !defined (RLIMTYPE)
47 # include <sys/resource.h>
50 #if defined (HAVE_SYS_TIMES_H) && defined (HAVE_TIMES)
51 # include <sys/times.h>
65 #include <y.tab.h> /* use <...> so we pick it up from the build directory */
70 #include "execute_cmd.h"
77 #if defined (COND_COMMAND)
81 #include "builtins/common.h"
82 #include "builtins/builtext.h" /* list of builtins */
84 #include <glob/strmatch.h>
85 #include <tilde/tilde.h>
87 #if defined (BUFFERED_INPUT)
96 # include "bashhist.h"
99 extern int posixly_correct;
100 extern int expand_aliases;
102 extern int breaking, continuing, loop_level;
103 extern int parse_and_execute_level, running_trap;
104 extern int command_string_index, line_number;
105 extern int dot_found_in_search;
106 extern int already_making_children;
107 extern int tempenv_assign_error;
108 extern char *the_printed_command, *shell_name;
109 extern pid_t last_command_subst_pid;
110 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
111 extern char **subshell_argv, **subshell_envp;
112 extern int subshell_argc;
114 extern char *glob_argv_flags;
117 extern int close __P((int));
119 /* Static functions defined and used in this file. */
120 static void close_pipes __P((int, int));
121 static void do_piping __P((int, int));
122 static void bind_lastarg __P((char *));
123 static int shell_control_structure __P((enum command_type));
124 static void cleanup_redirects __P((REDIRECT *));
126 #if defined (JOB_CONTROL)
127 static int restore_signal_mask __P((sigset_t *));
130 static void async_redirect_stdin __P((void));
132 static int builtin_status __P((int));
134 static int execute_for_command __P((FOR_COM *));
135 #if defined (SELECT_COMMAND)
136 static int print_index_and_element __P((int, int, WORD_LIST *));
137 static void indent __P((int, int));
138 static void print_select_list __P((WORD_LIST *, int, int, int));
139 static char *select_query __P((WORD_LIST *, int, char *, int));
140 static int execute_select_command __P((SELECT_COM *));
142 #if defined (DPAREN_ARITHMETIC)
143 static int execute_arith_command __P((ARITH_COM *));
145 #if defined (COND_COMMAND)
146 static int execute_cond_node __P((COND_COM *));
147 static int execute_cond_command __P((COND_COM *));
149 #if defined (COMMAND_TIMING)
150 static int mkfmt __P((char *, int, int, time_t, int));
151 static void print_formatted_time __P((FILE *, char *,
152 time_t, int, time_t, int,
154 static int time_command __P((COMMAND *, int, int, int, struct fd_bitmap *));
156 #if defined (ARITH_FOR_COMMAND)
157 static intmax_t eval_arith_for_expr __P((WORD_LIST *, int *));
158 static int execute_arith_for_command __P((ARITH_FOR_COM *));
160 static int execute_case_command __P((CASE_COM *));
161 static int execute_while_command __P((WHILE_COM *));
162 static int execute_until_command __P((WHILE_COM *));
163 static int execute_while_or_until __P((WHILE_COM *, int));
164 static int execute_if_command __P((IF_COM *));
165 static int execute_null_command __P((REDIRECT *, int, int, int));
166 static void fix_assignment_words __P((WORD_LIST *));
167 static int execute_simple_command __P((SIMPLE_COM *, int, int, int, struct fd_bitmap *));
168 static int execute_builtin __P((sh_builtin_func_t *, WORD_LIST *, int, int));
169 static int execute_function __P((SHELL_VAR *, WORD_LIST *, int, struct fd_bitmap *, int, int));
170 static int execute_builtin_or_function __P((WORD_LIST *, sh_builtin_func_t *,
172 REDIRECT *, struct fd_bitmap *, int));
173 static void execute_subshell_builtin_or_function __P((WORD_LIST *, REDIRECT *,
179 static void execute_disk_command __P((WORD_LIST *, REDIRECT *, char *,
180 int, int, int, struct fd_bitmap *, int));
182 static char *getinterp __P((char *, int, int *));
183 static void initialize_subshell __P((void));
184 static int execute_in_subshell __P((COMMAND *, int, int, int, struct fd_bitmap *));
185 #if defined (COPROCESS_SUPPORT)
186 static int execute_coproc __P((COMMAND *, int, int, struct fd_bitmap *));
189 static int execute_pipeline __P((COMMAND *, int, int, int, struct fd_bitmap *));
191 static int execute_connection __P((COMMAND *, int, int, int, struct fd_bitmap *));
193 static int execute_intern_function __P((WORD_DESC *, COMMAND *));
195 /* Set to 1 if fd 0 was the subject of redirection to a subshell. Global
196 so that reader_loop can set it to zero before executing a command. */
199 /* The name of the command that is currently being executed.
200 `test' needs this, for example. */
201 char *this_command_name;
203 /* The printed representation of the currently-executing command (same as
204 the_printed_command), except when a trap is being executed. Useful for
205 a debugger to know where exactly the program is currently executing. */
206 char *the_printed_command_except_trap;
208 /* For catching RETURN in a function. */
209 int return_catch_flag;
210 int return_catch_value;
211 procenv_t return_catch;
213 /* The value returned by the last synchronous command. */
214 int last_command_exit_value;
216 /* Whether or not the last command (corresponding to last_command_exit_value)
217 was terminated by a signal, and, if so, which one. */
218 int last_command_exit_signal;
220 /* The list of redirections to perform which will undo the redirections
221 that I made in the shell. */
222 REDIRECT *redirection_undo_list = (REDIRECT *)NULL;
224 /* The list of redirections to perform which will undo the internal
225 redirections performed by the `exec' builtin. These are redirections
226 that must be undone even when exec discards redirection_undo_list. */
227 REDIRECT *exec_redirection_undo_list = (REDIRECT *)NULL;
229 /* When greater than zero, value is the `level' of builtins we are
230 currently executing (e.g. `eval echo a' would have it set to 2). */
231 int executing_builtin = 0;
233 /* Non-zero if we are executing a command list (a;b;c, etc.) */
234 int executing_list = 0;
236 /* Non-zero if failing commands in a command substitution should not exit the
237 shell even if -e is set. Used to pass the CMD_IGNORE_RETURN flag down to
238 commands run in command substitutions by parse_and_execute. */
239 int comsub_ignore_return = 0;
241 /* Non-zero if we have just forked and are currently running in a subshell
243 int subshell_environment;
245 /* Count of nested subshells, like SHLVL. Available via $BASH_SUBSHELL */
246 int subshell_level = 0;
248 /* Currently-executing shell function. */
249 SHELL_VAR *this_shell_function;
251 /* If non-zero, matches in case and [[ ... ]] are case-insensitive */
252 int match_ignore_case = 0;
254 struct stat SB; /* used for debugging */
256 static int special_builtin_failed;
258 static COMMAND *currently_executing_command;
260 /* The line number that the currently executing function starts on. */
261 static int function_line_number;
263 /* XXX - set to 1 if we're running the DEBUG trap and we want to show the line
264 number containing the function name. Used by executing_line_number to
265 report the correct line number. Kind of a hack. */
266 static int showing_function_line;
268 static int line_number_for_err_trap;
270 struct fd_bitmap *current_fds_to_close = (struct fd_bitmap *)NULL;
272 #define FD_BITMAP_DEFAULT_SIZE 32
274 /* Functions to allocate and deallocate the structures used to pass
275 information from the shell to its children about file descriptors
281 struct fd_bitmap *ret;
283 ret = (struct fd_bitmap *)xmalloc (sizeof (struct fd_bitmap));
289 ret->bitmap = (char *)xmalloc (size);
290 memset (ret->bitmap, '\0', size);
293 ret->bitmap = (char *)NULL;
298 dispose_fd_bitmap (fdbp)
299 struct fd_bitmap *fdbp;
306 close_fd_bitmap (fdbp)
307 struct fd_bitmap *fdbp;
313 for (i = 0; i < fdbp->size; i++)
322 /* Return the line number of the currently executing command. */
324 executing_line_number ()
326 if (executing && showing_function_line == 0 &&
327 (variable_context == 0 || interactive_shell == 0) &&
328 currently_executing_command)
330 #if defined (COND_COMMAND)
331 if (currently_executing_command->type == cm_cond)
332 return currently_executing_command->value.Cond->line;
334 #if defined (DPAREN_ARITHMETIC)
335 else if (currently_executing_command->type == cm_arith)
336 return currently_executing_command->value.Arith->line;
338 #if defined (ARITH_FOR_COMMAND)
339 else if (currently_executing_command->type == cm_arith_for)
340 return currently_executing_command->value.ArithFor->line;
349 /* Execute the command passed in COMMAND. COMMAND is exactly what
350 read_command () places into GLOBAL_COMMAND. See "command.h" for the
351 details of the command structure.
353 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
354 return values. Executing a command with nothing in it returns
355 EXECUTION_SUCCESS. */
357 execute_command (command)
360 struct fd_bitmap *bitmap;
363 current_fds_to_close = (struct fd_bitmap *)NULL;
364 bitmap = new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE);
365 begin_unwind_frame ("execute-command");
366 add_unwind_protect (dispose_fd_bitmap, (char *)bitmap);
368 /* Just do the command, but not asynchronously. */
369 result = execute_command_internal (command, 0, NO_PIPE, NO_PIPE, bitmap);
371 dispose_fd_bitmap (bitmap);
372 discard_unwind_frame ("execute-command");
374 #if defined (PROCESS_SUBSTITUTION)
375 /* don't unlink fifos if we're in a shell function; wait until the function
377 if (variable_context == 0)
379 #endif /* PROCESS_SUBSTITUTION */
385 /* Return 1 if TYPE is a shell control structure type. */
387 shell_control_structure (type)
388 enum command_type type;
392 #if defined (ARITH_FOR_COMMAND)
395 #if defined (SELECT_COMMAND)
398 #if defined (DPAREN_ARITHMETIC)
401 #if defined (COND_COMMAND)
410 case cm_function_def:
418 /* A function to use to unwind_protect the redirection undo list
421 cleanup_redirects (list)
424 do_redirections (list, RX_ACTIVE);
425 dispose_redirects (list);
429 /* Function to unwind_protect the redirections for functions and builtins. */
431 cleanup_func_redirects (list)
434 do_redirections (list, RX_ACTIVE);
439 dispose_exec_redirects ()
441 if (exec_redirection_undo_list)
443 dispose_redirects (exec_redirection_undo_list);
444 exec_redirection_undo_list = (REDIRECT *)NULL;
448 #if defined (JOB_CONTROL)
449 /* A function to restore the signal mask to its proper value when the shell
450 is interrupted or errors occur while creating a pipeline. */
452 restore_signal_mask (set)
455 return (sigprocmask (SIG_SETMASK, set, (sigset_t *)NULL));
457 #endif /* JOB_CONTROL */
460 /* A debugging function that can be called from gdb, for instance. */
465 int f, fd_table_size;
467 fd_table_size = getdtablesize ();
469 fprintf (stderr, "pid %ld open files:", (long)getpid ());
470 for (i = 3; i < fd_table_size; i++)
472 if ((f = fcntl (i, F_GETFD, 0)) != -1)
473 fprintf (stderr, " %d (%s)", i, f ? "close" : "open");
475 fprintf (stderr, "\n");
480 async_redirect_stdin ()
484 fd = open ("/dev/null", O_RDONLY);
491 internal_error (_("cannot redirect standard input from /dev/null: %s"), strerror (errno));
494 #define DESCRIBE_PID(pid) do { if (interactive) describe_pid (pid); } while (0)
496 /* Execute the command passed in COMMAND, perhaps doing it asynchrounously.
497 COMMAND is exactly what read_command () places into GLOBAL_COMMAND.
498 ASYNCHROUNOUS, if non-zero, says to do this command in the background.
499 PIPE_IN and PIPE_OUT are file descriptors saying where input comes
500 from and where it goes. They can have the value of NO_PIPE, which means
502 FDS_TO_CLOSE is a list of file descriptors to close once the child has
503 been forked. This list often contains the unusable sides of pipes, etc.
505 EXECUTION_SUCCESS or EXECUTION_FAILURE are the only possible
506 return values. Executing a command with nothing in it returns
507 EXECUTION_SUCCESS. */
509 execute_command_internal (command, asynchronous, pipe_in, pipe_out,
513 int pipe_in, pipe_out;
514 struct fd_bitmap *fds_to_close;
516 int exec_result, user_subshell, invert, ignore_return, was_error_trap;
517 REDIRECT *my_undo_list, *exec_undo_list;
518 volatile int last_pid;
519 volatile int save_line_number;
522 if (command == 0 || breaking || continuing || read_but_dont_execute)
523 return (EXECUTION_SUCCESS);
525 if (breaking || continuing)
526 return (last_command_exit_value);
527 if (command == 0 || read_but_dont_execute)
528 return (EXECUTION_SUCCESS);
532 run_pending_traps ();
535 if (running_trap == 0)
537 currently_executing_command = command;
539 invert = (command->flags & CMD_INVERT_RETURN) != 0;
541 /* If we're inverting the return value and `set -e' has been executed,
542 we don't want a failing command to inadvertently cause the shell
544 if (exit_immediately_on_error && invert) /* XXX */
545 command->flags |= CMD_IGNORE_RETURN; /* XXX */
547 exec_result = EXECUTION_SUCCESS;
549 /* If a command was being explicitly run in a subshell, or if it is
550 a shell control-structure, and it has a pipe, then we do the command
552 if (command->type == cm_subshell && (command->flags & CMD_NO_FORK))
553 return (execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close));
555 #if defined (COPROCESS_SUPPORT)
556 if (command->type == cm_coproc)
557 return (execute_coproc (command, pipe_in, pipe_out, fds_to_close));
560 user_subshell = command->type == cm_subshell || ((command->flags & CMD_WANT_SUBSHELL) != 0);
562 if (command->type == cm_subshell ||
563 (command->flags & (CMD_WANT_SUBSHELL|CMD_FORCE_SUBSHELL)) ||
564 (shell_control_structure (command->type) &&
565 (pipe_out != NO_PIPE || pipe_in != NO_PIPE || asynchronous)))
569 /* Fork a subshell, turn off the subshell bit, turn off job
570 control and call execute_command () on the command again. */
571 line_number_for_err_trap = line_number;
572 paren_pid = make_child (savestring (make_command_string (command)),
575 exit (execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close));
579 close_pipes (pipe_in, pipe_out);
581 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
584 /* If we are part of a pipeline, and not the end of the pipeline,
585 then we should simply return and let the last command in the
586 pipe be waited for. If we are not in a pipeline, or are the
587 last command in the pipeline, then we wait for the subshell
588 and return its exit status as usual. */
589 if (pipe_out != NO_PIPE)
590 return (EXECUTION_SUCCESS);
592 stop_pipeline (asynchronous, (COMMAND *)NULL);
594 if (asynchronous == 0)
596 was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
597 invert = (command->flags & CMD_INVERT_RETURN) != 0;
598 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
600 last_command_exit_value = wait_for (paren_pid);
602 /* If we have to, invert the return value. */
604 exec_result = ((last_command_exit_value == EXECUTION_SUCCESS)
606 : EXECUTION_SUCCESS);
608 exec_result = last_command_exit_value;
611 if (user_subshell && was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
613 last_command_exit_value = exec_result;
614 save_line_number = line_number;
615 line_number = line_number_for_err_trap;
617 line_number = save_line_number;
620 if (user_subshell && ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
622 last_command_exit_value = exec_result;
623 run_pending_traps ();
624 jump_to_top_level (ERREXIT);
627 return (last_command_exit_value = exec_result);
631 DESCRIBE_PID (paren_pid);
633 run_pending_traps ();
635 return (EXECUTION_SUCCESS);
640 #if defined (COMMAND_TIMING)
641 if (command->flags & CMD_TIME_PIPELINE)
645 command->flags |= CMD_FORCE_SUBSHELL;
646 exec_result = execute_command_internal (command, 1, pipe_in, pipe_out, fds_to_close);
650 exec_result = time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close);
652 if (running_trap == 0)
654 currently_executing_command = (COMMAND *)NULL;
656 return (exec_result);
658 #endif /* COMMAND_TIMING */
660 if (shell_control_structure (command->type) && command->redirects)
661 stdin_redir = stdin_redirects (command->redirects);
663 /* Handle WHILE FOR CASE etc. with redirections. (Also '&' input
665 if (do_redirections (command->redirects, RX_ACTIVE|RX_UNDOABLE) != 0)
667 cleanup_redirects (redirection_undo_list);
668 redirection_undo_list = (REDIRECT *)NULL;
669 dispose_exec_redirects ();
670 return (last_command_exit_value = EXECUTION_FAILURE);
673 if (redirection_undo_list)
675 my_undo_list = (REDIRECT *)copy_redirects (redirection_undo_list);
676 dispose_redirects (redirection_undo_list);
677 redirection_undo_list = (REDIRECT *)NULL;
680 my_undo_list = (REDIRECT *)NULL;
682 if (exec_redirection_undo_list)
684 exec_undo_list = (REDIRECT *)copy_redirects (exec_redirection_undo_list);
685 dispose_redirects (exec_redirection_undo_list);
686 exec_redirection_undo_list = (REDIRECT *)NULL;
689 exec_undo_list = (REDIRECT *)NULL;
691 if (my_undo_list || exec_undo_list)
692 begin_unwind_frame ("loop_redirections");
695 add_unwind_protect ((Function *)cleanup_redirects, my_undo_list);
698 add_unwind_protect ((Function *)dispose_redirects, exec_undo_list);
700 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
704 switch (command->type)
708 save_line_number = line_number;
709 /* We can't rely on variables retaining their values across a
710 call to execute_simple_command if a longjmp occurs as the
711 result of a `return' builtin. This is true for sure with gcc. */
712 #if defined (RECYCLES_PIDS)
713 last_made_pid = NO_PID;
715 last_pid = last_made_pid;
716 was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
718 if (ignore_return && command->value.Simple)
719 command->value.Simple->flags |= CMD_IGNORE_RETURN;
720 if (command->flags & CMD_STDIN_REDIR)
721 command->value.Simple->flags |= CMD_STDIN_REDIR;
723 line_number_for_err_trap = line_number = command->value.Simple->line;
725 execute_simple_command (command->value.Simple, pipe_in, pipe_out,
726 asynchronous, fds_to_close);
727 line_number = save_line_number;
729 /* The temporary environment should be used for only the simple
730 command immediately following its definition. */
731 dispose_used_env_vars ();
733 #if (defined (ultrix) && defined (mips)) || defined (C_ALLOCA)
734 /* Reclaim memory allocated with alloca () on machines which
735 may be using the alloca emulation code. */
737 #endif /* (ultrix && mips) || C_ALLOCA */
739 /* If we forked to do the command, then we must wait_for ()
742 /* XXX - this is something to watch out for if there are problems
743 when the shell is compiled without job control. */
744 if (already_making_children && pipe_out == NO_PIPE &&
745 last_made_pid != last_pid)
747 stop_pipeline (asynchronous, (COMMAND *)NULL);
751 DESCRIBE_PID (last_made_pid);
754 #if !defined (JOB_CONTROL)
755 /* Do not wait for asynchronous processes started from
757 if (last_made_pid != last_asynchronous_pid)
759 /* When executing a shell function that executes other
760 commands, this causes the last simple command in
761 the function to be waited for twice. This also causes
762 subshells forked to execute builtin commands (e.g., in
763 pipelines) to be waited for twice. */
764 exec_result = wait_for (last_made_pid);
768 /* 2009/02/13 -- pipeline failure is processed elsewhere. This handles
769 only the failure of a simple command. */
770 if (was_error_trap && ignore_return == 0 && invert == 0 && pipe_in == NO_PIPE && pipe_out == NO_PIPE && exec_result != EXECUTION_SUCCESS)
772 last_command_exit_value = exec_result;
773 line_number = line_number_for_err_trap;
775 line_number = save_line_number;
778 if (ignore_return == 0 && invert == 0 &&
779 ((posixly_correct && interactive == 0 && special_builtin_failed) ||
780 (exit_immediately_on_error && pipe_in == NO_PIPE && pipe_out == NO_PIPE && exec_result != EXECUTION_SUCCESS)))
782 last_command_exit_value = exec_result;
783 run_pending_traps ();
784 jump_to_top_level (ERREXIT);
791 command->value.For->flags |= CMD_IGNORE_RETURN;
792 exec_result = execute_for_command (command->value.For);
795 #if defined (ARITH_FOR_COMMAND)
798 command->value.ArithFor->flags |= CMD_IGNORE_RETURN;
799 exec_result = execute_arith_for_command (command->value.ArithFor);
803 #if defined (SELECT_COMMAND)
806 command->value.Select->flags |= CMD_IGNORE_RETURN;
807 exec_result = execute_select_command (command->value.Select);
813 command->value.Case->flags |= CMD_IGNORE_RETURN;
814 exec_result = execute_case_command (command->value.Case);
819 command->value.While->flags |= CMD_IGNORE_RETURN;
820 exec_result = execute_while_command (command->value.While);
825 command->value.While->flags |= CMD_IGNORE_RETURN;
826 exec_result = execute_until_command (command->value.While);
831 command->value.If->flags |= CMD_IGNORE_RETURN;
832 exec_result = execute_if_command (command->value.If);
837 /* This code can be executed from either of two paths: an explicit
838 '{}' command, or via a function call. If we are executed via a
839 function call, we have already taken care of the function being
840 executed in the background (down there in execute_simple_command ()),
841 and this command should *not* be marked as asynchronous. If we
842 are executing a regular '{}' group command, and asynchronous == 1,
843 we must want to execute the whole command in the background, so we
844 need a subshell, and we want the stuff executed in that subshell
845 (this group command) to be executed in the foreground of that
846 subshell (i.e. there will not be *another* subshell forked).
848 What we do is to force a subshell if asynchronous, and then call
849 execute_command_internal again with asynchronous still set to 1,
850 but with the original group command, so the printed command will
853 The code above that handles forking off subshells will note that
854 both subshell and async are on, and turn off async in the child
855 after forking the subshell (but leave async set in the parent, so
856 the normal call to describe_pid is made). This turning off
857 async is *crucial*; if it is not done, this will fall into an
858 infinite loop of executions through this spot in subshell after
859 subshell until the process limit is exhausted. */
863 command->flags |= CMD_FORCE_SUBSHELL;
865 execute_command_internal (command, 1, pipe_in, pipe_out,
870 if (ignore_return && command->value.Group->command)
871 command->value.Group->command->flags |= CMD_IGNORE_RETURN;
873 execute_command_internal (command->value.Group->command,
874 asynchronous, pipe_in, pipe_out,
880 exec_result = execute_connection (command, asynchronous,
881 pipe_in, pipe_out, fds_to_close);
884 #if defined (DPAREN_ARITHMETIC)
887 command->value.Arith->flags |= CMD_IGNORE_RETURN;
888 exec_result = execute_arith_command (command->value.Arith);
892 #if defined (COND_COMMAND)
895 command->value.Cond->flags |= CMD_IGNORE_RETURN;
896 save_line_number = line_number;
897 exec_result = execute_cond_command (command->value.Cond);
898 line_number = save_line_number;
902 case cm_function_def:
903 exec_result = execute_intern_function (command->value.Function_def->name,
904 command->value.Function_def->command);
908 command_error ("execute_command", CMDERR_BADTYPE, command->type, 0);
913 do_redirections (my_undo_list, RX_ACTIVE);
914 dispose_redirects (my_undo_list);
918 dispose_redirects (exec_undo_list);
920 if (my_undo_list || exec_undo_list)
921 discard_unwind_frame ("loop_redirections");
923 /* Invert the return value if we have to */
925 exec_result = (exec_result == EXECUTION_SUCCESS)
929 #if defined (DPAREN_ARITHMETIC) || defined (COND_COMMAND)
930 /* This is where we set PIPESTATUS from the exit status of the appropriate
931 compound commands (the ones that look enough like simple commands to
932 cause confusion). We might be able to optimize by not doing this if
933 subshell_environment != 0. */
934 switch (command->type)
936 # if defined (DPAREN_ARITHMETIC)
939 # if defined (COND_COMMAND)
942 set_pipestatus_from_exit (exec_result);
947 last_command_exit_value = exec_result;
948 run_pending_traps ();
950 if (running_trap == 0)
952 currently_executing_command = (COMMAND *)NULL;
953 return (last_command_exit_value);
956 #if defined (COMMAND_TIMING)
958 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
959 extern struct timeval *difftimeval __P((struct timeval *, struct timeval *, struct timeval *));
960 extern struct timeval *addtimeval __P((struct timeval *, struct timeval *, struct timeval *));
961 extern int timeval_to_cpu __P((struct timeval *, struct timeval *, struct timeval *));
964 #define POSIX_TIMEFORMAT "real %2R\nuser %2U\nsys %2S"
965 #define BASH_TIMEFORMAT "\nreal\t%3lR\nuser\t%3lU\nsys\t%3lS"
967 static const int precs[] = { 0, 100, 10, 1 };
969 /* Expand one `%'-prefixed escape sequence from a time format string. */
971 mkfmt (buf, prec, lng, sec, sec_fraction)
978 char abuf[INT_STRLEN_BOUND(time_t) + 1];
982 abuf[sizeof(abuf) - 1] = '\0';
984 /* If LNG is non-zero, we want to decompose SEC into minutes and seconds. */
989 aind = sizeof(abuf) - 2;
991 abuf[aind--] = (min % 10) + '0';
995 buf[ind++] = abuf[aind++];
999 /* Now add the seconds. */
1000 aind = sizeof (abuf) - 2;
1002 abuf[aind--] = (sec % 10) + '0';
1006 buf[ind++] = abuf[aind++];
1008 /* We want to add a decimal point and PREC places after it if PREC is
1009 nonzero. PREC is not greater than 3. SEC_FRACTION is between 0
1014 for (aind = 1; aind <= prec; aind++)
1016 buf[ind++] = (sec_fraction / precs[aind]) + '0';
1017 sec_fraction %= precs[aind];
1028 /* Interpret the format string FORMAT, interpolating the following escape
1032 where the optional `prec' is a precision, meaning the number of
1033 characters after the decimal point, the optional `l' means to format
1034 using minutes and seconds (MMmNN[.FF]s), like the `times' builtin',
1035 and the last character is one of
1037 R number of seconds of `real' time
1038 U number of seconds of `user' time
1039 S number of seconds of `system' time
1041 An occurrence of `%%' in the format string is translated to a `%'. The
1042 result is printed to FP, a pointer to a FILE. The other variables are
1043 the seconds and thousandths of a second of real, user, and system time,
1046 print_formatted_time (fp, format, rs, rsf, us, usf, ss, ssf, cpu)
1057 char *str, *s, ts[INT_STRLEN_BOUND (time_t) + sizeof ("mSS.FFFF")];
1062 len = strlen (format);
1063 ssize = (len + 64) - (len % 64);
1064 str = (char *)xmalloc (ssize);
1067 for (s = format; *s; s++)
1069 if (*s != '%' || s[1] == '\0')
1071 RESIZE_MALLOCED_BUFFER (str, sindex, 1, ssize, 64);
1074 else if (s[1] == '%')
1077 RESIZE_MALLOCED_BUFFER (str, sindex, 1, ssize, 64);
1080 else if (s[1] == 'P')
1084 /* clamp CPU usage at 100% */
1089 sum_frac = (cpu % 100) * 10;
1090 len = mkfmt (ts, 2, 0, sum, sum_frac);
1091 RESIZE_MALLOCED_BUFFER (str, sindex, len, ssize, 64);
1092 strcpy (str + sindex, ts);
1097 prec = 3; /* default is three places past the decimal point. */
1098 lng = 0; /* default is to not use minutes or append `s' */
1100 if (DIGIT (*s)) /* `precision' */
1103 if (prec > 3) prec = 3;
1105 if (*s == 'l') /* `length extender' */
1110 if (*s == 'R' || *s == 'E')
1111 len = mkfmt (ts, prec, lng, rs, rsf);
1113 len = mkfmt (ts, prec, lng, us, usf);
1115 len = mkfmt (ts, prec, lng, ss, ssf);
1118 internal_error (_("TIMEFORMAT: `%c': invalid format character"), *s);
1122 RESIZE_MALLOCED_BUFFER (str, sindex, len, ssize, 64);
1123 strcpy (str + sindex, ts);
1129 fprintf (fp, "%s\n", str);
1136 time_command (command, asynchronous, pipe_in, pipe_out, fds_to_close)
1138 int asynchronous, pipe_in, pipe_out;
1139 struct fd_bitmap *fds_to_close;
1141 int rv, posix_time, old_flags;
1147 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1148 struct timeval real, user, sys;
1149 struct timeval before, after;
1150 # if defined (HAVE_STRUCT_TIMEZONE)
1151 struct timezone dtz; /* posix doesn't define this */
1153 struct rusage selfb, selfa, kidsb, kidsa; /* a = after, b = before */
1155 # if defined (HAVE_TIMES)
1156 clock_t tbefore, tafter, real, user, sys;
1157 struct tms before, after;
1161 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1162 # if defined (HAVE_STRUCT_TIMEZONE)
1163 gettimeofday (&before, &dtz);
1165 gettimeofday (&before, (void *)NULL);
1166 # endif /* !HAVE_STRUCT_TIMEZONE */
1167 getrusage (RUSAGE_SELF, &selfb);
1168 getrusage (RUSAGE_CHILDREN, &kidsb);
1170 # if defined (HAVE_TIMES)
1171 tbefore = times (&before);
1175 posix_time = (command->flags & CMD_TIME_POSIX);
1177 old_flags = command->flags;
1178 command->flags &= ~(CMD_TIME_PIPELINE|CMD_TIME_POSIX);
1179 rv = execute_command_internal (command, asynchronous, pipe_in, pipe_out, fds_to_close);
1180 command->flags = old_flags;
1183 rsf = usf = ssf = cpu = 0;
1185 #if defined (HAVE_GETRUSAGE) && defined (HAVE_GETTIMEOFDAY)
1186 # if defined (HAVE_STRUCT_TIMEZONE)
1187 gettimeofday (&after, &dtz);
1189 gettimeofday (&after, (void *)NULL);
1190 # endif /* !HAVE_STRUCT_TIMEZONE */
1191 getrusage (RUSAGE_SELF, &selfa);
1192 getrusage (RUSAGE_CHILDREN, &kidsa);
1194 difftimeval (&real, &before, &after);
1195 timeval_to_secs (&real, &rs, &rsf);
1197 addtimeval (&user, difftimeval(&after, &selfb.ru_utime, &selfa.ru_utime),
1198 difftimeval(&before, &kidsb.ru_utime, &kidsa.ru_utime));
1199 timeval_to_secs (&user, &us, &usf);
1201 addtimeval (&sys, difftimeval(&after, &selfb.ru_stime, &selfa.ru_stime),
1202 difftimeval(&before, &kidsb.ru_stime, &kidsa.ru_stime));
1203 timeval_to_secs (&sys, &ss, &ssf);
1205 cpu = timeval_to_cpu (&real, &user, &sys);
1207 # if defined (HAVE_TIMES)
1208 tafter = times (&after);
1210 real = tafter - tbefore;
1211 clock_t_to_secs (real, &rs, &rsf);
1213 user = (after.tms_utime - before.tms_utime) + (after.tms_cutime - before.tms_cutime);
1214 clock_t_to_secs (user, &us, &usf);
1216 sys = (after.tms_stime - before.tms_stime) + (after.tms_cstime - before.tms_cstime);
1217 clock_t_to_secs (sys, &ss, &ssf);
1219 cpu = (real == 0) ? 0 : ((user + sys) * 10000) / real;
1223 rsf = usf = ssf = cpu = 0;
1228 time_format = POSIX_TIMEFORMAT;
1229 else if ((time_format = get_string_value ("TIMEFORMAT")) == 0)
1230 time_format = BASH_TIMEFORMAT;
1232 if (time_format && *time_format)
1233 print_formatted_time (stderr, time_format, rs, rsf, us, usf, ss, ssf, cpu);
1237 #endif /* COMMAND_TIMING */
1239 /* Execute a command that's supposed to be in a subshell. This must be
1240 called after make_child and we must be running in the child process.
1241 The caller will return or exit() immediately with the value this returns. */
1243 execute_in_subshell (command, asynchronous, pipe_in, pipe_out, fds_to_close)
1246 int pipe_in, pipe_out;
1247 struct fd_bitmap *fds_to_close;
1249 int user_subshell, return_code, function_value, should_redir_stdin, invert;
1250 int ois, user_coproc;
1253 USE_VAR(user_subshell);
1254 USE_VAR(user_coproc);
1257 USE_VAR(asynchronous);
1260 should_redir_stdin = (asynchronous && (command->flags & CMD_STDIN_REDIR) &&
1261 pipe_in == NO_PIPE &&
1262 stdin_redirects (command->redirects) == 0);
1264 invert = (command->flags & CMD_INVERT_RETURN) != 0;
1265 user_subshell = command->type == cm_subshell || ((command->flags & CMD_WANT_SUBSHELL) != 0);
1266 user_coproc = command->type == cm_coproc;
1268 command->flags &= ~(CMD_FORCE_SUBSHELL | CMD_WANT_SUBSHELL | CMD_INVERT_RETURN);
1270 /* If a command is asynchronous in a subshell (like ( foo ) & or
1271 the special case of an asynchronous GROUP command where the
1272 the subshell bit is turned on down in case cm_group: below),
1273 turn off `asynchronous', so that two subshells aren't spawned.
1274 XXX - asynchronous used to be set to 0 in this block, but that
1275 means that setup_async_signals was never run. Now it's set to
1276 0 after subshell_environment is set appropriately and setup_async_signals
1279 This seems semantically correct to me. For example,
1280 ( foo ) & seems to say ``do the command `foo' in a subshell
1281 environment, but don't wait for that subshell to finish'',
1282 and "{ foo ; bar ; } &" seems to me to be like functions or
1283 builtins in the background, which executed in a subshell
1284 environment. I just don't see the need to fork two subshells. */
1286 /* Don't fork again, we are already in a subshell. A `doubly
1287 async' shell is not interactive, however. */
1290 #if defined (JOB_CONTROL)
1291 /* If a construct like ( exec xxx yyy ) & is given while job
1292 control is active, we want to prevent exec from putting the
1293 subshell back into the original process group, carefully
1294 undoing all the work we just did in make_child. */
1296 #endif /* JOB_CONTROL */
1297 ois = interactive_shell;
1298 interactive_shell = 0;
1299 /* This test is to prevent alias expansion by interactive shells that
1300 run `(command) &' but to allow scripts that have enabled alias
1301 expansion with `shopt -s expand_alias' to continue to expand
1303 if (ois != interactive_shell)
1307 /* Subshells are neither login nor interactive. */
1308 login_shell = interactive = 0;
1311 subshell_environment = SUBSHELL_PAREN;
1314 subshell_environment = 0; /* XXX */
1316 subshell_environment |= SUBSHELL_ASYNC;
1317 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
1318 subshell_environment |= SUBSHELL_PIPE;
1320 subshell_environment |= SUBSHELL_COPROC;
1323 reset_terminating_signals (); /* in sig.c */
1324 /* Cancel traps, in trap.c. */
1325 restore_original_signals ();
1327 /* Make sure restore_original_signals doesn't undo the work done by
1328 make_child to ensure that asynchronous children are immune to SIGINT
1329 and SIGQUIT. Turn off asynchronous to make sure more subshells are
1333 setup_async_signals ();
1337 #if defined (JOB_CONTROL)
1338 set_sigchld_handler ();
1339 #endif /* JOB_CONTROL */
1341 set_sigint_handler ();
1343 #if defined (JOB_CONTROL)
1344 /* Delete all traces that there were any jobs running. This is
1345 only for subshells. */
1346 without_job_control ();
1347 #endif /* JOB_CONTROL */
1350 close_fd_bitmap (fds_to_close);
1352 do_piping (pipe_in, pipe_out);
1354 #if defined (COPROCESS_SUPPORT)
1358 /* If this is a user subshell, set a flag if stdin was redirected.
1359 This is used later to decide whether to redirect fd 0 to
1360 /dev/null for async commands in the subshell. This adds more
1361 sh compatibility, but I'm not sure it's the right thing to do. */
1364 stdin_redir = stdin_redirects (command->redirects);
1365 restore_default_signal (0);
1368 /* If this is an asynchronous command (command &), we want to
1369 redirect the standard input from /dev/null in the absence of
1370 any specific redirection involving stdin. */
1371 if (should_redir_stdin && stdin_redir == 0)
1372 async_redirect_stdin ();
1374 /* Do redirections, then dispose of them before recursive call. */
1375 if (command->redirects)
1377 if (do_redirections (command->redirects, RX_ACTIVE) != 0)
1378 exit (invert ? EXECUTION_SUCCESS : EXECUTION_FAILURE);
1380 dispose_redirects (command->redirects);
1381 command->redirects = (REDIRECT *)NULL;
1384 if (command->type == cm_subshell)
1385 tcom = command->value.Subshell->command;
1386 else if (user_coproc)
1387 tcom = command->value.Coproc->command;
1391 if (command->flags & CMD_TIME_PIPELINE)
1392 tcom->flags |= CMD_TIME_PIPELINE;
1393 if (command->flags & CMD_TIME_POSIX)
1394 tcom->flags |= CMD_TIME_POSIX;
1396 /* Make sure the subshell inherits any CMD_IGNORE_RETURN flag. */
1397 if ((command->flags & CMD_IGNORE_RETURN) && tcom != command)
1398 tcom->flags |= CMD_IGNORE_RETURN;
1400 /* If this is a simple command, tell execute_disk_command that it
1401 might be able to get away without forking and simply exec.
1402 This means things like ( sleep 10 ) will only cause one fork.
1403 If we're timing the command or inverting its return value, however,
1404 we cannot do this optimization. */
1405 if ((user_subshell || user_coproc) && (tcom->type == cm_simple || tcom->type == cm_subshell) &&
1406 ((tcom->flags & CMD_TIME_PIPELINE) == 0) &&
1407 ((tcom->flags & CMD_INVERT_RETURN) == 0))
1409 tcom->flags |= CMD_NO_FORK;
1410 if (tcom->type == cm_simple)
1411 tcom->value.Simple->flags |= CMD_NO_FORK;
1414 invert = (tcom->flags & CMD_INVERT_RETURN) != 0;
1415 tcom->flags &= ~CMD_INVERT_RETURN;
1417 /* If we're inside a function while executing this subshell, we
1418 need to handle a possible `return'. */
1420 if (return_catch_flag)
1421 function_value = setjmp (return_catch);
1424 return_code = return_catch_value;
1426 return_code = execute_command_internal (tcom, asynchronous, NO_PIPE, NO_PIPE, fds_to_close);
1428 /* If we are asked to, invert the return value. */
1430 return_code = (return_code == EXECUTION_SUCCESS) ? EXECUTION_FAILURE
1431 : EXECUTION_SUCCESS;
1433 /* If we were explicitly placed in a subshell with (), we need
1434 to do the `shell cleanup' things, such as running traps[0]. */
1435 if (user_subshell && signal_is_trapped (0))
1437 last_command_exit_value = return_code;
1438 return_code = run_exit_trap ();
1442 return (return_code);
1446 #if defined (COPROCESS_SUPPORT)
1447 #define COPROC_MAX 16
1449 typedef struct cpelement
1451 struct cpelement *next;
1452 struct coproc *coproc;
1456 typedef struct cplist
1458 struct cpelement *head;
1459 struct cpelement *tail;
1464 static struct cpelement *cpe_alloc __P((struct coproc *));
1465 static void cpe_dispose __P((struct cpelement *));
1466 static struct cpelement *cpl_add __P((struct coproc *));
1467 static struct cpelement *cpl_delete __P((pid_t));
1468 static void cpl_reap __P((void));
1469 static void cpl_flush __P((void));
1470 static struct cpelement *cpl_search __P((pid_t));
1471 static struct cpelement *cpl_searchbyname __P((char *));
1472 static void cpl_prune __P((void));
1474 Coproc sh_coproc = { 0, NO_PID, -1, -1, 0, 0 };
1476 cplist_t coproc_list = {0, 0, 0};
1478 /* Functions to manage the list of coprocs */
1480 static struct cpelement *
1484 struct cpelement *cpe;
1486 cpe = (struct cpelement *)xmalloc (sizeof (struct cpelement));
1488 cpe->next = (struct cpelement *)0;
1494 struct cpelement *cpe;
1499 static struct cpelement *
1503 struct cpelement *cpe;
1505 cpe = cpe_alloc (cp);
1507 if (coproc_list.head == 0)
1509 coproc_list.head = coproc_list.tail = cpe;
1510 coproc_list.ncoproc = 0; /* just to make sure */
1514 coproc_list.tail->next = cpe;
1515 coproc_list.tail = cpe;
1517 coproc_list.ncoproc++;
1522 static struct cpelement *
1526 struct cpelement *prev, *p;
1528 for (prev = p = coproc_list.head; p; prev = p, p = p->next)
1529 if (p->coproc->c_pid == pid)
1531 prev->next = p->next; /* remove from list */
1536 return 0; /* not found */
1539 itrace("cpl_delete: deleting %d", pid);
1542 /* Housekeeping in the border cases. */
1543 if (p == coproc_list.head)
1544 coproc_list.head = coproc_list.head->next;
1545 else if (p == coproc_list.tail)
1546 coproc_list.tail = prev;
1548 coproc_list.ncoproc--;
1549 if (coproc_list.ncoproc == 0)
1550 coproc_list.head = coproc_list.tail = 0;
1551 else if (coproc_list.ncoproc == 1)
1552 coproc_list.tail = coproc_list.head; /* just to make sure */
1560 struct cpelement *prev, *p;
1562 for (prev = p = coproc_list.head; p; prev = p, p = p->next)
1563 if (p->coproc->c_flags & COPROC_DEAD)
1565 prev->next = p->next; /* remove from list */
1567 /* Housekeeping in the border cases. */
1568 if (p == coproc_list.head)
1569 coproc_list.head = coproc_list.head->next;
1570 else if (p == coproc_list.tail)
1571 coproc_list.tail = prev;
1573 coproc_list.ncoproc--;
1574 if (coproc_list.ncoproc == 0)
1575 coproc_list.head = coproc_list.tail = 0;
1576 else if (coproc_list.ncoproc == 1)
1577 coproc_list.tail = coproc_list.head; /* just to make sure */
1580 itrace("cpl_reap: deleting %d", p->coproc->c_pid);
1583 coproc_dispose (p->coproc);
1588 /* Clear out the list of saved statuses */
1592 struct cpelement *cpe, *p;
1594 for (cpe = coproc_list.head; cpe; )
1599 coproc_dispose (p->coproc);
1603 coproc_list.head = coproc_list.tail = 0;
1604 coproc_list.ncoproc = 0;
1607 /* Search for PID in the list of coprocs; return the cpelement struct if
1608 found. If not found, return NULL. */
1609 static struct cpelement *
1613 struct cpelement *cp;
1615 for (cp = coproc_list.head ; cp; cp = cp->next)
1616 if (cp->coproc->c_pid == pid)
1618 return (struct cpelement *)NULL;
1621 /* Search for the coproc named NAME in the list of coprocs; return the
1622 cpelement struct if found. If not found, return NULL. */
1623 static struct cpelement *
1624 cpl_searchbyname (name)
1627 struct cpelement *cp;
1629 for (cp = coproc_list.head ; cp; cp = cp->next)
1630 if (STREQ (cp->coproc->c_name, name))
1632 return (struct cpelement *)NULL;
1639 struct cpelement *cp;
1641 while (coproc_list.head && coproc_list.ncoproc > COPROC_MAX)
1643 cp = coproc_list.head;
1644 coproc_list.head = coproc_list.head->next;
1645 coproc_dispose (cp->coproc);
1647 coproc_list.ncoproc--;
1652 /* These currently use a single global "shell coproc" but are written in a
1653 way to not preclude additional coprocs later (using the list management
1657 getcoprocbypid (pid)
1660 return (pid == sh_coproc.c_pid ? &sh_coproc : 0);
1664 getcoprocbyname (name)
1667 return ((sh_coproc.c_name && STREQ (sh_coproc.c_name, name)) ? &sh_coproc : 0);
1676 cp->c_rfd = cp->c_wfd = -1;
1677 cp->c_rsave = cp->c_wsave = -1;
1678 cp->c_flags = cp->c_status = 0;
1682 coproc_alloc (name, pid)
1688 cp = &sh_coproc; /* XXX */
1691 cp->c_name = savestring (name);
1704 coproc_unsetvars (cp);
1710 /* Placeholder for now. */
1714 coproc_dispose (&sh_coproc);
1731 cp->c_rsave = cp->c_wsave = -1;
1737 coproc_close (&sh_coproc);
1746 if (cp && (cp->c_flags & COPROC_DEAD))
1747 coproc_dispose (cp);
1751 coproc_rclose (cp, fd)
1755 if (cp->c_rfd >= 0 && cp->c_rfd == fd)
1763 coproc_wclose (cp, fd)
1767 if (cp->c_wfd >= 0 && cp->c_wfd == fd)
1775 coproc_checkfd (cp, fd)
1782 if (cp->c_rfd >= 0 && cp->c_rfd == fd)
1783 update = cp->c_rfd = -1;
1784 if (cp->c_wfd >= 0 && cp->c_wfd == fd)
1785 update = cp->c_wfd = -1;
1787 coproc_setvars (cp);
1794 coproc_checkfd (&sh_coproc, fd);
1798 coproc_fdclose (cp, fd)
1802 coproc_rclose (cp, fd);
1803 coproc_wclose (cp, fd);
1804 coproc_setvars (cp);
1811 cp->c_rsave = cp->c_rfd;
1812 cp->c_wsave = cp->c_wfd;
1816 coproc_fdrestore (cp)
1819 cp->c_rfd = cp->c_rsave;
1820 cp->c_wfd = cp->c_wsave;
1824 coproc_pidchk (pid, status)
1829 cp = getcoprocbypid (pid);
1832 itrace("coproc_pidchk: pid %d has died", pid);
1836 cp->c_status = status;
1837 cp->c_flags |= COPROC_DEAD;
1838 cp->c_flags &= ~COPROC_RUNNING;
1840 coproc_dispose (cp);
1852 #if defined (ARRAY_VARS)
1856 if (cp->c_name == 0)
1859 l = strlen (cp->c_name);
1860 namevar = xmalloc (l + 16);
1862 #if defined (ARRAY_VARS)
1863 v = find_variable (cp->c_name);
1865 v = make_new_array_variable (cp->c_name);
1866 if (array_p (v) == 0)
1867 v = convert_var_to_array (v);
1869 t = itos (cp->c_rfd);
1871 v = bind_array_variable (cp->c_name, ind, t, 0);
1874 t = itos (cp->c_wfd);
1876 bind_array_variable (cp->c_name, ind, t, 0);
1879 sprintf (namevar, "%s_READ", cp->c_name);
1880 t = itos (cp->c_rfd);
1881 bind_variable (namevar, t, 0);
1883 sprintf (namevar, "%s_WRITE", cp->c_name);
1884 t = itos (cp->c_wfd);
1885 bind_variable (namevar, t, 0);
1889 sprintf (namevar, "%s_PID", cp->c_name);
1890 t = itos (cp->c_pid);
1891 bind_variable (namevar, t, 0);
1898 coproc_unsetvars (cp)
1904 if (cp->c_name == 0)
1907 l = strlen (cp->c_name);
1908 namevar = xmalloc (l + 16);
1910 sprintf (namevar, "%s_PID", cp->c_name);
1911 unbind_variable (namevar);
1913 #if defined (ARRAY_VARS)
1914 unbind_variable (cp->c_name);
1916 sprintf (namevar, "%s_READ", cp->c_name);
1917 unbind_variable (namevar);
1918 sprintf (namevar, "%s_WRITE", cp->c_name);
1919 unbind_variable (namevar);
1926 execute_coproc (command, pipe_in, pipe_out, fds_to_close)
1928 int pipe_in, pipe_out;
1929 struct fd_bitmap *fds_to_close;
1931 int rpipe[2], wpipe[2];
1936 /* XXX -- will require changes to handle multiple coprocs */
1937 if (sh_coproc.c_pid != NO_PID)
1940 internal_error ("execute_coproc: coproc [%d:%s] already exists", sh_coproc.c_pid, sh_coproc.c_name);
1941 return (last_command_exit_value = EXECUTION_FAILURE);
1943 internal_warning ("execute_coproc: coproc [%d:%s] still exists", sh_coproc.c_pid, sh_coproc.c_name);
1946 coproc_init (&sh_coproc);
1948 command_string_index = 0;
1949 tcmd = make_command_string (command);
1951 sh_openpipe ((int *)&rpipe); /* 0 = parent read, 1 = child write */
1952 sh_openpipe ((int *)&wpipe); /* 0 = child read, 1 = parent write */
1954 coproc_pid = make_child (savestring (tcmd), 1);
1955 if (coproc_pid == 0)
1960 exit (execute_in_subshell (command, 1, wpipe[0], rpipe[1], fds_to_close));
1966 cp = coproc_alloc (command->value.Coproc->name, coproc_pid);
1967 cp->c_rfd = rpipe[0];
1968 cp->c_wfd = wpipe[1];
1970 SET_CLOSE_ON_EXEC (cp->c_rfd);
1971 SET_CLOSE_ON_EXEC (cp->c_wfd);
1973 coproc_setvars (cp);
1976 itrace ("execute_coproc: [%d] %s", coproc_pid, the_printed_command);
1979 close_pipes (pipe_in, pipe_out);
1980 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
1981 unlink_fifo_list ();
1983 stop_pipeline (1, (COMMAND *)NULL);
1984 DESCRIBE_PID (coproc_pid);
1985 run_pending_traps ();
1987 return (EXECUTION_SUCCESS);
1992 execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close)
1994 int asynchronous, pipe_in, pipe_out;
1995 struct fd_bitmap *fds_to_close;
1997 int prev, fildes[2], new_bitmap_size, dummyfd, ignore_return, exec_result;
1999 struct fd_bitmap *fd_bitmap;
2001 #if defined (JOB_CONTROL)
2003 BLOCK_CHILD (set, oset);
2004 #endif /* JOB_CONTROL */
2006 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
2011 while (cmd && cmd->type == cm_connection &&
2012 cmd->value.Connection && cmd->value.Connection->connector == '|')
2014 /* Make a pipeline between the two commands. */
2015 if (pipe (fildes) < 0)
2017 sys_error (_("pipe error"));
2018 #if defined (JOB_CONTROL)
2019 terminate_current_pipeline ();
2020 kill_current_pipeline ();
2021 UNBLOCK_CHILD (oset);
2022 #endif /* JOB_CONTROL */
2023 last_command_exit_value = EXECUTION_FAILURE;
2024 /* The unwind-protects installed below will take care
2025 of closing all of the open file descriptors. */
2026 throw_to_top_level ();
2027 return (EXECUTION_FAILURE); /* XXX */
2030 /* Here is a problem: with the new file close-on-exec
2031 code, the read end of the pipe (fildes[0]) stays open
2032 in the first process, so that process will never get a
2033 SIGPIPE. There is no way to signal the first process
2034 that it should close fildes[0] after forking, so it
2035 remains open. No SIGPIPE is ever sent because there
2036 is still a file descriptor open for reading connected
2037 to the pipe. We take care of that here. This passes
2038 around a bitmap of file descriptors that must be
2039 closed after making a child process in execute_simple_command. */
2041 /* We need fd_bitmap to be at least as big as fildes[0].
2042 If fildes[0] is less than fds_to_close->size, then
2043 use fds_to_close->size. */
2044 new_bitmap_size = (fildes[0] < fds_to_close->size)
2045 ? fds_to_close->size
2048 fd_bitmap = new_fd_bitmap (new_bitmap_size);
2050 /* Now copy the old information into the new bitmap. */
2051 xbcopy ((char *)fds_to_close->bitmap, (char *)fd_bitmap->bitmap, fds_to_close->size);
2053 /* And mark the pipe file descriptors to be closed. */
2054 fd_bitmap->bitmap[fildes[0]] = 1;
2056 /* In case there are pipe or out-of-processes errors, we
2057 want all these file descriptors to be closed when
2058 unwind-protects are run, and the storage used for the
2059 bitmaps freed up. */
2060 begin_unwind_frame ("pipe-file-descriptors");
2061 add_unwind_protect (dispose_fd_bitmap, fd_bitmap);
2062 add_unwind_protect (close_fd_bitmap, fd_bitmap);
2064 add_unwind_protect (close, prev);
2065 dummyfd = fildes[1];
2066 add_unwind_protect (close, dummyfd);
2068 #if defined (JOB_CONTROL)
2069 add_unwind_protect (restore_signal_mask, &oset);
2070 #endif /* JOB_CONTROL */
2072 if (ignore_return && cmd->value.Connection->first)
2073 cmd->value.Connection->first->flags |= CMD_IGNORE_RETURN;
2074 execute_command_internal (cmd->value.Connection->first, asynchronous,
2075 prev, fildes[1], fd_bitmap);
2083 dispose_fd_bitmap (fd_bitmap);
2084 discard_unwind_frame ("pipe-file-descriptors");
2086 cmd = cmd->value.Connection->second;
2089 /* Now execute the rightmost command in the pipeline. */
2090 if (ignore_return && cmd)
2091 cmd->flags |= CMD_IGNORE_RETURN;
2092 exec_result = execute_command_internal (cmd, asynchronous, prev, pipe_out, fds_to_close);
2097 #if defined (JOB_CONTROL)
2098 UNBLOCK_CHILD (oset);
2102 return (exec_result);
2106 execute_connection (command, asynchronous, pipe_in, pipe_out, fds_to_close)
2108 int asynchronous, pipe_in, pipe_out;
2109 struct fd_bitmap *fds_to_close;
2112 COMMAND *tc, *second;
2113 int ignore_return, exec_result, was_error_trap, invert;
2114 volatile int save_line_number;
2116 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
2118 switch (command->value.Connection->connector)
2120 /* Do the first command asynchronously. */
2122 tc = command->value.Connection->first;
2124 return (EXECUTION_SUCCESS);
2129 tc->flags |= CMD_IGNORE_RETURN;
2130 tc->flags |= CMD_AMPERSAND;
2132 /* If this shell was compiled without job control support,
2133 if we are currently in a subshell via `( xxx )', or if job
2134 control is not active then the standard input for an
2135 asynchronous command is forced to /dev/null. */
2136 #if defined (JOB_CONTROL)
2137 if ((subshell_environment || !job_control) && !stdin_redir)
2140 #endif /* JOB_CONTROL */
2141 tc->flags |= CMD_STDIN_REDIR;
2143 exec_result = execute_command_internal (tc, 1, pipe_in, pipe_out, fds_to_close);
2146 if (tc->flags & CMD_STDIN_REDIR)
2147 tc->flags &= ~CMD_STDIN_REDIR;
2149 second = command->value.Connection->second;
2153 second->flags |= CMD_IGNORE_RETURN;
2155 exec_result = execute_command_internal (second, asynchronous, pipe_in, pipe_out, fds_to_close);
2160 /* Just call execute command on both sides. */
2164 if (command->value.Connection->first)
2165 command->value.Connection->first->flags |= CMD_IGNORE_RETURN;
2166 if (command->value.Connection->second)
2167 command->value.Connection->second->flags |= CMD_IGNORE_RETURN;
2171 execute_command (command->value.Connection->first);
2173 exec_result = execute_command_internal (command->value.Connection->second,
2174 asynchronous, pipe_in, pipe_out,
2180 was_error_trap = signal_is_trapped (ERROR_TRAP) && signal_is_ignored (ERROR_TRAP) == 0;
2181 invert = (command->flags & CMD_INVERT_RETURN) != 0;
2182 ignore_return = (command->flags & CMD_IGNORE_RETURN) != 0;
2184 line_number_for_err_trap = line_number;
2185 exec_result = execute_pipeline (command, asynchronous, pipe_in, pipe_out, fds_to_close);
2187 if (was_error_trap && ignore_return == 0 && invert == 0 && exec_result != EXECUTION_SUCCESS)
2189 last_command_exit_value = exec_result;
2190 save_line_number = line_number;
2191 line_number = line_number_for_err_trap;
2193 line_number = save_line_number;
2196 if (ignore_return == 0 && invert == 0 && exit_immediately_on_error && exec_result != EXECUTION_SUCCESS)
2198 last_command_exit_value = exec_result;
2199 run_pending_traps ();
2200 jump_to_top_level (ERREXIT);
2209 /* If we have something like `a && b &' or `a || b &', run the
2210 && or || stuff in a subshell. Force a subshell and just call
2211 execute_command_internal again. Leave asynchronous on
2212 so that we get a report from the parent shell about the
2214 command->flags |= CMD_FORCE_SUBSHELL;
2215 exec_result = execute_command_internal (command, 1, pipe_in, pipe_out, fds_to_close);
2219 /* Execute the first command. If the result of that is successful
2220 and the connector is AND_AND, or the result is not successful
2221 and the connector is OR_OR, then execute the second command,
2222 otherwise return. */
2225 if (command->value.Connection->first)
2226 command->value.Connection->first->flags |= CMD_IGNORE_RETURN;
2228 exec_result = execute_command (command->value.Connection->first);
2230 if (((command->value.Connection->connector == AND_AND) &&
2231 (exec_result == EXECUTION_SUCCESS)) ||
2232 ((command->value.Connection->connector == OR_OR) &&
2233 (exec_result != EXECUTION_SUCCESS)))
2235 if (ignore_return && command->value.Connection->second)
2236 command->value.Connection->second->flags |= CMD_IGNORE_RETURN;
2238 exec_result = execute_command (command->value.Connection->second);
2244 command_error ("execute_connection", CMDERR_BADCONN, command->value.Connection->connector, 0);
2245 jump_to_top_level (DISCARD);
2246 exec_result = EXECUTION_FAILURE;
2255 if (!interactive_shell) \
2256 reap_dead_jobs (); \
2260 /* Execute a FOR command. The syntax is: FOR word_desc IN word_list;
2263 execute_for_command (for_command)
2264 FOR_COM *for_command;
2266 register WORD_LIST *releaser, *list;
2269 int retval, save_line_number;
2271 SHELL_VAR *old_value = (SHELL_VAR *)NULL; /* Remember the old value of x. */
2274 save_line_number = line_number;
2275 if (check_identifier (for_command->name, 1) == 0)
2277 if (posixly_correct && interactive_shell == 0)
2279 last_command_exit_value = EX_BADUSAGE;
2280 jump_to_top_level (ERREXIT);
2282 return (EXECUTION_FAILURE);
2286 identifier = for_command->name->word;
2288 list = releaser = expand_words_no_vars (for_command->map_list);
2290 begin_unwind_frame ("for");
2291 add_unwind_protect (dispose_words, releaser);
2294 if (lexical_scoping)
2296 old_value = copy_variable (find_variable (identifier));
2298 add_unwind_protect (dispose_variable, old_value);
2302 if (for_command->flags & CMD_IGNORE_RETURN)
2303 for_command->action->flags |= CMD_IGNORE_RETURN;
2305 for (retval = EXECUTION_SUCCESS; list; list = list->next)
2309 line_number = for_command->line;
2311 /* Remember what this command looks like, for debugger. */
2312 command_string_index = 0;
2313 print_for_command_head (for_command);
2315 if (echo_command_at_execute)
2316 xtrace_print_for_command_head (for_command);
2318 /* Save this command unless it's a trap command and we're not running
2321 if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
2323 if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
2326 FREE (the_printed_command_except_trap);
2327 the_printed_command_except_trap = savestring (the_printed_command);
2330 retval = run_debug_trap ();
2331 #if defined (DEBUGGER)
2332 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
2333 skip the command. */
2334 if (debugging_mode && retval != EXECUTION_SUCCESS)
2338 this_command_name = (char *)NULL;
2339 v = bind_variable (identifier, list->word->word, 0);
2340 if (readonly_p (v) || noassign_p (v))
2342 line_number = save_line_number;
2343 if (readonly_p (v) && interactive_shell == 0 && posixly_correct)
2345 last_command_exit_value = EXECUTION_FAILURE;
2346 jump_to_top_level (FORCE_EOF);
2350 dispose_words (releaser);
2351 discard_unwind_frame ("for");
2353 return (EXECUTION_FAILURE);
2356 retval = execute_command (for_command->action);
2375 line_number = save_line_number;
2378 if (lexical_scoping)
2381 unbind_variable (identifier);
2384 SHELL_VAR *new_value;
2386 new_value = bind_variable (identifier, value_cell(old_value), 0);
2387 new_value->attributes = old_value->attributes;
2388 dispose_variable (old_value);
2393 dispose_words (releaser);
2394 discard_unwind_frame ("for");
2398 #if defined (ARITH_FOR_COMMAND)
2399 /* Execute an arithmetic for command. The syntax is
2401 for (( init ; step ; test ))
2406 The execution should be exactly equivalent to
2409 while eval \(\( test \)\) ; do
2415 eval_arith_for_expr (l, okp)
2423 new = expand_words_no_vars (l);
2426 if (echo_command_at_execute)
2427 xtrace_print_arith_cmd (new);
2428 this_command_name = "(("; /* )) for expression error messages */
2430 command_string_index = 0;
2431 print_arith_command (new);
2432 if (signal_in_progress (DEBUG_TRAP) == 0)
2434 FREE (the_printed_command_except_trap);
2435 the_printed_command_except_trap = savestring (the_printed_command);
2438 r = run_debug_trap ();
2439 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
2440 skip the command. */
2441 #if defined (DEBUGGER)
2442 if (debugging_mode == 0 || r == EXECUTION_SUCCESS)
2443 expresult = evalexp (new->word->word, okp);
2451 expresult = evalexp (new->word->word, okp);
2453 dispose_words (new);
2465 execute_arith_for_command (arith_for_command)
2466 ARITH_FOR_COM *arith_for_command;
2469 int expok, body_status, arith_lineno, save_lineno;
2471 body_status = EXECUTION_SUCCESS;
2473 save_lineno = line_number;
2475 if (arith_for_command->flags & CMD_IGNORE_RETURN)
2476 arith_for_command->action->flags |= CMD_IGNORE_RETURN;
2478 this_command_name = "(("; /* )) for expression error messages */
2480 /* save the starting line number of the command so we can reset
2481 line_number before executing each expression -- for $LINENO
2482 and the DEBUG trap. */
2483 line_number = arith_lineno = arith_for_command->line;
2484 if (variable_context && interactive_shell)
2485 line_number -= function_line_number;
2487 /* Evaluate the initialization expression. */
2488 expresult = eval_arith_for_expr (arith_for_command->init, &expok);
2491 line_number = save_lineno;
2492 return (EXECUTION_FAILURE);
2497 /* Evaluate the test expression. */
2498 line_number = arith_lineno;
2499 expresult = eval_arith_for_expr (arith_for_command->test, &expok);
2500 line_number = save_lineno;
2504 body_status = EXECUTION_FAILURE;
2511 /* Execute the body of the arithmetic for command. */
2513 body_status = execute_command (arith_for_command->action);
2516 /* Handle any `break' or `continue' commands executed by the body. */
2530 /* Evaluate the step expression. */
2531 line_number = arith_lineno;
2532 expresult = eval_arith_for_expr (arith_for_command->step, &expok);
2533 line_number = save_lineno;
2537 body_status = EXECUTION_FAILURE;
2543 line_number = save_lineno;
2545 return (body_status);
2549 #if defined (SELECT_COMMAND)
2550 static int LINES, COLS, tabsize;
2552 #define RP_SPACE ") "
2553 #define RP_SPACE_LEN 2
2555 /* XXX - does not handle numbers > 1000000 at all. */
2556 #define NUMBER_LEN(s) \
2560 : ((s < 10000) ? 4 \
2561 : ((s < 100000) ? 5 \
2565 print_index_and_element (len, ind, list)
2569 register WORD_LIST *l;
2574 for (i = ind, l = list; l && --i; l = l->next)
2576 fprintf (stderr, "%*d%s%s", len, ind, RP_SPACE, l->word->word);
2577 return (STRLEN (l->word->word));
2586 if ((to / tabsize) > (from / tabsize))
2588 putc ('\t', stderr);
2589 from += tabsize - from % tabsize;
2600 print_select_list (list, list_len, max_elem_len, indices_len)
2602 int list_len, max_elem_len, indices_len;
2604 int ind, row, elem_len, pos, cols, rows;
2605 int first_column_indices_len, other_indices_len;
2609 putc ('\n', stderr);
2613 cols = max_elem_len ? COLS / max_elem_len : 1;
2616 rows = list_len ? list_len / cols + (list_len % cols != 0) : 1;
2617 cols = list_len ? list_len / rows + (list_len % rows != 0) : 1;
2625 first_column_indices_len = NUMBER_LEN (rows);
2626 other_indices_len = indices_len;
2628 for (row = 0; row < rows; row++)
2634 indices_len = (pos == 0) ? first_column_indices_len : other_indices_len;
2635 elem_len = print_index_and_element (indices_len, ind + 1, list);
2636 elem_len += indices_len + RP_SPACE_LEN;
2638 if (ind >= list_len)
2640 indent (pos + elem_len, pos + max_elem_len);
2641 pos += max_elem_len;
2643 putc ('\n', stderr);
2647 /* Print the elements of LIST, one per line, preceded by an index from 1 to
2648 LIST_LEN. Then display PROMPT and wait for the user to enter a number.
2649 If the number is between 1 and LIST_LEN, return that selection. If EOF
2650 is read, return a null string. If a blank line is entered, or an invalid
2651 number is entered, the loop is executed again. */
2653 select_query (list, list_len, prompt, print_menu)
2659 int max_elem_len, indices_len, len;
2662 char *repl_string, *t;
2664 t = get_string_value ("LINES");
2665 LINES = (t && *t) ? atoi (t) : 24;
2666 t = get_string_value ("COLUMNS");
2667 COLS = (t && *t) ? atoi (t) : 80;
2670 t = get_string_value ("TABSIZE");
2671 tabsize = (t && *t) ? atoi (t) : 8;
2679 for (l = list; l; l = l->next)
2681 len = STRLEN (l->word->word);
2682 if (len > max_elem_len)
2685 indices_len = NUMBER_LEN (list_len);
2686 max_elem_len += indices_len + RP_SPACE_LEN + 2;
2691 print_select_list (list, list_len, max_elem_len, indices_len);
2692 fprintf (stderr, "%s", prompt);
2696 if (read_builtin ((WORD_LIST *)NULL) == EXECUTION_FAILURE)
2699 return ((char *)NULL);
2701 repl_string = get_string_value ("REPLY");
2702 if (*repl_string == 0)
2707 if (legal_number (repl_string, &reply) == 0)
2709 if (reply < 1 || reply > list_len)
2712 for (l = list; l && --reply; l = l->next)
2714 return (l->word->word);
2718 /* Execute a SELECT command. The syntax is:
2719 SELECT word IN list DO command_list DONE
2720 Only `break' or `return' in command_list will terminate
2723 execute_select_command (select_command)
2724 SELECT_COM *select_command;
2726 WORD_LIST *releaser, *list;
2728 char *identifier, *ps3_prompt, *selection;
2729 int retval, list_len, show_menu, save_line_number;
2731 if (check_identifier (select_command->name, 1) == 0)
2732 return (EXECUTION_FAILURE);
2734 save_line_number = line_number;
2735 line_number = select_command->line;
2737 command_string_index = 0;
2738 print_select_command_head (select_command);
2740 if (echo_command_at_execute)
2741 xtrace_print_select_command_head (select_command);
2744 if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
2746 if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
2749 FREE (the_printed_command_except_trap);
2750 the_printed_command_except_trap = savestring (the_printed_command);
2753 retval = run_debug_trap ();
2754 #if defined (DEBUGGER)
2755 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
2756 skip the command. */
2757 if (debugging_mode && retval != EXECUTION_SUCCESS)
2758 return (EXECUTION_SUCCESS);
2762 identifier = select_command->name->word;
2764 /* command and arithmetic substitution, parameter and variable expansion,
2765 word splitting, pathname expansion, and quote removal. */
2766 list = releaser = expand_words_no_vars (select_command->map_list);
2767 list_len = list_length (list);
2768 if (list == 0 || list_len == 0)
2771 dispose_words (list);
2772 line_number = save_line_number;
2773 return (EXECUTION_SUCCESS);
2776 begin_unwind_frame ("select");
2777 add_unwind_protect (dispose_words, releaser);
2779 if (select_command->flags & CMD_IGNORE_RETURN)
2780 select_command->action->flags |= CMD_IGNORE_RETURN;
2782 retval = EXECUTION_SUCCESS;
2787 line_number = select_command->line;
2788 ps3_prompt = get_string_value ("PS3");
2789 if (ps3_prompt == 0)
2793 selection = select_query (list, list_len, ps3_prompt, show_menu);
2797 /* select_query returns EXECUTION_FAILURE if the read builtin
2798 fails, so we want to return failure in this case. */
2799 retval = EXECUTION_FAILURE;
2803 v = bind_variable (identifier, selection, 0);
2804 if (readonly_p (v) || noassign_p (v))
2806 if (readonly_p (v) && interactive_shell == 0 && posixly_correct)
2808 last_command_exit_value = EXECUTION_FAILURE;
2809 jump_to_top_level (FORCE_EOF);
2813 dispose_words (releaser);
2814 discard_unwind_frame ("select");
2816 line_number = save_line_number;
2817 return (EXECUTION_FAILURE);
2821 retval = execute_command (select_command->action);
2839 #if defined (KSH_COMPATIBLE_SELECT)
2841 selection = get_string_value ("REPLY");
2842 if (selection && *selection == '\0')
2848 line_number = save_line_number;
2850 dispose_words (releaser);
2851 discard_unwind_frame ("select");
2854 #endif /* SELECT_COMMAND */
2856 /* Execute a CASE command. The syntax is: CASE word_desc IN pattern_list ESAC.
2857 The pattern_list is a linked list of pattern clauses; each clause contains
2858 some patterns to compare word_desc against, and an associated command to
2861 execute_case_command (case_command)
2862 CASE_COM *case_command;
2864 register WORD_LIST *list;
2865 WORD_LIST *wlist, *es;
2866 PATTERN_LIST *clauses;
2867 char *word, *pattern;
2868 int retval, match, ignore_return, save_line_number;
2870 save_line_number = line_number;
2871 line_number = case_command->line;
2873 command_string_index = 0;
2874 print_case_command_head (case_command);
2876 if (echo_command_at_execute)
2877 xtrace_print_case_command_head (case_command);
2880 if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
2882 if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
2885 FREE (the_printed_command_except_trap);
2886 the_printed_command_except_trap = savestring (the_printed_command);
2889 retval = run_debug_trap();
2890 #if defined (DEBUGGER)
2891 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
2892 skip the command. */
2893 if (debugging_mode && retval != EXECUTION_SUCCESS)
2895 line_number = save_line_number;
2896 return (EXECUTION_SUCCESS);
2900 wlist = expand_word_unsplit (case_command->word, 0);
2901 word = wlist ? string_list (wlist) : savestring ("");
2902 dispose_words (wlist);
2904 retval = EXECUTION_SUCCESS;
2905 ignore_return = case_command->flags & CMD_IGNORE_RETURN;
2907 begin_unwind_frame ("case");
2908 add_unwind_protect ((Function *)xfree, word);
2910 #define EXIT_CASE() goto exit_case_command
2912 for (clauses = case_command->clauses; clauses; clauses = clauses->next)
2915 for (list = clauses->patterns; list; list = list->next)
2917 es = expand_word_leave_quoted (list->word, 0);
2919 if (es && es->word && es->word->word && *(es->word->word))
2920 pattern = quote_string_for_globbing (es->word->word, QGLOB_CVTNULL);
2923 pattern = (char *)xmalloc (1);
2927 /* Since the pattern does not undergo quote removal (as per
2928 Posix.2, section 3.9.4.3), the strmatch () call must be able
2929 to recognize backslashes as escape characters. */
2930 match = strmatch (pattern, word, FNMATCH_EXTFLAG|FNMATCH_IGNCASE) != FNM_NOMATCH;
2939 if (clauses->action && ignore_return)
2940 clauses->action->flags |= CMD_IGNORE_RETURN;
2941 retval = execute_command (clauses->action);
2943 while ((clauses->flags & CASEPAT_FALLTHROUGH) && (clauses = clauses->next));
2944 if (clauses == 0 || (clauses->flags & CASEPAT_TESTNEXT) == 0)
2956 discard_unwind_frame ("case");
2957 line_number = save_line_number;
2964 /* The WHILE command. Syntax: WHILE test DO action; DONE.
2965 Repeatedly execute action while executing test produces
2966 EXECUTION_SUCCESS. */
2968 execute_while_command (while_command)
2969 WHILE_COM *while_command;
2971 return (execute_while_or_until (while_command, CMD_WHILE));
2974 /* UNTIL is just like WHILE except that the test result is negated. */
2976 execute_until_command (while_command)
2977 WHILE_COM *while_command;
2979 return (execute_while_or_until (while_command, CMD_UNTIL));
2982 /* The body for both while and until. The only difference between the
2983 two is that the test value is treated differently. TYPE is
2984 CMD_WHILE or CMD_UNTIL. The return value for both commands should
2985 be EXECUTION_SUCCESS if no commands in the body are executed, and
2986 the status of the last command executed in the body otherwise. */
2988 execute_while_or_until (while_command, type)
2989 WHILE_COM *while_command;
2992 int return_value, body_status;
2994 body_status = EXECUTION_SUCCESS;
2997 while_command->test->flags |= CMD_IGNORE_RETURN;
2998 if (while_command->flags & CMD_IGNORE_RETURN)
2999 while_command->action->flags |= CMD_IGNORE_RETURN;
3003 return_value = execute_command (while_command->test);
3006 /* Need to handle `break' in the test when we would break out of the
3007 loop. The job control code will set `breaking' to loop_level
3008 when a job in a loop is stopped with SIGTSTP. If the stopped job
3009 is in the loop test, `breaking' will not be reset unless we do
3010 this, and the shell will cease to execute commands. */
3011 if (type == CMD_WHILE && return_value != EXECUTION_SUCCESS)
3017 if (type == CMD_UNTIL && return_value == EXECUTION_SUCCESS)
3025 body_status = execute_command (while_command->action);
3043 return (body_status);
3046 /* IF test THEN command [ELSE command].
3047 IF also allows ELIF in the place of ELSE IF, but
3048 the parser makes *that* stupidity transparent. */
3050 execute_if_command (if_command)
3053 int return_value, save_line_number;
3055 save_line_number = line_number;
3056 if_command->test->flags |= CMD_IGNORE_RETURN;
3057 return_value = execute_command (if_command->test);
3058 line_number = save_line_number;
3060 if (return_value == EXECUTION_SUCCESS)
3064 if (if_command->true_case && (if_command->flags & CMD_IGNORE_RETURN))
3065 if_command->true_case->flags |= CMD_IGNORE_RETURN;
3067 return (execute_command (if_command->true_case));
3073 if (if_command->false_case && (if_command->flags & CMD_IGNORE_RETURN))
3074 if_command->false_case->flags |= CMD_IGNORE_RETURN;
3076 return (execute_command (if_command->false_case));
3080 #if defined (DPAREN_ARITHMETIC)
3082 execute_arith_command (arith_command)
3083 ARITH_COM *arith_command;
3085 int expok, save_line_number, retval;
3092 save_line_number = line_number;
3093 this_command_name = "(("; /* )) */
3094 line_number = arith_command->line;
3095 /* If we're in a function, update the line number information. */
3096 if (variable_context && interactive_shell)
3097 line_number -= function_line_number;
3099 command_string_index = 0;
3100 print_arith_command (arith_command->exp);
3102 if (signal_in_progress (DEBUG_TRAP) == 0)
3104 FREE (the_printed_command_except_trap);
3105 the_printed_command_except_trap = savestring (the_printed_command);
3108 /* Run the debug trap before each arithmetic command, but do it after we
3109 update the line number information and before we expand the various
3110 words in the expression. */
3111 retval = run_debug_trap ();
3112 #if defined (DEBUGGER)
3113 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3114 skip the command. */
3115 if (debugging_mode && retval != EXECUTION_SUCCESS)
3117 line_number = save_line_number;
3118 return (EXECUTION_SUCCESS);
3122 new = expand_words_no_vars (arith_command->exp);
3124 /* If we're tracing, make a new word list with `((' at the front and `))'
3125 at the back and print it. */
3126 if (echo_command_at_execute)
3127 xtrace_print_arith_cmd (new);
3131 exp = new->next ? string_list (new) : new->word->word;
3132 expresult = evalexp (exp, &expok);
3133 line_number = save_line_number;
3134 if (exp != new->word->word)
3136 dispose_words (new);
3145 return (EXECUTION_FAILURE);
3147 return (expresult == 0 ? EXECUTION_FAILURE : EXECUTION_SUCCESS);
3149 #endif /* DPAREN_ARITHMETIC */
3151 #if defined (COND_COMMAND)
3153 static char * const nullstr = "";
3156 execute_cond_node (cond)
3159 int result, invert, patmatch, rmatch, mflags;
3162 invert = (cond->flags & CMD_INVERT_RETURN);
3164 if (cond->type == COND_EXPR)
3165 result = execute_cond_node (cond->left);
3166 else if (cond->type == COND_OR)
3168 result = execute_cond_node (cond->left);
3169 if (result != EXECUTION_SUCCESS)
3170 result = execute_cond_node (cond->right);
3172 else if (cond->type == COND_AND)
3174 result = execute_cond_node (cond->left);
3175 if (result == EXECUTION_SUCCESS)
3176 result = execute_cond_node (cond->right);
3178 else if (cond->type == COND_UNARY)
3180 arg1 = cond_expand_word (cond->left->op, 0);
3183 if (echo_command_at_execute)
3184 xtrace_print_cond_term (cond->type, invert, cond->op, arg1, (char *)NULL);
3185 result = unary_test (cond->op->word, arg1) ? EXECUTION_SUCCESS : EXECUTION_FAILURE;
3186 if (arg1 != nullstr)
3189 else if (cond->type == COND_BINARY)
3192 patmatch = ((cond->op->word[1] == '=') && (cond->op->word[2] == '\0') &&
3193 (cond->op->word[0] == '!' || cond->op->word[0] == '=') ||
3194 (cond->op->word[0] == '=' && cond->op->word[1] == '\0'));
3195 #if defined (COND_REGEXP)
3196 rmatch = (cond->op->word[0] == '=' && cond->op->word[1] == '~' &&
3197 cond->op->word[2] == '\0');
3200 arg1 = cond_expand_word (cond->left->op, 0);
3203 arg2 = cond_expand_word (cond->right->op,
3204 (rmatch && shell_compatibility_level > 31) ? 2 : (patmatch ? 1 : 0));
3208 if (echo_command_at_execute)
3209 xtrace_print_cond_term (cond->type, invert, cond->op, arg1, arg2);
3211 #if defined (COND_REGEXP)
3214 mflags = SHMAT_PWARN;
3215 #if defined (ARRAY_VARS)
3216 mflags |= SHMAT_SUBEXP;
3219 result = sh_regmatch (arg1, arg2, mflags);
3222 #endif /* COND_REGEXP */
3227 result = binary_test (cond->op->word, arg1, arg2, TEST_PATMATCH|TEST_ARITHEXP)
3229 : EXECUTION_FAILURE;
3232 if (arg1 != nullstr)
3234 if (arg2 != nullstr)
3239 command_error ("execute_cond_node", CMDERR_BADTYPE, cond->type, 0);
3240 jump_to_top_level (DISCARD);
3241 result = EXECUTION_FAILURE;
3245 result = (result == EXECUTION_SUCCESS) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
3251 execute_cond_command (cond_command)
3252 COND_COM *cond_command;
3254 int retval, save_line_number;
3256 retval = EXECUTION_SUCCESS;
3257 save_line_number = line_number;
3259 this_command_name = "[[";
3260 line_number = cond_command->line;
3261 /* If we're in a function, update the line number information. */
3262 if (variable_context && interactive_shell)
3263 line_number -= function_line_number;
3265 command_string_index = 0;
3266 print_cond_command (cond_command);
3268 if (signal_in_progress (DEBUG_TRAP) == 0)
3270 FREE (the_printed_command_except_trap);
3271 the_printed_command_except_trap = savestring (the_printed_command);
3274 /* Run the debug trap before each conditional command, but do it after we
3275 update the line number information. */
3276 retval = run_debug_trap ();
3277 #if defined (DEBUGGER)
3278 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3279 skip the command. */
3280 if (debugging_mode && retval != EXECUTION_SUCCESS)
3282 line_number = save_line_number;
3283 return (EXECUTION_SUCCESS);
3288 debug_print_cond_command (cond_command);
3291 last_command_exit_value = retval = execute_cond_node (cond_command);
3292 line_number = save_line_number;
3295 #endif /* COND_COMMAND */
3305 var = bind_variable ("_", arg, 0);
3306 VUNSETATTR (var, att_exported);
3309 /* Execute a null command. Fork a subshell if the command uses pipes or is
3310 to be run asynchronously. This handles all the side effects that are
3311 supposed to take place. */
3313 execute_null_command (redirects, pipe_in, pipe_out, async)
3314 REDIRECT *redirects;
3315 int pipe_in, pipe_out, async;
3319 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE || async)
3321 /* We have a null command, but we really want a subshell to take
3322 care of it. Just fork, do piping and redirections, and exit. */
3323 if (make_child ((char *)NULL, async) == 0)
3325 /* Cancel traps, in trap.c. */
3326 restore_original_signals (); /* XXX */
3328 do_piping (pipe_in, pipe_out);
3330 #if defined (COPROCESS_SUPPORT)
3334 subshell_environment = 0;
3336 subshell_environment |= SUBSHELL_ASYNC;
3337 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
3338 subshell_environment |= SUBSHELL_PIPE;
3340 if (do_redirections (redirects, RX_ACTIVE) == 0)
3341 exit (EXECUTION_SUCCESS);
3343 exit (EXECUTION_FAILURE);
3347 close_pipes (pipe_in, pipe_out);
3348 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
3349 unlink_fifo_list ();
3351 return (EXECUTION_SUCCESS);
3356 /* Even if there aren't any command names, pretend to do the
3357 redirections that are specified. The user expects the side
3358 effects to take place. If the redirections fail, then return
3359 failure. Otherwise, if a command substitution took place while
3360 expanding the command or a redirection, return the value of that
3361 substitution. Otherwise, return EXECUTION_SUCCESS. */
3363 r = do_redirections (redirects, RX_ACTIVE|RX_UNDOABLE);
3364 cleanup_redirects (redirection_undo_list);
3365 redirection_undo_list = (REDIRECT *)NULL;
3368 return (EXECUTION_FAILURE);
3369 else if (last_command_subst_pid != NO_PID)
3370 return (last_command_exit_value);
3372 return (EXECUTION_SUCCESS);
3376 /* This is a hack to suppress word splitting for assignment statements
3377 given as arguments to builtins with the ASSIGNMENT_BUILTIN flag set. */
3379 fix_assignment_words (words)
3392 for (w = words; w; w = w->next)
3393 if (w->word->flags & W_ASSIGNMENT)
3397 b = builtin_address_internal (words->word->word, 0);
3398 if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
3400 else if (b && (b->flags & ASSIGNMENT_BUILTIN))
3401 words->word->flags |= W_ASSNBLTIN;
3403 w->word->flags |= (W_NOSPLIT|W_NOGLOB|W_TILDEEXP|W_ASSIGNARG);
3404 #if defined (ARRAY_VARS)
3406 w->word->flags |= W_ASSIGNASSOC;
3409 #if defined (ARRAY_VARS)
3410 /* Note that we saw an associative array option to a builtin that takes
3411 assignment statements. This is a bit of a kludge. */
3412 else if (w->word->word[0] == '-' && strchr (w->word->word, 'A'))
3416 b = builtin_address_internal (words->word->word, 0);
3417 if (b == 0 || (b->flags & ASSIGNMENT_BUILTIN) == 0)
3419 else if (b && (b->flags & ASSIGNMENT_BUILTIN))
3420 words->word->flags |= W_ASSNBLTIN;
3422 if (words->word->flags & W_ASSNBLTIN)
3428 /* Return 1 if the file found by searching $PATH for PATHNAME, defaulting
3429 to PATHNAME, is a directory. Used by the autocd code below. */
3431 is_dirname (pathname)
3435 temp = search_for_command (pathname);
3436 return (temp ? file_isdir (temp) : file_isdir (pathname));
3439 /* The meaty part of all the executions. We have to start hacking the
3440 real execution of commands here. Fork a process, set things up,
3441 execute the command. */
3443 execute_simple_command (simple_command, pipe_in, pipe_out, async, fds_to_close)
3444 SIMPLE_COM *simple_command;
3445 int pipe_in, pipe_out, async;
3446 struct fd_bitmap *fds_to_close;
3448 WORD_LIST *words, *lastword;
3449 char *command_line, *lastarg, *temp;
3450 int first_word_quoted, result, builtin_is_special, already_forked, dofork;
3451 pid_t old_last_async_pid;
3452 sh_builtin_func_t *builtin;
3455 result = EXECUTION_SUCCESS;
3456 special_builtin_failed = builtin_is_special = 0;
3457 command_line = (char *)0;
3459 /* If we're in a function, update the line number information. */
3460 if (variable_context && interactive_shell)
3461 line_number -= function_line_number;
3463 /* Remember what this command line looks like at invocation. */
3464 command_string_index = 0;
3465 print_simple_command (simple_command);
3468 if (signal_in_progress (DEBUG_TRAP) == 0 && (this_command_name == 0 || (STREQ (this_command_name, "trap") == 0)))
3470 if (signal_in_progress (DEBUG_TRAP) == 0 && running_trap == 0)
3473 FREE (the_printed_command_except_trap);
3474 the_printed_command_except_trap = the_printed_command ? savestring (the_printed_command) : (char *)0;
3477 /* Run the debug trap before each simple command, but do it after we
3478 update the line number information. */
3479 result = run_debug_trap ();
3480 #if defined (DEBUGGER)
3481 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
3482 skip the command. */
3483 if (debugging_mode && result != EXECUTION_SUCCESS)
3484 return (EXECUTION_SUCCESS);
3488 simple_command->words ? (simple_command->words->word->flags & W_QUOTED) : 0;
3490 last_command_subst_pid = NO_PID;
3491 old_last_async_pid = last_asynchronous_pid;
3493 already_forked = dofork = 0;
3495 /* If we're in a pipeline or run in the background, set DOFORK so we
3496 make the child early, before word expansion. This keeps assignment
3497 statements from affecting the parent shell's environment when they
3499 dofork = pipe_in != NO_PIPE || pipe_out != NO_PIPE || async;
3501 /* Something like `%2 &' should restart job 2 in the background, not cause
3502 the shell to fork here. */
3503 if (dofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE &&
3504 simple_command->words && simple_command->words->word &&
3505 simple_command->words->word->word &&
3506 (simple_command->words->word->word[0] == '%'))
3511 /* Do this now, because execute_disk_command will do it anyway in the
3512 vast majority of cases. */
3513 maybe_make_export_env ();
3515 /* Don't let a DEBUG trap overwrite the command string to be saved with
3516 the process/job associated with this child. */
3517 if (make_child (savestring (the_printed_command_except_trap), async) == 0)
3520 simple_command->flags |= CMD_NO_FORK;
3522 subshell_environment = SUBSHELL_FORK;
3523 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
3524 subshell_environment |= SUBSHELL_PIPE;
3526 subshell_environment |= SUBSHELL_ASYNC;
3528 /* We need to do this before piping to handle some really
3529 pathological cases where one of the pipe file descriptors
3532 close_fd_bitmap (fds_to_close);
3534 do_piping (pipe_in, pipe_out);
3535 pipe_in = pipe_out = NO_PIPE;
3536 #if defined (COPROCESS_SUPPORT)
3540 last_asynchronous_pid = old_last_async_pid;
3544 close_pipes (pipe_in, pipe_out);
3545 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
3546 unlink_fifo_list ();
3548 command_line = (char *)NULL; /* don't free this. */
3549 bind_lastarg ((char *)NULL);
3554 /* If we are re-running this as the result of executing the `command'
3555 builtin, do not expand the command words a second time. */
3556 if ((simple_command->flags & CMD_INHIBIT_EXPANSION) == 0)
3558 current_fds_to_close = fds_to_close;
3559 fix_assignment_words (simple_command->words);
3560 /* Pass the ignore return flag down to command substitutions */
3561 if (simple_command->flags & CMD_IGNORE_RETURN) /* XXX */
3562 comsub_ignore_return++;
3563 words = expand_words (simple_command->words);
3564 if (simple_command->flags & CMD_IGNORE_RETURN)
3565 comsub_ignore_return--;
3566 current_fds_to_close = (struct fd_bitmap *)NULL;
3569 words = copy_word_list (simple_command->words);
3571 /* It is possible for WORDS not to have anything left in it.
3572 Perhaps all the words consisted of `$foo', and there was
3573 no variable `$foo'. */
3576 this_command_name = 0;
3577 result = execute_null_command (simple_command->redirects,
3579 already_forked ? 0 : async);
3584 bind_lastarg ((char *)NULL);
3585 set_pipestatus_from_exit (result);
3590 lastarg = (char *)NULL;
3592 begin_unwind_frame ("simple-command");
3594 if (echo_command_at_execute)
3595 xtrace_print_word_list (words, 1);
3597 builtin = (sh_builtin_func_t *)NULL;
3598 func = (SHELL_VAR *)NULL;
3599 if ((simple_command->flags & CMD_NO_FUNCTIONS) == 0)
3601 /* Posix.2 says special builtins are found before functions. We
3602 don't set builtin_is_special anywhere other than here, because
3603 this path is followed only when the `command' builtin is *not*
3604 being used, and we don't want to exit the shell if a special
3605 builtin executed with `command builtin' fails. `command' is not
3606 a special builtin. */
3607 if (posixly_correct)
3609 builtin = find_special_builtin (words->word->word);
3611 builtin_is_special = 1;
3614 func = find_function (words->word->word);
3617 /* In POSIX mode, assignment errors in the temporary environment cause a
3618 non-interactive shell to exit. */
3619 if (builtin_is_special && interactive_shell == 0 && tempenv_assign_error)
3621 last_command_exit_value = EXECUTION_FAILURE;
3622 jump_to_top_level (ERREXIT);
3625 add_unwind_protect (dispose_words, words);
3628 /* Bind the last word in this command to "$_" after execution. */
3629 for (lastword = words; lastword->next; lastword = lastword->next)
3631 lastarg = lastword->word->word;
3633 #if defined (JOB_CONTROL)
3634 /* Is this command a job control related thing? */
3635 if (words->word->word[0] == '%' && already_forked == 0)
3637 this_command_name = async ? "bg" : "fg";
3638 last_shell_builtin = this_shell_builtin;
3639 this_shell_builtin = builtin_address (this_command_name);
3640 result = (*this_shell_builtin) (words);
3644 /* One other possiblilty. The user may want to resume an existing job.
3645 If they do, find out whether this word is a candidate for a running
3647 if (job_control && already_forked == 0 && async == 0 &&
3648 !first_word_quoted &&
3650 words->word->word[0] &&
3651 !simple_command->redirects &&
3652 pipe_in == NO_PIPE &&
3653 pipe_out == NO_PIPE &&
3654 (temp = get_string_value ("auto_resume")))
3656 int job, jflags, started_status;
3658 jflags = JM_STOPPED|JM_FIRSTMATCH;
3659 if (STREQ (temp, "exact"))
3661 else if (STREQ (temp, "substring"))
3662 jflags |= JM_SUBSTRING;
3664 jflags |= JM_PREFIX;
3665 job = get_job_by_name (words->word->word, jflags);
3668 run_unwind_frame ("simple-command");
3669 this_command_name = "fg";
3670 last_shell_builtin = this_shell_builtin;
3671 this_shell_builtin = builtin_address ("fg");
3673 started_status = start_job (job, 1);
3674 return ((started_status < 0) ? EXECUTION_FAILURE : started_status);
3677 #endif /* JOB_CONTROL */
3680 /* Remember the name of this command globally. */
3681 this_command_name = words->word->word;
3685 /* This command could be a shell builtin or a user-defined function.
3686 We have already found special builtins by this time, so we do not
3687 set builtin_is_special. If this is a function or builtin, and we
3688 have pipes, then fork a subshell in here. Otherwise, just execute
3689 the command directly. */
3690 if (func == 0 && builtin == 0)
3691 builtin = find_shell_builtin (this_command_name);
3693 last_shell_builtin = this_shell_builtin;
3694 this_shell_builtin = builtin;
3696 if (builtin || func)
3699 unwind_protect_int (executing_builtin); /* modified in execute_builtin */
3702 /* reset_terminating_signals (); */ /* XXX */
3703 /* Cancel traps, in trap.c. */
3704 restore_original_signals ();
3708 if ((simple_command->flags & CMD_STDIN_REDIR) &&
3709 pipe_in == NO_PIPE &&
3710 (stdin_redirects (simple_command->redirects) == 0))
3711 async_redirect_stdin ();
3712 setup_async_signals ();
3716 execute_subshell_builtin_or_function
3717 (words, simple_command->redirects, builtin, func,
3718 pipe_in, pipe_out, async, fds_to_close,
3719 simple_command->flags);
3724 result = execute_builtin_or_function
3725 (words, builtin, func, simple_command->redirects, fds_to_close,
3726 simple_command->flags);
3729 if (result > EX_SHERRBASE)
3731 result = builtin_status (result);
3732 if (builtin_is_special)
3733 special_builtin_failed = 1;
3735 /* In POSIX mode, if there are assignment statements preceding
3736 a special builtin, they persist after the builtin
3738 if (posixly_correct && builtin_is_special && temporary_env)
3739 merge_temporary_env ();
3743 if (result == EX_USAGE)
3744 result = EX_BADUSAGE;
3745 else if (result > EX_SHERRBASE)
3746 result = EXECUTION_FAILURE;
3749 set_pipestatus_from_exit (result);
3755 if (autocd && interactive && words->word && is_dirname (words->word->word))
3757 words = make_word_list (make_word ("cd"), words);
3758 xtrace_print_word_list (words, 0);
3762 if (command_line == 0)
3763 command_line = savestring (the_printed_command_except_trap);
3765 #if defined (PROCESS_SUBSTITUTION)
3766 if ((subshell_environment & SUBSHELL_COMSUB) && (simple_command->flags & CMD_NO_FORK) && fifos_pending() > 0)
3767 simple_command->flags &= ~CMD_NO_FORK;
3770 execute_disk_command (words, simple_command->redirects, command_line,
3771 pipe_in, pipe_out, async, fds_to_close,
3772 simple_command->flags);
3775 bind_lastarg (lastarg);
3776 FREE (command_line);
3777 dispose_words (words);
3778 discard_unwind_frame ("simple-command");
3779 this_command_name = (char *)NULL; /* points to freed memory now */
3783 /* Translate the special builtin exit statuses. We don't really need a
3784 function for this; it's a placeholder for future work. */
3786 builtin_status (result)
3800 r = EXECUTION_FAILURE;
3803 r = EXECUTION_SUCCESS;
3810 execute_builtin (builtin, words, flags, subshell)
3811 sh_builtin_func_t *builtin;
3813 int flags, subshell;
3815 int old_e_flag, result, eval_unwind;
3819 /* XXX -- added 12/11 */
3820 terminate_immediately++;
3823 old_e_flag = exit_immediately_on_error;
3824 /* The eval builtin calls parse_and_execute, which does not know about
3825 the setting of flags, and always calls the execution functions with
3826 flags that will exit the shell on an error if -e is set. If the
3827 eval builtin is being called, and we're supposed to ignore the exit
3828 value of the command, we turn the -e flag off ourselves, then
3829 restore it when the command completes. This is also a problem (as
3830 below) for the command and source/. builtins. */
3831 if (subshell == 0 && (flags & CMD_IGNORE_RETURN) &&
3832 (builtin == eval_builtin || builtin == command_builtin || builtin == source_builtin))
3834 begin_unwind_frame ("eval_builtin");
3835 unwind_protect_int (exit_immediately_on_error);
3836 exit_immediately_on_error = 0;
3842 /* The temporary environment for a builtin is supposed to apply to
3843 all commands executed by that builtin. Currently, this is a
3844 problem only with the `unset', `source' and `eval' builtins. */
3846 isbltinenv = (builtin == source_builtin || builtin == eval_builtin || builtin == unset_builtin);
3851 begin_unwind_frame ("builtin_env");
3855 push_scope (VC_BLTNENV, temporary_env);
3857 add_unwind_protect (pop_scope, (flags & CMD_COMMAND_BUILTIN) ? 0 : "1");
3858 temporary_env = (HASH_TABLE *)NULL;
3862 /* `return' does a longjmp() back to a saved environment in execute_function.
3863 If a variable assignment list preceded the command, and the shell is
3864 running in POSIX mode, we need to merge that into the shell_variables
3865 table, since `return' is a POSIX special builtin. */
3866 if (posixly_correct && subshell == 0 && builtin == return_builtin && temporary_env)
3868 begin_unwind_frame ("return_temp_env");
3869 add_unwind_protect (merge_temporary_env, (char *)NULL);
3872 executing_builtin++;
3873 result = ((*builtin) (words->next));
3875 /* This shouldn't happen, but in case `return' comes back instead of
3876 longjmp'ing, we need to unwind. */
3877 if (posixly_correct && subshell == 0 && builtin == return_builtin && temporary_env)
3878 discard_unwind_frame ("return_temp_env");
3880 if (subshell == 0 && isbltinenv)
3881 run_unwind_frame ("builtin_env");
3885 exit_immediately_on_error += old_e_flag;
3886 discard_unwind_frame ("eval_builtin");
3890 /* XXX -- added 12/11 */
3891 terminate_immediately--;
3898 execute_function (var, words, flags, fds_to_close, async, subshell)
3902 struct fd_bitmap *fds_to_close;
3903 int async, subshell;
3905 int return_val, result;
3906 COMMAND *tc, *fc, *save_current;
3907 char *debug_trap, *error_trap, *return_trap;
3908 #if defined (ARRAY_VARS)
3909 SHELL_VAR *funcname_v, *nfv, *bash_source_v, *bash_lineno_v;
3910 ARRAY *funcname_a, *bash_source_a, *bash_lineno_a;
3912 FUNCTION_DEF *shell_fn;
3914 static int funcnest = 0;
3918 #if defined (ARRAY_VARS)
3919 GET_ARRAY_FROM_VAR ("FUNCNAME", funcname_v, funcname_a);
3920 GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
3921 GET_ARRAY_FROM_VAR ("BASH_LINENO", bash_lineno_v, bash_lineno_a);
3924 tc = (COMMAND *)copy_command (function_cell (var));
3925 if (tc && (flags & CMD_IGNORE_RETURN))
3926 tc->flags |= CMD_IGNORE_RETURN;
3930 begin_unwind_frame ("function_calling");
3931 push_context (var->name, subshell, temporary_env);
3932 add_unwind_protect (pop_context, (char *)NULL);
3933 unwind_protect_int (line_number);
3934 unwind_protect_int (return_catch_flag);
3935 unwind_protect_jmp_buf (return_catch);
3936 add_unwind_protect (dispose_command, (char *)tc);
3937 unwind_protect_pointer (this_shell_function);
3938 unwind_protect_int (loop_level);
3941 push_context (var->name, subshell, temporary_env); /* don't unwind-protect for subshells */
3943 temporary_env = (HASH_TABLE *)NULL;
3945 this_shell_function = var;
3946 make_funcname_visible (1);
3948 debug_trap = TRAP_STRING(DEBUG_TRAP);
3949 error_trap = TRAP_STRING(ERROR_TRAP);
3950 return_trap = TRAP_STRING(RETURN_TRAP);
3952 /* The order of the unwind protects for debug_trap, error_trap and
3953 return_trap is important here! unwind-protect commands are run
3954 in reverse order of registration. If this causes problems, take
3955 out the xfree unwind-protect calls and live with the small memory leak. */
3957 /* function_trace_mode != 0 means that all functions inherit the DEBUG trap.
3958 if the function has the trace attribute set, it inherits the DEBUG trap */
3959 if (debug_trap && ((trace_p (var) == 0) && function_trace_mode == 0))
3963 debug_trap = savestring (debug_trap);
3964 add_unwind_protect (xfree, debug_trap);
3965 add_unwind_protect (set_debug_trap, debug_trap);
3967 restore_default_signal (DEBUG_TRAP);
3970 /* error_trace_mode != 0 means that functions inherit the ERR trap. */
3971 if (error_trap && error_trace_mode == 0)
3975 error_trap = savestring (error_trap);
3976 add_unwind_protect (xfree, error_trap);
3977 add_unwind_protect (set_error_trap, error_trap);
3979 restore_default_signal (ERROR_TRAP);
3982 /* Shell functions inherit the RETURN trap if function tracing is on
3983 globally or on individually for this function. */
3985 if (return_trap && ((trace_p (var) == 0) && function_trace_mode == 0))
3987 if (return_trap && (signal_in_progress (DEBUG_TRAP) || ((trace_p (var) == 0) && function_trace_mode == 0)))
3992 return_trap = savestring (return_trap);
3993 add_unwind_protect (xfree, return_trap);
3994 add_unwind_protect (set_return_trap, return_trap);
3996 restore_default_signal (RETURN_TRAP);
4000 #if defined (ARRAY_VARS)
4001 /* This is quite similar to the code in shell.c and elsewhere. */
4002 shell_fn = find_function_def (this_shell_function->name);
4003 sfile = shell_fn ? shell_fn->source_file : "";
4004 array_push (funcname_a, this_shell_function->name);
4006 array_push (bash_source_a, sfile);
4007 t = itos (executing_line_number ());
4008 array_push (bash_lineno_a, t);
4012 /* The temporary environment for a function is supposed to apply to
4013 all commands executed within the function body. */
4015 remember_args (words->next, 1);
4017 /* Update BASH_ARGV and BASH_ARGC */
4019 push_args (words->next);
4021 /* Number of the line on which the function body starts. */
4022 line_number = function_line_number = tc->line;
4024 #if defined (JOB_CONTROL)
4026 stop_pipeline (async, (COMMAND *)NULL);
4031 return_catch_flag++;
4032 return_val = setjmp (return_catch);
4036 result = return_catch_value;
4037 /* Run the RETURN trap in the function's context. */
4038 save_current = currently_executing_command;
4040 currently_executing_command = save_current;
4044 /* Run the debug trap here so we can trap at the start of a function's
4045 execution rather than the execution of the body's first command. */
4046 showing_function_line = 1;
4047 save_current = currently_executing_command;
4048 result = run_debug_trap ();
4049 #if defined (DEBUGGER)
4050 /* In debugging mode, if the DEBUG trap returns a non-zero status, we
4051 skip the command. */
4052 if (debugging_mode == 0 || result == EXECUTION_SUCCESS)
4054 showing_function_line = 0;
4055 currently_executing_command = save_current;
4056 result = execute_command_internal (fc, 0, NO_PIPE, NO_PIPE, fds_to_close);
4058 /* Run the RETURN trap in the function's context */
4059 save_current = currently_executing_command;
4061 currently_executing_command = save_current;
4064 result = execute_command_internal (fc, 0, NO_PIPE, NO_PIPE, fds_to_close);
4066 save_current = currently_executing_command;
4068 currently_executing_command = save_current;
4070 showing_function_line = 0;
4073 /* Restore BASH_ARGC and BASH_ARGV */
4078 run_unwind_frame ("function_calling");
4081 #if defined (ARRAY_VARS)
4082 /* These two variables cannot be unset, and cannot be affected by the
4084 array_pop (bash_source_a);
4085 array_pop (bash_lineno_a);
4087 /* FUNCNAME can be unset, and so can potentially be changed by the
4089 GET_ARRAY_FROM_VAR ("FUNCNAME", nfv, funcname_a);
4090 if (nfv == funcname_v)
4091 array_pop (funcname_a);
4094 if (variable_context == 0 || this_shell_function == 0)
4095 make_funcname_visible (0);
4100 /* A convenience routine for use by other parts of the shell to execute
4101 a particular shell function. */
4103 execute_shell_function (var, words)
4108 struct fd_bitmap *bitmap;
4110 bitmap = new_fd_bitmap (FD_BITMAP_DEFAULT_SIZE);
4111 begin_unwind_frame ("execute-shell-function");
4112 add_unwind_protect (dispose_fd_bitmap, (char *)bitmap);
4114 ret = execute_function (var, words, 0, bitmap, 0, 0);
4116 dispose_fd_bitmap (bitmap);
4117 discard_unwind_frame ("execute-shell-function");
4122 /* Execute a shell builtin or function in a subshell environment. This
4123 routine does not return; it only calls exit(). If BUILTIN is non-null,
4124 it points to a function to call to execute a shell builtin; otherwise
4125 VAR points at the body of a function to execute. WORDS is the arguments
4126 to the command, REDIRECTS specifies redirections to perform before the
4127 command is executed. */
4129 execute_subshell_builtin_or_function (words, redirects, builtin, var,
4130 pipe_in, pipe_out, async, fds_to_close,
4133 REDIRECT *redirects;
4134 sh_builtin_func_t *builtin;
4136 int pipe_in, pipe_out, async;
4137 struct fd_bitmap *fds_to_close;
4140 int result, r, funcvalue;
4141 #if defined (JOB_CONTROL)
4144 jobs_hack = (builtin == jobs_builtin) &&
4145 ((subshell_environment & SUBSHELL_ASYNC) == 0 || pipe_out != NO_PIPE);
4148 /* A subshell is neither a login shell nor interactive. */
4149 login_shell = interactive = 0;
4152 subshell_environment |= SUBSHELL_ASYNC;
4153 if (pipe_in != NO_PIPE || pipe_out != NO_PIPE)
4154 subshell_environment |= SUBSHELL_PIPE;
4156 maybe_make_export_env (); /* XXX - is this needed? */
4158 #if defined (JOB_CONTROL)
4159 /* Eradicate all traces of job control after we fork the subshell, so
4160 all jobs begun by this subshell are in the same process group as
4161 the shell itself. */
4163 /* Allow the output of `jobs' to be piped. */
4165 kill_current_pipeline ();
4167 without_job_control ();
4169 set_sigchld_handler ();
4170 #endif /* JOB_CONTROL */
4172 set_sigint_handler ();
4175 close_fd_bitmap (fds_to_close);
4177 do_piping (pipe_in, pipe_out);
4179 if (do_redirections (redirects, RX_ACTIVE) != 0)
4180 exit (EXECUTION_FAILURE);
4184 /* Give builtins a place to jump back to on failure,
4185 so we don't go back up to main(). */
4186 result = setjmp (top_level);
4188 /* Give the return builtin a place to jump to when executed in a subshell
4191 if (return_catch_flag && builtin == return_builtin)
4192 funcvalue = setjmp (return_catch);
4194 if (result == EXITPROG)
4195 exit (last_command_exit_value);
4197 exit (EXECUTION_FAILURE);
4199 exit (return_catch_value);
4202 r = execute_builtin (builtin, words, flags, 1);
4211 r = execute_function (var, words, flags, fds_to_close, async, 1);
4217 /* Execute a builtin or function in the current shell context. If BUILTIN
4218 is non-null, it is the builtin command to execute, otherwise VAR points
4219 to the body of a function. WORDS are the command's arguments, REDIRECTS
4220 are the redirections to perform. FDS_TO_CLOSE is the usual bitmap of
4221 file descriptors to close.
4223 If BUILTIN is exec_builtin, the redirections specified in REDIRECTS are
4224 not undone before this function returns. */
4226 execute_builtin_or_function (words, builtin, var, redirects,
4227 fds_to_close, flags)
4229 sh_builtin_func_t *builtin;
4231 REDIRECT *redirects;
4232 struct fd_bitmap *fds_to_close;
4236 REDIRECT *saved_undo_list;
4237 sh_builtin_func_t *saved_this_shell_builtin;
4239 if (do_redirections (redirects, RX_ACTIVE|RX_UNDOABLE) != 0)
4241 cleanup_redirects (redirection_undo_list);
4242 redirection_undo_list = (REDIRECT *)NULL;
4243 dispose_exec_redirects ();
4244 return (EX_REDIRFAIL); /* was EXECUTION_FAILURE */
4247 saved_this_shell_builtin = this_shell_builtin;
4248 saved_undo_list = redirection_undo_list;
4250 /* Calling the "exec" builtin changes redirections forever. */
4251 if (builtin == exec_builtin)
4253 dispose_redirects (saved_undo_list);
4254 saved_undo_list = exec_redirection_undo_list;
4255 exec_redirection_undo_list = (REDIRECT *)NULL;
4258 dispose_exec_redirects ();
4260 if (saved_undo_list)
4262 begin_unwind_frame ("saved redirects");
4263 add_unwind_protect (cleanup_redirects, (char *)saved_undo_list);
4266 redirection_undo_list = (REDIRECT *)NULL;
4269 result = execute_builtin (builtin, words, flags, 0);
4271 result = execute_function (var, words, flags, fds_to_close, 0, 0);
4273 /* We do this before undoing the effects of any redirections. */
4276 if (ferror (stdout))
4279 /* If we are executing the `command' builtin, but this_shell_builtin is
4280 set to `exec_builtin', we know that we have something like
4281 `command exec [redirection]', since otherwise `exec' would have
4282 overwritten the shell and we wouldn't get here. In this case, we
4283 want to behave as if the `command' builtin had not been specified
4284 and preserve the redirections. */
4285 if (builtin == command_builtin && this_shell_builtin == exec_builtin)
4287 if (saved_undo_list)
4288 dispose_redirects (saved_undo_list);
4289 redirection_undo_list = exec_redirection_undo_list;
4290 saved_undo_list = exec_redirection_undo_list = (REDIRECT *)NULL;
4291 discard_unwind_frame ("saved_redirects");
4294 if (saved_undo_list)
4296 redirection_undo_list = saved_undo_list;
4297 discard_unwind_frame ("saved redirects");
4300 if (redirection_undo_list)
4302 cleanup_redirects (redirection_undo_list);
4303 redirection_undo_list = (REDIRECT *)NULL;
4310 setup_async_signals ()
4312 #if defined (__BEOS__)
4313 set_signal_handler (SIGHUP, SIG_IGN); /* they want csh-like behavior */
4316 #if defined (JOB_CONTROL)
4317 if (job_control == 0)
4320 set_signal_handler (SIGINT, SIG_IGN);
4321 set_signal_ignored (SIGINT);
4322 set_signal_handler (SIGQUIT, SIG_IGN);
4323 set_signal_ignored (SIGQUIT);
4327 /* Execute a simple command that is hopefully defined in a disk file
4332 3) look up the command
4335 6) If the execve failed, see if the file has executable mode set.
4336 If so, and it isn't a directory, then execute its contents as
4339 Note that the filename hashing stuff has to take place up here,
4340 in the parent. This is probably why the Bourne style shells
4341 don't handle it, since that would require them to go through
4342 this gnarly hair, for no good reason.
4344 NOTE: callers expect this to fork or exit(). */
4346 /* Name of a shell function to call when a command name is not found. */
4347 #ifndef NOTFOUND_HOOK
4348 # define NOTFOUND_HOOK "command_not_found_handle"
4352 execute_disk_command (words, redirects, command_line, pipe_in, pipe_out,
4353 async, fds_to_close, cmdflags)
4355 REDIRECT *redirects;
4357 int pipe_in, pipe_out, async;
4358 struct fd_bitmap *fds_to_close;
4361 char *pathname, *command, **args;
4367 nofork = (cmdflags & CMD_NO_FORK); /* Don't fork, just exec, if no pipes */
4368 pathname = words->word->word;
4370 #if defined (RESTRICTED_SHELL)
4371 command = (char *)NULL;
4372 if (restricted && xstrchr (pathname, '/'))
4374 internal_error (_("%s: restricted: cannot specify `/' in command names"),
4376 last_command_exit_value = EXECUTION_FAILURE;
4378 /* If we're not going to fork below, we must already be in a child
4379 process or a context in which it's safe to call exit(2). */
4380 if (nofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE)
4381 exit (last_command_exit_value);
4385 #endif /* RESTRICTED_SHELL */
4387 command = search_for_command (pathname);
4391 maybe_make_export_env ();
4392 put_command_name_into_env (command);
4395 /* We have to make the child before we check for the non-existence
4396 of COMMAND, since we want the error messages to be redirected. */
4397 /* If we can get away without forking and there are no pipes to deal with,
4398 don't bother to fork, just directly exec the command. */
4399 if (nofork && pipe_in == NO_PIPE && pipe_out == NO_PIPE)
4402 pid = make_child (savestring (command_line), async);
4406 int old_interactive;
4409 /* This has been disabled for the time being. */
4410 #if !defined (ARG_MAX) || ARG_MAX >= 10240
4411 if (posixly_correct == 0)
4412 put_gnu_argv_flags_into_env ((long)getpid (), glob_argv_flags);
4416 /* Cancel traps, in trap.c. */
4417 restore_original_signals ();
4419 /* restore_original_signals may have undone the work done
4420 by make_child to ensure that SIGINT and SIGQUIT are ignored
4421 in asynchronous children. */
4424 if ((cmdflags & CMD_STDIN_REDIR) &&
4425 pipe_in == NO_PIPE &&
4426 (stdin_redirects (redirects) == 0))
4427 async_redirect_stdin ();
4428 setup_async_signals ();
4431 /* This functionality is now provided by close-on-exec of the
4432 file descriptors manipulated by redirection and piping.
4433 Some file descriptors still need to be closed in all children
4434 because of the way bash does pipes; fds_to_close is a
4435 bitmap of all such file descriptors. */
4437 close_fd_bitmap (fds_to_close);
4439 do_piping (pipe_in, pipe_out);
4441 old_interactive = interactive;
4445 subshell_environment = SUBSHELL_FORK;
4447 if (redirects && (do_redirections (redirects, RX_ACTIVE) != 0))
4449 #if defined (PROCESS_SUBSTITUTION)
4450 /* Try to remove named pipes that may have been created as the
4451 result of redirections. */
4452 unlink_fifo_list ();
4453 #endif /* PROCESS_SUBSTITUTION */
4454 exit (EXECUTION_FAILURE);
4458 interactive = old_interactive;
4462 hookf = find_function (NOTFOUND_HOOK);
4465 internal_error (_("%s: command not found"), pathname);
4466 exit (EX_NOTFOUND); /* Posix.2 says the exit status is 127 */
4469 wl = make_word_list (make_word (NOTFOUND_HOOK), words);
4470 exit (execute_shell_function (hookf, wl));
4473 /* Execve expects the command name to be in args[0]. So we
4474 leave it there, in the same format that the user used to
4476 args = strvec_from_word_list (words, 0, 0, (int *)NULL);
4477 exit (shell_execve (command, args, export_env));
4482 /* Make sure that the pipes are closed in the parent. */
4483 close_pipes (pipe_in, pipe_out);
4484 #if defined (PROCESS_SUBSTITUTION) && defined (HAVE_DEV_FD)
4485 unlink_fifo_list ();
4491 /* CPP defines to decide whether a particular index into the #! line
4492 corresponds to a valid interpreter name or argument character, or
4493 whitespace. The MSDOS define is to allow \r to be treated the same
4496 #if !defined (MSDOS)
4497 # define STRINGCHAR(ind) \
4498 (ind < sample_len && !whitespace (sample[ind]) && sample[ind] != '\n')
4499 # define WHITECHAR(ind) \
4500 (ind < sample_len && whitespace (sample[ind]))
4502 # define STRINGCHAR(ind) \
4503 (ind < sample_len && !whitespace (sample[ind]) && sample[ind] != '\n' && sample[ind] != '\r')
4504 # define WHITECHAR(ind) \
4505 (ind < sample_len && whitespace (sample[ind]))
4509 getinterp (sample, sample_len, endp)
4511 int sample_len, *endp;
4517 /* Find the name of the interpreter to exec. */
4518 for (i = 2; i < sample_len && whitespace (sample[i]); i++)
4521 for (start = i; STRINGCHAR(i); i++)
4524 execname = substring (sample, start, i);
4531 #if !defined (HAVE_HASH_BANG_EXEC)
4532 /* If the operating system on which we're running does not handle
4533 the #! executable format, then help out. SAMPLE is the text read
4534 from the file, SAMPLE_LEN characters. COMMAND is the name of
4535 the script; it and ARGS, the arguments given by the user, will
4536 become arguments to the specified interpreter. ENV is the environment
4537 to pass to the interpreter.
4539 The word immediately following the #! is the interpreter to execute.
4540 A single argument to the interpreter is allowed. */
4543 execute_shell_script (sample, sample_len, command, args, env)
4549 char *execname, *firstarg;
4550 int i, start, size_increment, larry;
4552 /* Find the name of the interpreter to exec. */
4553 execname = getinterp (sample, sample_len, &i);
4556 /* Now the argument, if any. */
4557 for (firstarg = (char *)NULL, start = i; WHITECHAR(i); i++)
4560 /* If there is more text on the line, then it is an argument for the
4565 for (start = i; STRINGCHAR(i); i++)
4567 firstarg = substring ((char *)sample, start, i);
4571 larry = strvec_len (args) + size_increment;
4572 args = strvec_resize (args, larry + 1);
4574 for (i = larry - 1; i; i--)
4575 args[i] = args[i - size_increment];
4586 args[larry] = (char *)NULL;
4588 return (shell_execve (execname, args, env));
4593 #endif /* !HAVE_HASH_BANG_EXEC */
4596 initialize_subshell ()
4599 /* Forget about any aliases that we knew of. We are in a subshell. */
4600 delete_all_aliases ();
4603 #if defined (HISTORY)
4604 /* Forget about the history lines we have read. This is a non-interactive
4606 history_lines_this_session = 0;
4609 #if defined (JOB_CONTROL)
4610 /* Forget about the way job control was working. We are in a subshell. */
4611 without_job_control ();
4612 set_sigchld_handler ();
4614 #endif /* JOB_CONTROL */
4616 /* Reset the values of the shell flags and options. */
4617 reset_shell_flags ();
4618 reset_shell_options ();
4619 reset_shopt_options ();
4621 /* Zero out builtin_env, since this could be a shell script run from a
4622 sourced file with a temporary environment supplied to the `source/.'
4623 builtin. Such variables are not supposed to be exported (empirical
4624 testing with sh and ksh). Just throw it away; don't worry about a
4626 if (vc_isbltnenv (shell_variables))
4627 shell_variables = shell_variables->down;
4629 clear_unwind_protect_list (0);
4630 /* XXX -- are there other things we should be resetting here? */
4631 parse_and_execute_level = 0; /* nothing left to restore it */
4633 /* We're no longer inside a shell function. */
4634 variable_context = return_catch_flag = 0;
4636 executing_list = 0; /* XXX */
4638 /* If we're not interactive, close the file descriptor from which we're
4639 reading the current shell script. */
4640 if (interactive_shell == 0)
4641 unset_bash_input (0);
4644 #if defined (HAVE_SETOSTYPE) && defined (_POSIX_SOURCE)
4645 # define SETOSTYPE(x) __setostype(x)
4647 # define SETOSTYPE(x)
4650 #define READ_SAMPLE_BUF(file, buf, len) \
4653 fd = open(file, O_RDONLY); \
4656 len = read (fd, buf, 80); \
4664 /* Call execve (), handling interpreting shell scripts, and handling
4667 shell_execve (command, args, env)
4675 SETOSTYPE (0); /* Some systems use for USG/POSIX semantics */
4676 execve (command, args, env);
4677 i = errno; /* error from execve() */
4681 /* If we get to this point, then start checking out the file.
4682 Maybe it is something we can hack ourselves. */
4685 if (file_isdir (command))
4686 internal_error (_("%s: is a directory"), command);
4687 else if (executable_file (command) == 0)
4690 file_error (command);
4692 /* errors not involving the path argument to execve. */
4693 else if (i == E2BIG || i == ENOMEM)
4696 file_error (command);
4700 /* The file has the execute bits set, but the kernel refuses to
4701 run it for some reason. See why. */
4702 #if defined (HAVE_HASH_BANG_EXEC)
4703 READ_SAMPLE_BUF (command, sample, sample_len);
4704 if (sample_len > 2 && sample[0] == '#' && sample[1] == '!')
4709 interp = getinterp (sample, sample_len, (int *)NULL);
4710 ilen = strlen (interp);
4712 if (interp[ilen - 1] == '\r')
4714 interp = xrealloc (interp, ilen + 2);
4715 interp[ilen - 1] = '^';
4717 interp[ilen + 1] = '\0';
4719 sys_error (_("%s: %s: bad interpreter"), command, interp ? interp : "");
4725 file_error (command);
4727 return ((i == ENOENT) ? EX_NOTFOUND : EX_NOEXEC); /* XXX Posix.2 says that exit status is 126 */
4730 /* This file is executable.
4731 If it begins with #!, then help out people with losing operating
4732 systems. Otherwise, check to see if it is a binary file by seeing
4733 if the contents of the first line (or up to 80 characters) are in the
4734 ASCII set. If it's a text file, execute the contents as shell commands,
4735 otherwise return 126 (EX_BINARY_FILE). */
4736 READ_SAMPLE_BUF (command, sample, sample_len);
4738 if (sample_len == 0)
4739 return (EXECUTION_SUCCESS);
4741 /* Is this supposed to be an executable script?
4742 If so, the format of the line is "#! interpreter [argument]".
4743 A single argument is allowed. The BSD kernel restricts
4744 the length of the entire line to 32 characters (32 bytes
4745 being the size of the BSD exec header), but we allow 80
4749 #if !defined (HAVE_HASH_BANG_EXEC)
4750 if (sample_len > 2 && sample[0] == '#' && sample[1] == '!')
4751 return (execute_shell_script (sample, sample_len, command, args, env));
4754 if (check_binary_file (sample, sample_len))
4756 internal_error (_("%s: cannot execute binary file"), command);
4757 return (EX_BINARY_FILE);
4761 /* We have committed to attempting to execute the contents of this file
4762 as shell commands. */
4764 initialize_subshell ();
4766 set_sigint_handler ();
4768 /* Insert the name of this shell into the argument list. */
4769 larray = strvec_len (args) + 1;
4770 args = strvec_resize (args, larray + 1);
4772 for (i = larray - 1; i; i--)
4773 args[i] = args[i - 1];
4775 args[0] = shell_name;
4777 args[larray] = (char *)NULL;
4779 if (args[0][0] == '-')
4782 #if defined (RESTRICTED_SHELL)
4784 change_flag ('r', FLAG_OFF);
4789 /* Can't free subshell_argv[0]; that is shell_name. */
4790 for (i = 1; i < subshell_argc; i++)
4791 free (subshell_argv[i]);
4792 free (subshell_argv);
4795 dispose_command (currently_executing_command); /* XXX */
4796 currently_executing_command = (COMMAND *)NULL;
4798 subshell_argc = larray;
4799 subshell_argv = args;
4800 subshell_envp = env;
4802 unbind_args (); /* remove the positional parameters */
4804 longjmp (subshell_top_level, 1);
4809 execute_intern_function (name, function)
4815 if (check_identifier (name, posixly_correct) == 0)
4817 if (posixly_correct && interactive_shell == 0)
4819 last_command_exit_value = EX_BADUSAGE;
4820 jump_to_top_level (ERREXIT);
4822 return (EXECUTION_FAILURE);
4825 var = find_function (name->word);
4826 if (var && (readonly_p (var) || noassign_p (var)))
4828 if (readonly_p (var))
4829 internal_error (_("%s: readonly function"), var->name);
4830 return (EXECUTION_FAILURE);
4833 bind_function (name->word, function);
4834 return (EXECUTION_SUCCESS);
4837 #if defined (INCLUDE_UNUSED)
4838 #if defined (PROCESS_SUBSTITUTION)
4842 register int i, fd_table_size;
4844 fd_table_size = getdtablesize ();
4845 if (fd_table_size > 256) /* clamp to a reasonable value */
4846 fd_table_size = 256;
4848 for (i = 3; i < fd_table_size; i++)
4851 #endif /* PROCESS_SUBSTITUTION */
4855 close_pipes (in, out)
4865 dup_error (oldd, newd)
4868 sys_error (_("cannot duplicate fd %d to fd %d"), oldd, newd);
4871 /* Redirect input and output to be from and to the specified pipes.
4872 NO_PIPE and REDIRECT_BOTH are handled correctly. */
4874 do_piping (pipe_in, pipe_out)
4875 int pipe_in, pipe_out;
4877 if (pipe_in != NO_PIPE)
4879 if (dup2 (pipe_in, 0) < 0)
4880 dup_error (pipe_in, 0);
4884 if (pipe_out != NO_PIPE)
4886 if (pipe_out != REDIRECT_BOTH)
4888 if (dup2 (pipe_out, 1) < 0)
4889 dup_error (pipe_out, 1);
4890 if (pipe_out == 0 || pipe_out > 1)
4895 if (dup2 (1, 2) < 0)