1 /* make_cmd.c -- Functions for making instances of the various
4 /* Copyright (C) 1989-2009 Free Software Foundation, Inc.
6 This file is part of GNU Bash, the Bourne Again SHell.
8 Bash is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Bash is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Bash. If not, see <http://www.gnu.org/licenses/>.
25 #include "bashtypes.h"
26 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
27 # include <sys/file.h>
31 #if defined (HAVE_UNISTD_H)
44 #include "dispose_cmd.h"
45 #include "variables.h"
51 #if defined (JOB_CONTROL)
57 extern int line_number
, current_command_line_count
, parser_state
;
58 extern int last_command_exit_value
;
59 extern int shell_initialized
;
61 int here_doc_first_line
= 0;
64 sh_obj_cache_t wdcache
= {0, 0, 0};
65 sh_obj_cache_t wlcache
= {0, 0, 0};
67 #define WDCACHESIZE 128
68 #define WLCACHESIZE 128
70 static COMMAND
*make_for_or_select
__P((enum command_type
, WORD_DESC
*, WORD_LIST
*, COMMAND
*, int));
71 #if defined (ARITH_FOR_COMMAND)
72 static WORD_LIST
*make_arith_for_expr
__P((char *));
74 static COMMAND
*make_until_or_while
__P((enum command_type
, COMMAND
*, COMMAND
*));
79 ocache_create (wdcache
, WORD_DESC
, WDCACHESIZE
);
80 ocache_create (wlcache
, WORD_LIST
, WLCACHESIZE
);
88 ocache_alloc (wdcache
, WORD_DESC
, temp
);
95 make_bare_word (string
)
100 temp
= alloc_word_desc ();
103 temp
->word
= savestring (string
);
106 temp
->word
= (char *)xmalloc (1);
107 temp
->word
[0] = '\0';
114 make_word_flags (w
, string
)
123 slen
= strlen (string
);
129 w
->flags
|= W_HASDOLLAR
;
132 break; /* continue the loop */
136 w
->flags
|= W_QUOTED
;
140 ADVANCE_CHAR (string
, slen
, i
);
152 temp
= make_bare_word (string
);
153 return (make_word_flags (temp
, string
));
157 make_word_from_token (token
)
162 tokenizer
[0] = token
;
165 return (make_word (tokenizer
));
169 make_word_list (word
, wlink
)
175 ocache_alloc (wlcache
, WORD_LIST
, temp
);
183 make_command (type
, pointer
)
184 enum command_type type
;
189 temp
= (COMMAND
*)xmalloc (sizeof (COMMAND
));
191 temp
->value
.Simple
= pointer
;
192 temp
->value
.Simple
->flags
= temp
->flags
= 0;
193 temp
->redirects
= (REDIRECT
*)NULL
;
198 command_connect (com1
, com2
, connector
)
199 COMMAND
*com1
, *com2
;
204 temp
= (CONNECTION
*)xmalloc (sizeof (CONNECTION
));
205 temp
->connector
= connector
;
208 return (make_command (cm_connection
, (SIMPLE_COM
*)temp
));
212 make_for_or_select (type
, name
, map_list
, action
, lineno
)
213 enum command_type type
;
221 temp
= (FOR_COM
*)xmalloc (sizeof (FOR_COM
));
225 temp
->map_list
= map_list
;
226 temp
->action
= action
;
227 return (make_command (type
, (SIMPLE_COM
*)temp
));
231 make_for_command (name
, map_list
, action
, lineno
)
237 return (make_for_or_select (cm_for
, name
, map_list
, action
, lineno
));
241 make_select_command (name
, map_list
, action
, lineno
)
247 #if defined (SELECT_COMMAND)
248 return (make_for_or_select (cm_select
, name
, map_list
, action
, lineno
));
250 last_command_exit_value
= 2;
251 return ((COMMAND
*)NULL
);
255 #if defined (ARITH_FOR_COMMAND)
257 make_arith_for_expr (s
)
263 if (s
== 0 || *s
== '\0')
264 return ((WORD_LIST
*)NULL
);
266 wd
->flags
|= W_NOGLOB
|W_NOSPLIT
|W_QUOTED
|W_DQUOTE
; /* no word splitting or globbing */
267 #if defined (PROCESS_SUBSTITUTION)
268 wd
->flags
|= W_NOPROCSUB
; /* no process substitution */
270 result
= make_word_list (wd
, (WORD_LIST
*)NULL
);
275 /* Note that this function calls dispose_words on EXPRS, since it doesn't
276 use the word list directly. We free it here rather than at the caller
277 because no other function in this file requires that the caller free
280 make_arith_for_command (exprs
, action
, lineno
)
285 #if defined (ARITH_FOR_COMMAND)
287 WORD_LIST
*init
, *test
, *step
;
291 init
= test
= step
= (WORD_LIST
*)NULL
;
292 /* Parse the string into the three component sub-expressions. */
293 start
= t
= s
= exprs
->word
->word
;
296 /* skip whitespace at the start of each sub-expression. */
297 while (whitespace (*s
))
300 /* skip to the semicolon or EOS */
301 i
= skip_to_delim (start
, 0, ";", SD_NOJMP
|SD_NOPROCSUB
);
304 t
= (i
> 0) ? substring (start
, 0, i
) : (char *)NULL
;
310 init
= make_arith_for_expr (t
);
313 test
= make_arith_for_expr (t
);
316 step
= make_arith_for_expr (t
);
323 s
++; /* skip over semicolon */
329 parser_error (lineno
, _("syntax error: arithmetic expression required"));
331 parser_error (lineno
, _("syntax error: `;' unexpected"));
332 parser_error (lineno
, _("syntax error: `((%s))'"), exprs
->word
->word
);
336 last_command_exit_value
= 2;
337 return ((COMMAND
*)NULL
);
340 temp
= (ARITH_FOR_COM
*)xmalloc (sizeof (ARITH_FOR_COM
));
343 temp
->init
= init
? init
: make_arith_for_expr ("1");
344 temp
->test
= test
? test
: make_arith_for_expr ("1");
345 temp
->step
= step
? step
: make_arith_for_expr ("1");
346 temp
->action
= action
;
348 dispose_words (exprs
);
349 return (make_command (cm_arith_for
, (SIMPLE_COM
*)temp
));
351 dispose_words (exprs
);
352 last_command_exit_value
= 2;
353 return ((COMMAND
*)NULL
);
354 #endif /* ARITH_FOR_COMMAND */
358 make_group_command (command
)
363 temp
= (GROUP_COM
*)xmalloc (sizeof (GROUP_COM
));
364 temp
->command
= command
;
365 return (make_command (cm_group
, (SIMPLE_COM
*)temp
));
369 make_case_command (word
, clauses
, lineno
)
371 PATTERN_LIST
*clauses
;
376 temp
= (CASE_COM
*)xmalloc (sizeof (CASE_COM
));
380 temp
->clauses
= REVERSE_LIST (clauses
, PATTERN_LIST
*);
381 return (make_command (cm_case
, (SIMPLE_COM
*)temp
));
385 make_pattern_list (patterns
, action
)
391 temp
= (PATTERN_LIST
*)xmalloc (sizeof (PATTERN_LIST
));
392 temp
->patterns
= REVERSE_LIST (patterns
, WORD_LIST
*);
393 temp
->action
= action
;
400 make_if_command (test
, true_case
, false_case
)
401 COMMAND
*test
, *true_case
, *false_case
;
405 temp
= (IF_COM
*)xmalloc (sizeof (IF_COM
));
408 temp
->true_case
= true_case
;
409 temp
->false_case
= false_case
;
410 return (make_command (cm_if
, (SIMPLE_COM
*)temp
));
414 make_until_or_while (which
, test
, action
)
415 enum command_type which
;
416 COMMAND
*test
, *action
;
420 temp
= (WHILE_COM
*)xmalloc (sizeof (WHILE_COM
));
423 temp
->action
= action
;
424 return (make_command (which
, (SIMPLE_COM
*)temp
));
428 make_while_command (test
, action
)
429 COMMAND
*test
, *action
;
431 return (make_until_or_while (cm_while
, test
, action
));
435 make_until_command (test
, action
)
436 COMMAND
*test
, *action
;
438 return (make_until_or_while (cm_until
, test
, action
));
442 make_arith_command (exp
)
445 #if defined (DPAREN_ARITHMETIC)
449 command
= (COMMAND
*)xmalloc (sizeof (COMMAND
));
450 command
->value
.Arith
= temp
= (ARITH_COM
*)xmalloc (sizeof (ARITH_COM
));
453 temp
->line
= line_number
;
456 command
->type
= cm_arith
;
457 command
->redirects
= (REDIRECT
*)NULL
;
462 last_command_exit_value
= 2;
463 return ((COMMAND
*)NULL
);
467 #if defined (COND_COMMAND)
469 make_cond_node (type
, op
, left
, right
)
472 struct cond_com
*left
, *right
;
476 temp
= (COND_COM
*)xmalloc (sizeof (COND_COM
));
478 temp
->line
= line_number
;
489 make_cond_command (cond_node
)
492 #if defined (COND_COMMAND)
495 command
= (COMMAND
*)xmalloc (sizeof (COMMAND
));
496 command
->value
.Cond
= cond_node
;
498 command
->type
= cm_cond
;
499 command
->redirects
= (REDIRECT
*)NULL
;
501 command
->line
= cond_node
? cond_node
->line
: 0;
505 last_command_exit_value
= 2;
506 return ((COMMAND
*)NULL
);
511 make_bare_simple_command ()
516 command
= (COMMAND
*)xmalloc (sizeof (COMMAND
));
517 command
->value
.Simple
= temp
= (SIMPLE_COM
*)xmalloc (sizeof (SIMPLE_COM
));
520 temp
->line
= line_number
;
521 temp
->words
= (WORD_LIST
*)NULL
;
522 temp
->redirects
= (REDIRECT
*)NULL
;
524 command
->type
= cm_simple
;
525 command
->redirects
= (REDIRECT
*)NULL
;
531 /* Return a command which is the connection of the word or redirection
532 in ELEMENT, and the command * or NULL in COMMAND. */
534 make_simple_command (element
, command
)
538 /* If we are starting from scratch, then make the initial command
539 structure. Also note that we have to fill in all the slots, since
540 malloc doesn't return zeroed space. */
543 command
= make_bare_simple_command ();
544 parser_state
|= PST_REDIRLIST
;
549 command
->value
.Simple
->words
= make_word_list (element
.word
, command
->value
.Simple
->words
);
550 parser_state
&= ~PST_REDIRLIST
;
552 else if (element
.redirect
)
554 REDIRECT
*r
= element
.redirect
;
555 /* Due to the way <> is implemented, there may be more than a single
556 redirection in element.redirect. We just follow the chain as far
557 as it goes, and hook onto the end. */
560 r
->next
= command
->value
.Simple
->redirects
;
561 command
->value
.Simple
->redirects
= element
.redirect
;
567 /* Because we are Bourne compatible, we read the input for this
568 << or <<- redirection now, from wherever input is coming from.
569 We store the input read into a WORD_DESC. Replace the text of
570 the redirectee.word with the new input text. If <<- is on,
571 then remove leading TABS from each line. */
573 make_here_document (temp
, lineno
)
577 int kill_leading
, redir_len
;
578 char *redir_word
, *document
, *full_line
;
579 int document_index
, document_size
, delim_unquoted
;
581 if (temp
->instruction
!= r_deblank_reading_until
&&
582 temp
->instruction
!= r_reading_until
)
584 internal_error (_("make_here_document: bad instruction type %d"), temp
->instruction
);
588 kill_leading
= temp
->instruction
== r_deblank_reading_until
;
590 document
= (char *)NULL
;
591 document_index
= document_size
= 0;
593 /* Quote removal is the only expansion performed on the delimiter
594 for here documents, making it an extremely special case. */
595 redir_word
= string_quote_removal (temp
->redirectee
.filename
->word
, 0);
597 /* redirection_expand will return NULL if the expansion results in
598 multiple words or no words. Check for that here, and just abort
599 this here document if it does. */
601 redir_len
= strlen (redir_word
);
604 temp
->here_doc_eof
= (char *)xmalloc (1);
605 temp
->here_doc_eof
[0] = '\0';
609 free (temp
->redirectee
.filename
->word
);
610 temp
->here_doc_eof
= redir_word
;
612 /* Read lines from wherever lines are coming from.
613 For each line read, if kill_leading, then kill the
614 leading tab characters.
615 If the line matches redir_word exactly, then we have
616 manufactured the document. Otherwise, add the line to the
617 list of lines in the document. */
619 /* If the here-document delimiter was quoted, the lines should
620 be read verbatim from the input. If it was not quoted, we
621 need to perform backslash-quoted newline removal. */
622 delim_unquoted
= (temp
->redirectee
.filename
->flags
& W_QUOTED
) == 0;
623 while (full_line
= read_secondary_line (delim_unquoted
))
628 here_doc_first_line
= 0;
632 /* If set -v is in effect, echo the line read. read_secondary_line/
633 read_a_line leaves the newline at the end, so don't print another. */
634 if (echo_input_at_read
)
635 fprintf (stderr
, "%s", line
);
637 if (kill_leading
&& *line
)
639 /* Hack: To be compatible with some Bourne shells, we
640 check the word before stripping the whitespace. This
641 is a hack, though. */
642 if (STREQN (line
, redir_word
, redir_len
) && line
[redir_len
] == '\n')
645 while (*line
== '\t')
652 if (STREQN (line
, redir_word
, redir_len
) && line
[redir_len
] == '\n')
656 if (len
+ document_index
>= document_size
)
658 document_size
= document_size
? 2 * (document_size
+ len
) : len
+ 2;
659 document
= (char *)xrealloc (document
, document_size
);
662 /* len is guaranteed to be > 0 because of the check for line
663 being an empty string before the call to strlen. */
664 FASTCOPY (line
, document
+ document_index
, len
);
665 document_index
+= len
;
669 internal_warning (_("here-document at line %d delimited by end-of-file (wanted `%s')"), lineno
, redir_word
);
673 document
[document_index
] = '\0';
676 document
= (char *)xmalloc (1);
679 temp
->redirectee
.filename
->word
= document
;
680 here_doc_first_line
= 0;
683 /* Generate a REDIRECT from SOURCE, DEST, and INSTRUCTION.
684 INSTRUCTION is the instruction type, SOURCE is a file descriptor,
685 and DEST is a file descriptor or a WORD_DESC *. */
687 make_redirection (source
, instruction
, dest_and_filename
, flags
)
689 enum r_instruction instruction
;
690 REDIRECTEE dest_and_filename
;
698 temp
= (REDIRECT
*)xmalloc (sizeof (REDIRECT
));
700 /* First do the common cases. */
701 temp
->redirector
= source
;
702 temp
->redirectee
= dest_and_filename
;
703 temp
->here_doc_eof
= 0;
704 temp
->instruction
= instruction
;
706 temp
->rflags
= flags
;
707 temp
->next
= (REDIRECT
*)NULL
;
712 case r_output_direction
: /* >foo */
713 case r_output_force
: /* >| foo */
714 case r_err_and_out
: /* &>filename */
715 temp
->flags
= O_TRUNC
| O_WRONLY
| O_CREAT
;
718 case r_appending_to
: /* >>foo */
719 case r_append_err_and_out
: /* &>> filename */
720 temp
->flags
= O_APPEND
| O_WRONLY
| O_CREAT
;
723 case r_input_direction
: /* <foo */
724 case r_inputa_direction
: /* foo & makes this. */
725 temp
->flags
= O_RDONLY
;
728 case r_input_output
: /* <>foo */
729 temp
->flags
= O_RDWR
| O_CREAT
;
732 case r_deblank_reading_until
: /* <<-foo */
733 case r_reading_until
: /* << foo */
734 case r_reading_string
: /* <<< foo */
735 case r_close_this
: /* <&- */
736 case r_duplicating_input
: /* 1<&2 */
737 case r_duplicating_output
: /* 1>&2 */
740 /* the parser doesn't pass these. */
741 case r_move_input
: /* 1<&2- */
742 case r_move_output
: /* 1>&2- */
743 case r_move_input_word
: /* 1<&$foo- */
744 case r_move_output_word
: /* 1>&$foo- */
747 /* The way the lexer works we have to do this here. */
748 case r_duplicating_input_word
: /* 1<&$foo */
749 case r_duplicating_output_word
: /* 1>&$foo */
750 w
= dest_and_filename
.filename
;
751 wlen
= strlen (w
->word
) - 1;
752 if (w
->word
[wlen
] == '-') /* Yuck */
754 w
->word
[wlen
] = '\0';
755 if (all_digits (w
->word
) && legal_number (w
->word
, &lfd
) && lfd
== (int)lfd
)
758 temp
->instruction
= (instruction
== r_duplicating_input_word
) ? r_move_input
: r_move_output
;
759 temp
->redirectee
.dest
= lfd
;
762 temp
->instruction
= (instruction
== r_duplicating_input_word
) ? r_move_input_word
: r_move_output_word
;
768 programming_error (_("make_redirection: redirection instruction `%d' out of range"), instruction
);
776 make_function_def (name
, command
, lineno
, lstart
)
782 #if defined (ARRAY_VARS)
783 SHELL_VAR
*bash_source_v
;
784 ARRAY
*bash_source_a
;
787 temp
= (FUNCTION_DEF
*)xmalloc (sizeof (FUNCTION_DEF
));
788 temp
->command
= command
;
792 command
->line
= lstart
;
794 /* Information used primarily for debugging. */
795 temp
->source_file
= 0;
796 #if defined (ARRAY_VARS)
797 GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v
, bash_source_a
);
798 if (bash_source_a
&& array_num_elements (bash_source_a
) > 0)
799 temp
->source_file
= array_reference (bash_source_a
, 0);
801 /* Assume that shell functions without a source file before the shell is
802 initialized come from the environment. Otherwise default to "main"
803 (usually functions being defined interactively) */
804 if (temp
->source_file
== 0)
805 temp
->source_file
= shell_initialized
? "main" : "environment";
807 #if defined (DEBUGGER)
808 bind_function_def (name
->word
, temp
);
811 temp
->source_file
= temp
->source_file
? savestring (temp
->source_file
) : 0;
813 return (make_command (cm_function_def
, (SIMPLE_COM
*)temp
));
817 make_subshell_command (command
)
822 temp
= (SUBSHELL_COM
*)xmalloc (sizeof (SUBSHELL_COM
));
823 temp
->command
= command
;
824 temp
->flags
= CMD_WANT_SUBSHELL
;
825 return (make_command (cm_subshell
, (SIMPLE_COM
*)temp
));
829 make_coproc_command (name
, command
)
835 temp
= (COPROC_COM
*)xmalloc (sizeof (COPROC_COM
));
836 temp
->name
= savestring (name
);
837 temp
->command
= command
;
838 temp
->flags
= CMD_WANT_SUBSHELL
|CMD_COPROC_SUBSHELL
;
839 return (make_command (cm_coproc
, (SIMPLE_COM
*)temp
));
842 /* Reverse the word list and redirection list in the simple command
843 has just been parsed. It seems simpler to do this here the one
844 time then by any other method that I can think of. */
846 clean_simple_command (command
)
849 if (command
->type
!= cm_simple
)
850 command_error ("clean_simple_command", CMDERR_BADTYPE
, command
->type
, 0);
853 command
->value
.Simple
->words
=
854 REVERSE_LIST (command
->value
.Simple
->words
, WORD_LIST
*);
855 command
->value
.Simple
->redirects
=
856 REVERSE_LIST (command
->value
.Simple
->redirects
, REDIRECT
*);
859 parser_state
&= ~PST_REDIRLIST
;
863 /* The Yacc grammar productions have a problem, in that they take a
864 list followed by an ampersand (`&') and do a simple command connection,
865 making the entire list effectively asynchronous, instead of just
866 the last command. This means that when the list is executed, all
867 the commands have stdin set to /dev/null when job control is not
868 active, instead of just the last. This is wrong, and needs fixing
869 up. This function takes the `&' and applies it to the last command
870 in the list. This is done only for lists connected by `;'; it makes
871 `;' bind `tighter' than `&'. */
873 connect_async_list (command
, command2
, connector
)
874 COMMAND
*command
, *command2
;
877 COMMAND
*t
, *t1
, *t2
;
880 t
= command
->value
.Connection
->second
;
882 if (!t
|| (command
->flags
& CMD_WANT_SUBSHELL
) ||
883 command
->value
.Connection
->connector
!= ';')
885 t
= command_connect (command
, command2
, connector
);
889 /* This is just defensive programming. The Yacc precedence rules
890 will generally hand this function a command where t points directly
891 to the command we want (e.g. given a ; b ; c ; d &, t1 will point
892 to the `a ; b ; c' list and t will be the `d'). We only want to do
893 this if the list is not being executed as a unit in the background
894 with `( ... )', so we have to check for CMD_WANT_SUBSHELL. That's
895 the only way to tell. */
896 while (((t
->flags
& CMD_WANT_SUBSHELL
) == 0) && t
->type
== cm_connection
&&
897 t
->value
.Connection
->connector
== ';')
900 t
= t
->value
.Connection
->second
;
902 /* Now we have t pointing to the last command in the list, and
903 t1->value.Connection->second == t. */
904 t2
= command_connect (t
, command2
, connector
);
905 t1
->value
.Connection
->second
= t2
;