1 /* evalstring.c - evaluate a string as one or more shell commands. */
3 /* Copyright (C) 1996-2012 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 (HAVE_UNISTD_H)
25 # include <sys/types.h>
36 #include "../bashansi.h"
40 #include "../builtins.h"
43 #include "../execute_cmd.h"
46 #include "../bashintl.h"
51 # include "../bashhist.h"
61 #define IS_BUILTIN(s) (builtin_address_internal(s, 0) != (struct builtin *)NULL)
63 extern int indirection_level, subshell_environment;
64 extern int line_number, line_number_for_err_trap;
65 extern int current_token, shell_eof_token;
66 extern int last_command_exit_value;
67 extern int running_trap;
68 extern int loop_level;
69 extern int executing_list;
70 extern int comsub_ignore_return;
71 extern int posixly_correct;
72 extern int return_catch_flag, return_catch_value;
73 extern sh_builtin_func_t *this_shell_builtin;
74 extern char *the_printed_command_except_trap;
76 int parse_and_execute_level = 0;
78 static int cat_file __P((REDIRECT *));
80 #define PE_TAG "parse_and_execute top"
81 #define PS_TAG "parse_string top"
85 set_history_remembering ()
87 remember_on_history = enable_history_list;
95 FREE (the_printed_command_except_trap);
96 the_printed_command_except_trap = x;
99 /* How to force parse_and_execute () to clean up after itself. */
101 parse_and_execute_cleanup ()
105 run_trap_cleanup (running_trap - 1);
106 unfreeze_jobs_list ();
109 if (have_unwind_protects ())
110 run_unwind_frame (PE_TAG);
112 parse_and_execute_level = 0; /* XXX */
116 parse_prologue (string, flags, tag)
121 char *orig_string, *lastcom;
124 orig_string = string;
125 /* Unwind protect this invocation of parse_and_execute (). */
126 begin_unwind_frame (tag);
127 unwind_protect_int (parse_and_execute_level);
128 unwind_protect_jmp_buf (top_level);
129 unwind_protect_int (indirection_level);
130 unwind_protect_int (line_number);
131 unwind_protect_int (line_number_for_err_trap);
132 unwind_protect_int (loop_level);
133 unwind_protect_int (executing_list);
134 unwind_protect_int (comsub_ignore_return);
135 if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
136 unwind_protect_int (interactive);
138 #if defined (HISTORY)
139 if (parse_and_execute_level == 0)
140 add_unwind_protect (set_history_remembering, (char *)NULL);
142 unwind_protect_int (remember_on_history); /* can be used in scripts */
143 # if defined (BANG_HISTORY)
144 if (interactive_shell)
145 unwind_protect_int (history_expansion_inhibited);
146 # endif /* BANG_HISTORY */
149 if (interactive_shell)
151 x = get_current_prompt_level ();
152 add_unwind_protect (set_current_prompt_level, x);
155 if (the_printed_command_except_trap)
157 lastcom = savestring (the_printed_command_except_trap);
158 add_unwind_protect (restore_lastcom, lastcom);
161 add_unwind_protect (pop_stream, (char *)NULL);
162 if (parser_expanding_alias ())
163 add_unwind_protect (parser_restore_alias, (char *)NULL);
165 if (orig_string && ((flags & SEVAL_NOFREE) == 0))
166 add_unwind_protect (xfree, orig_string);
169 if (flags & (SEVAL_NONINT|SEVAL_INTERACT))
170 interactive = (flags & SEVAL_NONINT) ? 0 : 1;
172 #if defined (HISTORY)
173 if (flags & SEVAL_NOHIST)
174 bash_history_disable ();
178 /* Parse and execute the commands in STRING. Returns whatever
179 execute_command () returns. This frees STRING. FLAGS is a
180 flags word; look in common.h for the possible values. Actions
182 (flags & SEVAL_NONINT) -> interactive = 0;
183 (flags & SEVAL_INTERACT) -> interactive = 1;
184 (flags & SEVAL_NOHIST) -> call bash_history_disable ()
185 (flags & SEVAL_NOFREE) -> don't free STRING when finished
186 (flags & SEVAL_RESETLINE) -> reset line_number to 1
190 parse_and_execute (string, from_file, flags)
192 const char *from_file;
196 volatile int should_jump_to_top_level, last_result;
197 COMMAND *volatile command;
198 volatile sigset_t pe_sigmask;
200 parse_prologue (string, flags, PE_TAG);
202 parse_and_execute_level++;
204 lreset = flags & SEVAL_RESETLINE;
206 #if defined (HAVE_POSIX_SIGNALS)
207 /* If we longjmp and are going to go on, use this to restore signal mask */
208 sigemptyset (&pe_sigmask);
209 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &pe_sigmask);
212 /* Reset the line number if the caller wants us to. If we don't reset the
213 line number, we have to subtract one, because we will add one just
214 before executing the next command (resetting the line number sets it to
215 0; the first line number is 1). */
216 push_stream (lreset);
217 if (parser_expanding_alias ())
218 /* push current shell_input_line */
219 parser_save_alias ();
226 code = should_jump_to_top_level = 0;
227 last_result = EXECUTION_SUCCESS;
229 with_input_from_string (string, from_file);
230 while (*(bash_input.location.string))
232 command = (COMMAND *)NULL;
236 last_result = EXECUTION_FAILURE;
240 /* Provide a location for functions which `longjmp (top_level)' to
241 jump to. This prevents errors in substitution from restarting
242 the reader loop directly, for example. */
243 code = setjmp_nosigs (top_level);
247 should_jump_to_top_level = 0;
251 /* variable_context -> 0 is what eval.c:reader_loop() does in
252 these circumstances. Don't bother with cleanup here because
253 we don't want to run the function execution cleanup stuff
254 that will cause pop_context and other functions to run.
255 XXX - change that if we want the function context to be
257 if (exit_immediately_on_error && variable_context)
259 discard_unwind_frame ("pe_dispose");
260 variable_context = 0; /* not in a function */
262 should_jump_to_top_level = 1;
267 run_unwind_frame ("pe_dispose");
268 /* Remember to call longjmp (top_level) after the old
269 value for it is restored. */
270 should_jump_to_top_level = 1;
275 run_unwind_frame ("pe_dispose");
276 last_result = last_command_exit_value = EXECUTION_FAILURE; /* XXX */
277 if (subshell_environment)
279 should_jump_to_top_level = 1;
285 dispose_command (command); /* pe_dispose does this */
287 #if defined (HAVE_POSIX_SIGNALS)
288 sigprocmask (SIG_SETMASK, &pe_sigmask, (sigset_t *)NULL);
294 command_error ("parse_and_execute", CMDERR_BADJUMP, code, 0);
299 if (parse_command () == 0)
301 if ((flags & SEVAL_PARSEONLY) || (interactive_shell == 0 && read_but_dont_execute))
303 last_result = EXECUTION_SUCCESS;
304 dispose_command (global_command);
305 global_command = (COMMAND *)NULL;
307 else if (command = global_command)
309 struct fd_bitmap *bitmap;
311 if ((flags & SEVAL_FUNCDEF) && command->type != cm_function_def)
313 internal_warning ("%s: ignoring function definition attempt", from_file);
314 should_jump_to_top_level = 0;
315 last_result = last_command_exit_value = EX_BADUSAGE;
319 bitmap = new_fd_bitmap (FD_BITMAP_SIZE);
320 begin_unwind_frame ("pe_dispose");
321 add_unwind_protect (dispose_fd_bitmap, bitmap);
322 add_unwind_protect (dispose_command, command); /* XXX */
324 global_command = (COMMAND *)NULL;
326 if ((subshell_environment & SUBSHELL_COMSUB) && comsub_ignore_return)
327 command->flags |= CMD_IGNORE_RETURN;
329 #if defined (ONESHOT)
332 * we were invoked as `bash -c' (startup_state == 2) AND
333 * parse_and_execute has not been called recursively AND
334 * we're not running a trap AND
335 * we have parsed the full command (string == '\0') AND
336 * we're not going to run the exit trap AND
337 * we have a simple command without redirections AND
338 * the command is not being timed AND
339 * the command's return status is not being inverted
341 * tell the execution code that we don't need to fork
343 if (startup_state == 2 && parse_and_execute_level == 1 &&
345 *bash_input.location.string == '\0' &&
346 command->type == cm_simple &&
347 signal_is_trapped (EXIT_TRAP) == 0 &&
348 command->redirects == 0 && command->value.Simple->redirects == 0 &&
349 ((command->flags & CMD_TIME_PIPELINE) == 0) &&
350 ((command->flags & CMD_INVERT_RETURN) == 0))
352 command->flags |= CMD_NO_FORK;
353 command->value.Simple->flags |= CMD_NO_FORK;
357 /* See if this is a candidate for $( <file ). */
358 if (startup_state == 2 &&
359 (subshell_environment & SUBSHELL_COMSUB) &&
360 *bash_input.location.string == '\0' &&
361 command->type == cm_simple && !command->redirects &&
362 (command->flags & CMD_TIME_PIPELINE) == 0 &&
363 command->value.Simple->words == 0 &&
364 command->value.Simple->redirects &&
365 command->value.Simple->redirects->next == 0 &&
366 command->value.Simple->redirects->instruction == r_input_direction &&
367 command->value.Simple->redirects->redirector.dest == 0)
370 r = cat_file (command->value.Simple->redirects);
371 last_result = (r < 0) ? EXECUTION_FAILURE : EXECUTION_SUCCESS;
374 last_result = execute_command_internal
375 (command, 0, NO_PIPE, NO_PIPE, bitmap);
376 dispose_command (command);
377 dispose_fd_bitmap (bitmap);
378 discard_unwind_frame ("pe_dispose");
380 if (flags & SEVAL_ONECMD)
386 last_result = EXECUTION_FAILURE;
388 if (interactive_shell == 0 && this_shell_builtin &&
389 (this_shell_builtin == source_builtin || this_shell_builtin == eval_builtin) &&
390 last_command_exit_value == EX_BADSYNTAX && posixly_correct)
392 should_jump_to_top_level = 1;
394 last_command_exit_value = EX_BADUSAGE;
397 /* Since we are shell compatible, syntax errors in a script
398 abort the execution of the script. Right? */
405 run_unwind_frame (PE_TAG);
407 if (interrupt_state && parse_and_execute_level == 0)
409 /* An interrupt during non-interactive execution in an
410 interactive shell (e.g. via $PROMPT_COMMAND) should
411 not cause the shell to exit. */
412 interactive = interactive_shell;
413 throw_to_top_level ();
416 if (should_jump_to_top_level)
417 jump_to_top_level (code);
419 return (last_result);
422 /* Parse a command contained in STRING according to FLAGS and return the
423 number of characters consumed from the string. If non-NULL, set *ENDP
424 to the position in the string where the parse ended. Used to validate
425 command substitutions during parsing to obey Posix rules about finding
426 the end of the command and balancing parens. */
428 parse_string (string, from_file, flags, endp)
430 const char *from_file;
435 volatile int should_jump_to_top_level;
436 COMMAND *volatile command, *oglobal;
438 volatile sigset_t ps_sigmask;
440 parse_prologue (string, flags, PS_TAG);
442 #if defined (HAVE_POSIX_SIGNALS)
443 /* If we longjmp and are going to go on, use this to restore signal mask */
444 sigemptyset (&ps_sigmask);
445 sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &ps_sigmask);
448 /* itrace("parse_string: `%s'", string); */
449 /* Reset the line number if the caller wants us to. If we don't reset the
450 line number, we have to subtract one, because we will add one just
451 before executing the next command (resetting the line number sets it to
452 0; the first line number is 1). */
454 if (parser_expanding_alias ())
455 /* push current shell_input_line */
456 parser_save_alias ();
458 code = should_jump_to_top_level = 0;
459 oglobal = global_command;
462 with_input_from_string (string, from_file);
463 while (*(bash_input.location.string))
465 command = (COMMAND *)NULL;
472 /* Provide a location for functions which `longjmp (top_level)' to
474 code = setjmp_nosigs (top_level);
479 itrace("parse_string: longjmp executed: code = %d", code);
481 should_jump_to_top_level = 0;
487 case DISCARD: /* XXX */
489 dispose_command (command);
490 /* Remember to call longjmp (top_level) after the old
491 value for it is restored. */
492 should_jump_to_top_level = 1;
496 #if defined (HAVE_POSIX_SIGNALS)
497 sigprocmask (SIG_SETMASK, &ps_sigmask, (sigset_t *)NULL);
499 command_error ("parse_string", CMDERR_BADJUMP, code, 0);
504 if (parse_command () == 0)
506 dispose_command (global_command);
507 global_command = (COMMAND *)NULL;
511 if ((flags & SEVAL_NOLONGJMP) == 0)
513 should_jump_to_top_level = 1;
517 reset_parser (); /* XXX - sets token_to_read */
521 if (current_token == yacc_EOF || current_token == shell_eof_token)
527 global_command = oglobal;
528 nc = bash_input.location.string - ostring;
530 *endp = bash_input.location.string;
532 run_unwind_frame (PS_TAG);
534 if (should_jump_to_top_level)
535 jump_to_top_level (code);
540 /* Handle a $( < file ) command substitution. This expands the filename,
541 returning errors as appropriate, then just cats the file to the standard
550 if (r->instruction != r_input_direction)
553 /* Get the filename. */
554 if (posixly_correct && !interactive_shell)
555 disallow_filename_globbing++;
556 fn = redirection_expand (r->redirectee.filename);
557 if (posixly_correct && !interactive_shell)
558 disallow_filename_globbing--;
562 redirection_error (r, AMBIGUOUS_REDIRECT);
566 fd = open(fn, O_RDONLY);
574 rval = zcatfd (fd, 1, fn);
583 evalstring (string, from_file, flags)
585 const char *from_file;
588 volatile int r, rflag, rcatch;
591 rflag = return_catch_flag;
592 /* If we are in a place where `return' is valid, we have to catch
593 `eval "... return"' and make sure parse_and_execute cleans up. Then
594 we can trampoline to the previous saved return_catch location. */
597 begin_unwind_frame ("evalstring");
599 unwind_protect_int (return_catch_flag);
600 unwind_protect_jmp_buf (return_catch);
602 return_catch_flag++; /* increment so we have a counter */
603 rcatch = setjmp_nosigs (return_catch);
608 parse_and_execute_cleanup ();
609 r = return_catch_value;
612 /* Note that parse_and_execute () frees the string it is passed. */
613 r = parse_and_execute (string, from_file, flags);
617 run_unwind_frame ("evalstring");
618 if (rcatch && return_catch_flag)
620 return_catch_value = r;
621 longjmp (return_catch, 1);