1 /* make_cmd.c -- Functions for making instances of the various
4 /* Copyright (C) 1989-2005 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 it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License along
19 with Bash; see the file COPYING. If not, write to the Free Software
20 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
25 #include "bashtypes.h"
26 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
27 # include <sys/file.h>
31 #if defined (HAVE_UNISTD_H)
43 #include "dispose_cmd.h"
44 #include "variables.h"
50 #if defined (JOB_CONTROL)
56 extern int line_number, current_command_line_count;
57 extern int last_command_exit_value;
60 sh_obj_cache_t wdcache = {0, 0, 0};
61 sh_obj_cache_t wlcache = {0, 0, 0};
63 #define WDCACHESIZE 60
64 #define WLCACHESIZE 60
66 static COMMAND *make_for_or_select __P((enum command_type, WORD_DESC *, WORD_LIST *, COMMAND *, int));
67 #if defined (ARITH_FOR_COMMAND)
68 static WORD_LIST *make_arith_for_expr __P((char *));
70 static COMMAND *make_until_or_while __P((enum command_type, COMMAND *, COMMAND *));
75 ocache_create (wdcache, WORD_DESC, WDCACHESIZE);
76 ocache_create (wlcache, WORD_LIST, WLCACHESIZE);
84 ocache_alloc (wdcache, WORD_DESC, temp);
91 make_bare_word (string)
96 temp = alloc_word_desc ();
99 temp->word = savestring (string);
102 temp->word = (char *)xmalloc (1);
103 temp->word[0] = '\0';
110 make_word_flags (w, string)
119 slen = strlen (string);
125 w->flags |= W_HASDOLLAR;
128 break; /* continue the loop */
132 w->flags |= W_QUOTED;
136 ADVANCE_CHAR (string, slen, i);
148 temp = make_bare_word (string);
149 return (make_word_flags (temp, string));
153 make_word_from_token (token)
158 tokenizer[0] = token;
161 return (make_word (tokenizer));
165 make_word_list (word, wlink)
171 ocache_alloc (wlcache, WORD_LIST, temp);
179 make_command (type, pointer)
180 enum command_type type;
185 temp = (COMMAND *)xmalloc (sizeof (COMMAND));
187 temp->value.Simple = pointer;
188 temp->value.Simple->flags = temp->flags = 0;
189 temp->redirects = (REDIRECT *)NULL;
194 command_connect (com1, com2, connector)
195 COMMAND *com1, *com2;
200 temp = (CONNECTION *)xmalloc (sizeof (CONNECTION));
201 temp->connector = connector;
204 return (make_command (cm_connection, (SIMPLE_COM *)temp));
208 make_for_or_select (type, name, map_list, action, lineno)
209 enum command_type type;
217 temp = (FOR_COM *)xmalloc (sizeof (FOR_COM));
221 temp->map_list = map_list;
222 temp->action = action;
223 return (make_command (type, (SIMPLE_COM *)temp));
227 make_for_command (name, map_list, action, lineno)
233 return (make_for_or_select (cm_for, name, map_list, action, lineno));
237 make_select_command (name, map_list, action, lineno)
243 #if defined (SELECT_COMMAND)
244 return (make_for_or_select (cm_select, name, map_list, action, lineno));
246 last_command_exit_value = 2;
247 return ((COMMAND *)NULL);
251 #if defined (ARITH_FOR_COMMAND)
253 make_arith_for_expr (s)
259 if (s == 0 || *s == '\0')
260 return ((WORD_LIST *)NULL);
262 wd->flags |= W_NOGLOB|W_NOSPLIT|W_QUOTED; /* no word splitting or globbing */
263 result = make_word_list (wd, (WORD_LIST *)NULL);
268 /* Note that this function calls dispose_words on EXPRS, since it doesn't
269 use the word list directly. We free it here rather than at the caller
270 because no other function in this file requires that the caller free
273 make_arith_for_command (exprs, action, lineno)
278 #if defined (ARITH_FOR_COMMAND)
280 WORD_LIST *init, *test, *step;
284 init = test = step = (WORD_LIST *)NULL;
285 /* Parse the string into the three component sub-expressions. */
286 start = t = s = exprs->word->word;
289 /* skip whitespace at the start of each sub-expression. */
290 while (whitespace (*s))
293 /* skip to the semicolon or EOS */
294 while (*s && *s != ';')
297 t = (s > start) ? substring (start, 0, s - start) : (char *)NULL;
303 init = make_arith_for_expr (t);
306 test = make_arith_for_expr (t);
309 step = make_arith_for_expr (t);
316 s++; /* skip over semicolon */
322 parser_error (lineno, _("syntax error: arithmetic expression required"));
324 parser_error (lineno, _("syntax error: `;' unexpected"));
325 parser_error (lineno, _("syntax error: `((%s))'"), exprs->word->word);
326 last_command_exit_value = 2;
327 return ((COMMAND *)NULL);
330 temp = (ARITH_FOR_COM *)xmalloc (sizeof (ARITH_FOR_COM));
333 temp->init = init ? init : make_arith_for_expr ("1");
334 temp->test = test ? test : make_arith_for_expr ("1");
335 temp->step = step ? step : make_arith_for_expr ("1");
336 temp->action = action;
338 dispose_words (exprs);
339 return (make_command (cm_arith_for, (SIMPLE_COM *)temp));
341 dispose_words (exprs);
342 last_command_exit_value = 2;
343 return ((COMMAND *)NULL);
344 #endif /* ARITH_FOR_COMMAND */
348 make_group_command (command)
353 temp = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
354 temp->command = command;
355 return (make_command (cm_group, (SIMPLE_COM *)temp));
359 make_case_command (word, clauses, lineno)
361 PATTERN_LIST *clauses;
366 temp = (CASE_COM *)xmalloc (sizeof (CASE_COM));
370 temp->clauses = REVERSE_LIST (clauses, PATTERN_LIST *);
371 return (make_command (cm_case, (SIMPLE_COM *)temp));
375 make_pattern_list (patterns, action)
381 temp = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
382 temp->patterns = REVERSE_LIST (patterns, WORD_LIST *);
383 temp->action = action;
389 make_if_command (test, true_case, false_case)
390 COMMAND *test, *true_case, *false_case;
394 temp = (IF_COM *)xmalloc (sizeof (IF_COM));
397 temp->true_case = true_case;
398 temp->false_case = false_case;
399 return (make_command (cm_if, (SIMPLE_COM *)temp));
403 make_until_or_while (which, test, action)
404 enum command_type which;
405 COMMAND *test, *action;
409 temp = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
412 temp->action = action;
413 return (make_command (which, (SIMPLE_COM *)temp));
417 make_while_command (test, action)
418 COMMAND *test, *action;
420 return (make_until_or_while (cm_while, test, action));
424 make_until_command (test, action)
425 COMMAND *test, *action;
427 return (make_until_or_while (cm_until, test, action));
431 make_arith_command (exp)
434 #if defined (DPAREN_ARITHMETIC)
438 command = (COMMAND *)xmalloc (sizeof (COMMAND));
439 command->value.Arith = temp = (ARITH_COM *)xmalloc (sizeof (ARITH_COM));
442 temp->line = line_number;
445 command->type = cm_arith;
446 command->redirects = (REDIRECT *)NULL;
451 last_command_exit_value = 2;
452 return ((COMMAND *)NULL);
456 #if defined (COND_COMMAND)
458 make_cond_node (type, op, left, right)
461 struct cond_com *left, *right;
465 temp = (COND_COM *)xmalloc (sizeof (COND_COM));
467 temp->line = line_number;
478 make_cond_command (cond_node)
481 #if defined (COND_COMMAND)
484 command = (COMMAND *)xmalloc (sizeof (COMMAND));
485 command->value.Cond = cond_node;
487 command->type = cm_cond;
488 command->redirects = (REDIRECT *)NULL;
490 command->line = cond_node ? cond_node->line : 0;
494 last_command_exit_value = 2;
495 return ((COMMAND *)NULL);
500 make_bare_simple_command ()
505 command = (COMMAND *)xmalloc (sizeof (COMMAND));
506 command->value.Simple = temp = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
509 temp->line = line_number;
510 temp->words = (WORD_LIST *)NULL;
511 temp->redirects = (REDIRECT *)NULL;
513 command->type = cm_simple;
514 command->redirects = (REDIRECT *)NULL;
520 /* Return a command which is the connection of the word or redirection
521 in ELEMENT, and the command * or NULL in COMMAND. */
523 make_simple_command (element, command)
527 /* If we are starting from scratch, then make the initial command
528 structure. Also note that we have to fill in all the slots, since
529 malloc doesn't return zeroed space. */
531 command = make_bare_simple_command ();
534 command->value.Simple->words = make_word_list (element.word, command->value.Simple->words);
535 else if (element.redirect)
537 REDIRECT *r = element.redirect;
538 /* Due to the way <> is implemented, there may be more than a single
539 redirection in element.redirect. We just follow the chain as far
540 as it goes, and hook onto the end. */
543 r->next = command->value.Simple->redirects;
544 command->value.Simple->redirects = element.redirect;
549 /* Because we are Bourne compatible, we read the input for this
550 << or <<- redirection now, from wherever input is coming from.
551 We store the input read into a WORD_DESC. Replace the text of
552 the redirectee.word with the new input text. If <<- is on,
553 then remove leading TABS from each line. */
555 make_here_document (temp)
558 int kill_leading, redir_len;
559 char *redir_word, *document, *full_line;
560 int document_index, document_size, delim_unquoted;
562 if (temp->instruction != r_deblank_reading_until &&
563 temp->instruction != r_reading_until)
565 internal_error (_("make_here_document: bad instruction type %d"), temp->instruction);
569 kill_leading = temp->instruction == r_deblank_reading_until;
571 document = (char *)NULL;
572 document_index = document_size = 0;
574 /* Quote removal is the only expansion performed on the delimiter
575 for here documents, making it an extremely special case. */
576 redir_word = string_quote_removal (temp->redirectee.filename->word, 0);
578 /* redirection_expand will return NULL if the expansion results in
579 multiple words or no words. Check for that here, and just abort
580 this here document if it does. */
582 redir_len = strlen (redir_word);
585 temp->here_doc_eof = (char *)xmalloc (1);
586 temp->here_doc_eof[0] = '\0';
590 free (temp->redirectee.filename->word);
591 temp->here_doc_eof = redir_word;
593 /* Read lines from wherever lines are coming from.
594 For each line read, if kill_leading, then kill the
595 leading tab characters.
596 If the line matches redir_word exactly, then we have
597 manufactured the document. Otherwise, add the line to the
598 list of lines in the document. */
600 /* If the here-document delimiter was quoted, the lines should
601 be read verbatim from the input. If it was not quoted, we
602 need to perform backslash-quoted newline removal. */
603 delim_unquoted = (temp->redirectee.filename->flags & W_QUOTED) == 0;
604 while (full_line = read_secondary_line (delim_unquoted))
612 if (kill_leading && *line)
614 /* Hack: To be compatible with some Bourne shells, we
615 check the word before stripping the whitespace. This
616 is a hack, though. */
617 if (STREQN (line, redir_word, redir_len) && line[redir_len] == '\n')
620 while (*line == '\t')
627 if (STREQN (line, redir_word, redir_len) && line[redir_len] == '\n')
631 if (len + document_index >= document_size)
633 document_size = document_size ? 2 * (document_size + len) : len + 2;
634 document = (char *)xrealloc (document, document_size);
637 /* len is guaranteed to be > 0 because of the check for line
638 being an empty string before the call to strlen. */
639 FASTCOPY (line, document + document_index, len);
640 document_index += len;
645 document[document_index] = '\0';
648 document = (char *)xmalloc (1);
651 temp->redirectee.filename->word = document;
654 /* Generate a REDIRECT from SOURCE, DEST, and INSTRUCTION.
655 INSTRUCTION is the instruction type, SOURCE is a file descriptor,
656 and DEST is a file descriptor or a WORD_DESC *. */
658 make_redirection (source, instruction, dest_and_filename)
660 enum r_instruction instruction;
661 REDIRECTEE dest_and_filename;
668 temp = (REDIRECT *)xmalloc (sizeof (REDIRECT));
670 /* First do the common cases. */
671 temp->redirector = source;
672 temp->redirectee = dest_and_filename;
673 temp->instruction = instruction;
675 temp->next = (REDIRECT *)NULL;
680 case r_output_direction: /* >foo */
681 case r_output_force: /* >| foo */
682 case r_err_and_out: /* command &>filename */
683 temp->flags = O_TRUNC | O_WRONLY | O_CREAT;
686 case r_appending_to: /* >>foo */
687 temp->flags = O_APPEND | O_WRONLY | O_CREAT;
690 case r_input_direction: /* <foo */
691 case r_inputa_direction: /* foo & makes this. */
692 temp->flags = O_RDONLY;
695 case r_input_output: /* <>foo */
696 temp->flags = O_RDWR | O_CREAT;
699 case r_deblank_reading_until: /* <<-foo */
700 case r_reading_until: /* << foo */
701 case r_reading_string: /* <<< foo */
702 case r_close_this: /* <&- */
703 case r_duplicating_input: /* 1<&2 */
704 case r_duplicating_output: /* 1>&2 */
707 /* the parser doesn't pass these. */
708 case r_move_input: /* 1<&2- */
709 case r_move_output: /* 1>&2- */
710 case r_move_input_word: /* 1<&$foo- */
711 case r_move_output_word: /* 1>&$foo- */
714 /* The way the lexer works we have to do this here. */
715 case r_duplicating_input_word: /* 1<&$foo */
716 case r_duplicating_output_word: /* 1>&$foo */
717 w = dest_and_filename.filename;
718 wlen = strlen (w->word) - 1;
719 if (w->word[wlen] == '-') /* Yuck */
721 w->word[wlen] = '\0';
722 if (all_digits (w->word) && legal_number (w->word, &lfd) && lfd == (int)lfd)
725 temp->instruction = (instruction == r_duplicating_input_word) ? r_move_input : r_move_output;
726 temp->redirectee.dest = lfd;
729 temp->instruction = (instruction == r_duplicating_input_word) ? r_move_input_word : r_move_output_word;
735 programming_error (_("make_redirection: redirection instruction `%d' out of range"), instruction);
743 make_function_def (name, command, lineno, lstart)
749 #if defined (ARRAY_VARS)
750 SHELL_VAR *bash_source_v;
751 ARRAY *bash_source_a;
755 temp = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
756 temp->command = command;
760 command->line = lstart;
762 /* Information used primarily for debugging. */
763 temp->source_file = 0;
764 #if defined (ARRAY_VARS)
765 GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
766 if (bash_source_a && array_num_elements (bash_source_a) > 0)
767 temp->source_file = array_reference (bash_source_a, 0);
769 bind_function_def (name->word, temp);
771 temp->source_file = 0;
772 return (make_command (cm_function_def, (SIMPLE_COM *)temp));
776 make_subshell_command (command)
781 temp = (SUBSHELL_COM *)xmalloc (sizeof (SUBSHELL_COM));
782 temp->command = command;
783 temp->flags = CMD_WANT_SUBSHELL;
784 return (make_command (cm_subshell, (SIMPLE_COM *)temp));
787 /* Reverse the word list and redirection list in the simple command
788 has just been parsed. It seems simpler to do this here the one
789 time then by any other method that I can think of. */
791 clean_simple_command (command)
794 if (command->type != cm_simple)
795 command_error ("clean_simple_command", CMDERR_BADTYPE, command->type, 0);
798 command->value.Simple->words =
799 REVERSE_LIST (command->value.Simple->words, WORD_LIST *);
800 command->value.Simple->redirects =
801 REVERSE_LIST (command->value.Simple->redirects, REDIRECT *);
807 /* The Yacc grammar productions have a problem, in that they take a
808 list followed by an ampersand (`&') and do a simple command connection,
809 making the entire list effectively asynchronous, instead of just
810 the last command. This means that when the list is executed, all
811 the commands have stdin set to /dev/null when job control is not
812 active, instead of just the last. This is wrong, and needs fixing
813 up. This function takes the `&' and applies it to the last command
814 in the list. This is done only for lists connected by `;'; it makes
815 `;' bind `tighter' than `&'. */
817 connect_async_list (command, command2, connector)
818 COMMAND *command, *command2;
821 COMMAND *t, *t1, *t2;
824 t = command->value.Connection->second;
826 if (!t || (command->flags & CMD_WANT_SUBSHELL) ||
827 command->value.Connection->connector != ';')
829 t = command_connect (command, command2, connector);
833 /* This is just defensive programming. The Yacc precedence rules
834 will generally hand this function a command where t points directly
835 to the command we want (e.g. given a ; b ; c ; d &, t1 will point
836 to the `a ; b ; c' list and t will be the `d'). We only want to do
837 this if the list is not being executed as a unit in the background
838 with `( ... )', so we have to check for CMD_WANT_SUBSHELL. That's
839 the only way to tell. */
840 while (((t->flags & CMD_WANT_SUBSHELL) == 0) && t->type == cm_connection &&
841 t->value.Connection->connector == ';')
844 t = t->value.Connection->second;
846 /* Now we have t pointing to the last command in the list, and
847 t1->value.Connection->second == t. */
848 t2 = command_connect (t, command2, connector);
849 t1->value.Connection->second = t2;