make_cmd.c

   1 /* make_cmd.c -- Functions for making instances of the various
   2    parser constructs. */
   3
   4 /* Copyright (C) 1989-2009 Free Software Foundation, Inc.
   5
   6    This file is part of GNU Bash, the Bourne Again SHell.
   7
   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.
  12
  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.
  17
  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/>.
  20 */
  21
  22 #include "config.h"
  23
  24 #include <stdio.h>
  25 #include "bashtypes.h"
  26 #if !defined (_MINIX) && defined (HAVE_SYS_FILE_H)
  27 #  include <sys/file.h>
  28 #endif
  29 #include "filecntl.h"
  30 #include "bashansi.h"
  31 #if defined (HAVE_UNISTD_H)
  32 #  include <unistd.h>
  33 #endif
  34
  35 #include "bashintl.h"
  36
  37 #include "parser.h"
  38 #include "syntax.h"
  39 #include "command.h"
  40 #include "general.h"
  41 #include "error.h"
  42 #include "flags.h"
  43 #include "make_cmd.h"
  44 #include "dispose_cmd.h"
  45 #include "variables.h"
  46 #include "subst.h"
  47 #include "input.h"
  48 #include "ocache.h"
  49 #include "externs.h"
  50
  51 #if defined (JOB_CONTROL)
  52 #include "jobs.h"
  53 #endif
  54
  55 #include "shmbutil.h"
  56
  57 extern int line_number, current_command_line_count, parser_state;
  58 extern int last_command_exit_value;
  59
  60 /* Object caching */
  61 sh_obj_cache_t wdcache = {0, 0, 0};
  62 sh_obj_cache_t wlcache = {0, 0, 0};
  63
  64 #define WDCACHESIZE     60
  65 #define WLCACHESIZE     60
  66
  67 static COMMAND *make_for_or_select __P((enum command_type, WORD_DESC *, WORD_LIST *, COMMAND *, int));
  68 #if defined (ARITH_FOR_COMMAND)
  69 static WORD_LIST *make_arith_for_expr __P((char *));
  70 #endif
  71 static COMMAND *make_until_or_while __P((enum command_type, COMMAND *, COMMAND *));
  72
  73 void
  74 cmd_init ()
  75 {
  76   ocache_create (wdcache, WORD_DESC, WDCACHESIZE);
  77   ocache_create (wlcache, WORD_LIST, WLCACHESIZE);
  78 }
  79
  80 WORD_DESC *
  81 alloc_word_desc ()
  82 {
  83   WORD_DESC *temp;
  84
  85   ocache_alloc (wdcache, WORD_DESC, temp);
  86   temp->flags = 0;
  87   temp->word = 0;
  88   return temp;
  89 }
  90
  91 WORD_DESC *
  92 make_bare_word (string)
  93      const char *string;
  94 {
  95   WORD_DESC *temp;
  96
  97   temp = alloc_word_desc ();
  98
  99   if (*string)
 100     temp->word = savestring (string);
 101   else
 102     {
 103       temp->word = (char *)xmalloc (1);
 104       temp->word[0] = '\0';
 105     }
 106
 107   return (temp);
 108 }
 109
 110 WORD_DESC *
 111 make_word_flags (w, string)
 112      WORD_DESC *w;
 113      const char *string;
 114 {
 115   register int i;
 116   size_t slen;
 117   DECLARE_MBSTATE;
 118
 119   i = 0;
 120   slen = strlen (string);
 121   while (i < slen)
 122     {
 123       switch (string[i])
 124         {
 125         case '$':
 126           w->flags |= W_HASDOLLAR;
 127           break;
 128         case '\\':
 129           break;        /* continue the loop */
 130         case '\'':
 131         case '`':
 132         case '"':
 133           w->flags |= W_QUOTED;
 134           break;
 135         }
 136
 137       ADVANCE_CHAR (string, slen, i);
 138     }
 139
 140   return (w);
 141 }
 142
 143 WORD_DESC *
 144 make_word (string)
 145      const char *string;
 146 {
 147   WORD_DESC *temp;
 148
 149   temp = make_bare_word (string);
 150   return (make_word_flags (temp, string));
 151 }
 152
 153 WORD_DESC *
 154 make_word_from_token (token)
 155      int token;
 156 {
 157   char tokenizer[2];
 158
 159   tokenizer[0] = token;
 160   tokenizer[1] = '\0';
 161
 162   return (make_word (tokenizer));
 163 }
 164
 165 WORD_LIST *
 166 make_word_list (word, wlink)
 167      WORD_DESC *word;
 168      WORD_LIST *wlink;
 169 {
 170   WORD_LIST *temp;
 171
 172   ocache_alloc (wlcache, WORD_LIST, temp);
 173
 174   temp->word = word;
 175   temp->next = wlink;
 176   return (temp);
 177 }
 178
 179 COMMAND *
 180 make_command (type, pointer)
 181      enum command_type type;
 182      SIMPLE_COM *pointer;
 183 {
 184   COMMAND *temp;
 185
 186   temp = (COMMAND *)xmalloc (sizeof (COMMAND));
 187   temp->type = type;
 188   temp->value.Simple = pointer;
 189   temp->value.Simple->flags = temp->flags = 0;
 190   temp->redirects = (REDIRECT *)NULL;
 191   return (temp);
 192 }
 193
 194 COMMAND *
 195 command_connect (com1, com2, connector)
 196      COMMAND *com1, *com2;
 197      int connector;
 198 {
 199   CONNECTION *temp;
 200
 201   temp = (CONNECTION *)xmalloc (sizeof (CONNECTION));
 202   temp->connector = connector;
 203   temp->first = com1;
 204   temp->second = com2;
 205   return (make_command (cm_connection, (SIMPLE_COM *)temp));
 206 }
 207
 208 static COMMAND *
 209 make_for_or_select (type, name, map_list, action, lineno)
 210      enum command_type type;
 211      WORD_DESC *name;
 212      WORD_LIST *map_list;
 213      COMMAND *action;
 214      int lineno;
 215 {
 216   FOR_COM *temp;
 217
 218   temp = (FOR_COM *)xmalloc (sizeof (FOR_COM));
 219   temp->flags = 0;
 220   temp->name = name;
 221   temp->line = lineno;
 222   temp->map_list = map_list;
 223   temp->action = action;
 224   return (make_command (type, (SIMPLE_COM *)temp));
 225 }
 226
 227 COMMAND *
 228 make_for_command (name, map_list, action, lineno)
 229      WORD_DESC *name;
 230      WORD_LIST *map_list;
 231      COMMAND *action;
 232      int lineno;
 233 {
 234   return (make_for_or_select (cm_for, name, map_list, action, lineno));
 235 }
 236
 237 COMMAND *
 238 make_select_command (name, map_list, action, lineno)
 239      WORD_DESC *name;
 240      WORD_LIST *map_list;
 241      COMMAND *action;
 242      int lineno;
 243 {
 244 #if defined (SELECT_COMMAND)
 245   return (make_for_or_select (cm_select, name, map_list, action, lineno));
 246 #else
 247   last_command_exit_value = 2;
 248   return ((COMMAND *)NULL);
 249 #endif
 250 }
 251
 252 #if defined (ARITH_FOR_COMMAND)
 253 static WORD_LIST *
 254 make_arith_for_expr (s)
 255      char *s;
 256 {
 257   WORD_LIST *result;
 258   WORD_DESC *wd;
 259
 260   if (s == 0 || *s == '\0')
 261     return ((WORD_LIST *)NULL);
 262   wd = make_word (s);
 263   wd->flags |= W_NOGLOB|W_NOSPLIT|W_QUOTED|W_DQUOTE;    /* no word splitting or globbing */
 264   result = make_word_list (wd, (WORD_LIST *)NULL);
 265   return result;
 266 }
 267 #endif
 268
 269 /* Note that this function calls dispose_words on EXPRS, since it doesn't
 270    use the word list directly.  We free it here rather than at the caller
 271    because no other function in this file requires that the caller free
 272    any arguments. */
 273 COMMAND *
 274 make_arith_for_command (exprs, action, lineno)
 275      WORD_LIST *exprs;
 276      COMMAND *action;
 277      int lineno;
 278 {
 279 #if defined (ARITH_FOR_COMMAND)
 280   ARITH_FOR_COM *temp;
 281   WORD_LIST *init, *test, *step;
 282   char *s, *t, *start;
 283   int nsemi, i;
 284
 285   init = test = step = (WORD_LIST *)NULL;
 286   /* Parse the string into the three component sub-expressions. */
 287   start = t = s = exprs->word->word;
 288   for (nsemi = 0; ;)
 289     {
 290       /* skip whitespace at the start of each sub-expression. */
 291       while (whitespace (*s))
 292         s++;
 293       start = s;
 294       /* skip to the semicolon or EOS */
 295       i = skip_to_delim (start, 0, ";", SD_NOJMP);
 296       s = start + i;
 297
 298       t = (i > 0) ? substring (start, 0, i) : (char *)NULL;
 299
 300       nsemi++;
 301       switch (nsemi)
 302         {
 303         case 1:
 304           init = make_arith_for_expr (t);
 305           break;
 306         case 2:
 307           test = make_arith_for_expr (t);
 308           break;
 309         case 3:
 310           step = make_arith_for_expr (t);
 311           break;
 312         }
 313
 314       FREE (t);
 315       if (*s == '\0')
 316         break;
 317       s++;      /* skip over semicolon */
 318     }
 319
 320   if (nsemi != 3)
 321     {
 322       if (nsemi < 3)
 323         parser_error (lineno, _("syntax error: arithmetic expression required"));
 324       else
 325         parser_error (lineno, _("syntax error: `;' unexpected"));
 326       parser_error (lineno, _("syntax error: `((%s))'"), exprs->word->word);
 327       free (init);
 328       free (test);
 329       free (step);
 330       last_command_exit_value = 2;
 331       return ((COMMAND *)NULL);
 332     }
 333
 334   temp = (ARITH_FOR_COM *)xmalloc (sizeof (ARITH_FOR_COM));
 335   temp->flags = 0;
 336   temp->line = lineno;
 337   temp->init = init ? init : make_arith_for_expr ("1");
 338   temp->test = test ? test : make_arith_for_expr ("1");
 339   temp->step = step ? step : make_arith_for_expr ("1");
 340   temp->action = action;
 341
 342   dispose_words (exprs);
 343   return (make_command (cm_arith_for, (SIMPLE_COM *)temp));
 344 #else
 345   dispose_words (exprs);
 346   last_command_exit_value = 2;
 347   return ((COMMAND *)NULL);
 348 #endif /* ARITH_FOR_COMMAND */
 349 }
 350
 351 COMMAND *
 352 make_group_command (command)
 353      COMMAND *command;
 354 {
 355   GROUP_COM *temp;
 356
 357   temp = (GROUP_COM *)xmalloc (sizeof (GROUP_COM));
 358   temp->command = command;
 359   return (make_command (cm_group, (SIMPLE_COM *)temp));
 360 }
 361
 362 COMMAND *
 363 make_case_command (word, clauses, lineno)
 364      WORD_DESC *word;
 365      PATTERN_LIST *clauses;
 366      int lineno;
 367 {
 368   CASE_COM *temp;
 369
 370   temp = (CASE_COM *)xmalloc (sizeof (CASE_COM));
 371   temp->flags = 0;
 372   temp->line = lineno;
 373   temp->word = word;
 374   temp->clauses = REVERSE_LIST (clauses, PATTERN_LIST *);
 375   return (make_command (cm_case, (SIMPLE_COM *)temp));
 376 }
 377
 378 PATTERN_LIST *
 379 make_pattern_list (patterns, action)
 380      WORD_LIST *patterns;
 381      COMMAND *action;
 382 {
 383   PATTERN_LIST *temp;
 384
 385   temp = (PATTERN_LIST *)xmalloc (sizeof (PATTERN_LIST));
 386   temp->patterns = REVERSE_LIST (patterns, WORD_LIST *);
 387   temp->action = action;
 388   temp->next = NULL;
 389   temp->flags = 0;
 390   return (temp);
 391 }
 392
 393 COMMAND *
 394 make_if_command (test, true_case, false_case)
 395      COMMAND *test, *true_case, *false_case;
 396 {
 397   IF_COM *temp;
 398
 399   temp = (IF_COM *)xmalloc (sizeof (IF_COM));
 400   temp->flags = 0;
 401   temp->test = test;
 402   temp->true_case = true_case;
 403   temp->false_case = false_case;
 404   return (make_command (cm_if, (SIMPLE_COM *)temp));
 405 }
 406
 407 static COMMAND *
 408 make_until_or_while (which, test, action)
 409      enum command_type which;
 410      COMMAND *test, *action;
 411 {
 412   WHILE_COM *temp;
 413
 414   temp = (WHILE_COM *)xmalloc (sizeof (WHILE_COM));
 415   temp->flags = 0;
 416   temp->test = test;
 417   temp->action = action;
 418   return (make_command (which, (SIMPLE_COM *)temp));
 419 }
 420
 421 COMMAND *
 422 make_while_command (test, action)
 423      COMMAND *test, *action;
 424 {
 425   return (make_until_or_while (cm_while, test, action));
 426 }
 427
 428 COMMAND *
 429 make_until_command (test, action)
 430      COMMAND *test, *action;
 431 {
 432   return (make_until_or_while (cm_until, test, action));
 433 }
 434
 435 COMMAND *
 436 make_arith_command (exp)
 437      WORD_LIST *exp;
 438 {
 439 #if defined (DPAREN_ARITHMETIC)
 440   COMMAND *command;
 441   ARITH_COM *temp;
 442
 443   command = (COMMAND *)xmalloc (sizeof (COMMAND));
 444   command->value.Arith = temp = (ARITH_COM *)xmalloc (sizeof (ARITH_COM));
 445
 446   temp->flags = 0;
 447   temp->line = line_number;
 448   temp->exp = exp;
 449
 450   command->type = cm_arith;
 451   command->redirects = (REDIRECT *)NULL;
 452   command->flags = 0;
 453
 454   return (command);
 455 #else
 456   last_command_exit_value = 2;
 457   return ((COMMAND *)NULL);
 458 #endif
 459 }
 460
 461 #if defined (COND_COMMAND)
 462 struct cond_com *
 463 make_cond_node (type, op, left, right)
 464      int type;
 465      WORD_DESC *op;
 466      struct cond_com *left, *right;
 467 {
 468   COND_COM *temp;
 469
 470   temp = (COND_COM *)xmalloc (sizeof (COND_COM));
 471   temp->flags = 0;
 472   temp->line = line_number;
 473   temp->type = type;
 474   temp->op = op;
 475   temp->left = left;
 476   temp->right = right;
 477
 478   return (temp);
 479 }
 480 #endif
 481
 482 COMMAND *
 483 make_cond_command (cond_node)
 484      COND_COM *cond_node;
 485 {
 486 #if defined (COND_COMMAND)
 487   COMMAND *command;
 488
 489   command = (COMMAND *)xmalloc (sizeof (COMMAND));
 490   command->value.Cond = cond_node;
 491
 492   command->type = cm_cond;
 493   command->redirects = (REDIRECT *)NULL;
 494   command->flags = 0;
 495   command->line = cond_node ? cond_node->line : 0;
 496
 497   return (command);
 498 #else
 499   last_command_exit_value = 2;
 500   return ((COMMAND *)NULL);
 501 #endif
 502 }
 503
 504 COMMAND *
 505 make_bare_simple_command ()
 506 {
 507   COMMAND *command;
 508   SIMPLE_COM *temp;
 509
 510   command = (COMMAND *)xmalloc (sizeof (COMMAND));
 511   command->value.Simple = temp = (SIMPLE_COM *)xmalloc (sizeof (SIMPLE_COM));
 512
 513   temp->flags = 0;
 514   temp->line = line_number;
 515   temp->words = (WORD_LIST *)NULL;
 516   temp->redirects = (REDIRECT *)NULL;
 517
 518   command->type = cm_simple;
 519   command->redirects = (REDIRECT *)NULL;
 520   command->flags = 0;
 521
 522   return (command);
 523 }
 524
 525 /* Return a command which is the connection of the word or redirection
 526    in ELEMENT, and the command * or NULL in COMMAND. */
 527 COMMAND *
 528 make_simple_command (element, command)
 529      ELEMENT element;
 530      COMMAND *command;
 531 {
 532   /* If we are starting from scratch, then make the initial command
 533      structure.  Also note that we have to fill in all the slots, since
 534      malloc doesn't return zeroed space. */
 535   if (command == 0)
 536     {
 537       command = make_bare_simple_command ();
 538       parser_state |= PST_REDIRLIST;
 539     }
 540
 541   if (element.word)
 542     {
 543       command->value.Simple->words = make_word_list (element.word, command->value.Simple->words);
 544       parser_state &= ~PST_REDIRLIST;
 545     }
 546   else if (element.redirect)
 547     {
 548       REDIRECT *r = element.redirect;
 549       /* Due to the way <> is implemented, there may be more than a single
 550          redirection in element.redirect.  We just follow the chain as far
 551          as it goes, and hook onto the end. */
 552       while (r->next)
 553         r = r->next;
 554       r->next = command->value.Simple->redirects;
 555       command->value.Simple->redirects = element.redirect;
 556     }
 557
 558   return (command);
 559 }
 560
 561 /* Because we are Bourne compatible, we read the input for this
 562    << or <<- redirection now, from wherever input is coming from.
 563    We store the input read into a WORD_DESC.  Replace the text of
 564    the redirectee.word with the new input text.  If <<- is on,
 565    then remove leading TABS from each line. */
 566 void
 567 make_here_document (temp, lineno)
 568      REDIRECT *temp;
 569      int lineno;
 570 {
 571   int kill_leading, redir_len;
 572   char *redir_word, *document, *full_line;
 573   int document_index, document_size, delim_unquoted;
 574
 575   if (temp->instruction != r_deblank_reading_until &&
 576       temp->instruction != r_reading_until)
 577     {
 578       internal_error (_("make_here_document: bad instruction type %d"), temp->instruction);
 579       return;
 580     }
 581
 582   kill_leading = temp->instruction == r_deblank_reading_until;
 583
 584   document = (char *)NULL;
 585   document_index = document_size = 0;
 586
 587   /* Quote removal is the only expansion performed on the delimiter
 588      for here documents, making it an extremely special case. */
 589   redir_word = string_quote_removal (temp->redirectee.filename->word, 0);
 590
 591   /* redirection_expand will return NULL if the expansion results in
 592      multiple words or no words.  Check for that here, and just abort
 593      this here document if it does. */
 594   if (redir_word)
 595     redir_len = strlen (redir_word);
 596   else
 597     {
 598       temp->here_doc_eof = (char *)xmalloc (1);
 599       temp->here_doc_eof[0] = '\0';
 600       goto document_done;
 601     }
 602
 603   free (temp->redirectee.filename->word);
 604   temp->here_doc_eof = redir_word;
 605
 606   /* Read lines from wherever lines are coming from.
 607      For each line read, if kill_leading, then kill the
 608      leading tab characters.
 609      If the line matches redir_word exactly, then we have
 610      manufactured the document.  Otherwise, add the line to the
 611      list of lines in the document. */
 612
 613   /* If the here-document delimiter was quoted, the lines should
 614      be read verbatim from the input.  If it was not quoted, we
 615      need to perform backslash-quoted newline removal. */
 616   delim_unquoted = (temp->redirectee.filename->flags & W_QUOTED) == 0;
 617   while (full_line = read_secondary_line (delim_unquoted))
 618     {
 619       register char *line;
 620       int len;
 621
 622       line = full_line;
 623       line_number++;
 624
 625       /* If set -v is in effect, echo the line read.  read_secondary_line/
 626          read_a_line leaves the newline at the end, so don't print another. */
 627       if (echo_input_at_read)
 628         fprintf (stderr, "%s", line);
 629
 630       if (kill_leading && *line)
 631         {
 632           /* Hack:  To be compatible with some Bourne shells, we
 633              check the word before stripping the whitespace.  This
 634              is a hack, though. */
 635           if (STREQN (line, redir_word, redir_len) && line[redir_len] == '\n')
 636             goto document_done;
 637
 638           while (*line == '\t')
 639             line++;
 640         }
 641
 642       if (*line == 0)
 643         continue;
 644
 645       if (STREQN (line, redir_word, redir_len) && line[redir_len] == '\n')
 646         goto document_done;
 647
 648       len = strlen (line);
 649       if (len + document_index >= document_size)
 650         {
 651           document_size = document_size ? 2 * (document_size + len) : len + 2;
 652           document = (char *)xrealloc (document, document_size);
 653         }
 654
 655       /* len is guaranteed to be > 0 because of the check for line
 656          being an empty string before the call to strlen. */
 657       FASTCOPY (line, document + document_index, len);
 658       document_index += len;
 659     }
 660
 661   if (full_line == 0)
 662     internal_warning (_("here-document at line %d delimited by end-of-file (wanted `%s')"), lineno, redir_word);
 663
 664 document_done:
 665   if (document)
 666     document[document_index] = '\0';
 667   else
 668     {
 669       document = (char *)xmalloc (1);
 670       document[0] = '\0';
 671     }
 672   temp->redirectee.filename->word = document;
 673 }
 674
 675 /* Generate a REDIRECT from SOURCE, DEST, and INSTRUCTION.
 676    INSTRUCTION is the instruction type, SOURCE is a file descriptor,
 677    and DEST is a file descriptor or a WORD_DESC *. */
 678 REDIRECT *
 679 make_redirection (source, instruction, dest_and_filename, flags)
 680      REDIRECTEE source;
 681      enum r_instruction instruction;
 682      REDIRECTEE dest_and_filename;
 683      int flags;
 684 {
 685   REDIRECT *temp;
 686   WORD_DESC *w;
 687   int wlen;
 688   intmax_t lfd;
 689
 690   temp = (REDIRECT *)xmalloc (sizeof (REDIRECT));
 691
 692   /* First do the common cases. */
 693   temp->redirector = source;
 694   temp->redirectee = dest_and_filename;
 695   temp->here_doc_eof = 0;
 696   temp->instruction = instruction;
 697   temp->flags = 0;
 698   temp->rflags = flags;
 699   temp->next = (REDIRECT *)NULL;
 700
 701   switch (instruction)
 702     {
 703
 704     case r_output_direction:            /* >foo */
 705     case r_output_force:                /* >| foo */
 706     case r_err_and_out:                 /* &>filename */
 707       temp->flags = O_TRUNC | O_WRONLY | O_CREAT;
 708       break;
 709
 710     case r_appending_to:                /* >>foo */
 711     case r_append_err_and_out:          /* &>> filename */
 712       temp->flags = O_APPEND | O_WRONLY | O_CREAT;
 713       break;
 714
 715     case r_input_direction:             /* <foo */
 716     case r_inputa_direction:            /* foo & makes this. */
 717       temp->flags = O_RDONLY;
 718       break;
 719
 720     case r_input_output:                /* <>foo */
 721       temp->flags = O_RDWR | O_CREAT;
 722       break;
 723
 724     case r_deblank_reading_until:       /* <<-foo */
 725     case r_reading_until:               /* << foo */
 726     case r_reading_string:              /* <<< foo */
 727     case r_close_this:                  /* <&- */
 728     case r_duplicating_input:           /* 1<&2 */
 729     case r_duplicating_output:          /* 1>&2 */
 730       break;
 731
 732     /* the parser doesn't pass these. */
 733     case r_move_input:                  /* 1<&2- */
 734     case r_move_output:                 /* 1>&2- */
 735     case r_move_input_word:             /* 1<&$foo- */
 736     case r_move_output_word:            /* 1>&$foo- */
 737       break;
 738
 739     /* The way the lexer works we have to do this here. */
 740     case r_duplicating_input_word:      /* 1<&$foo */
 741     case r_duplicating_output_word:     /* 1>&$foo */
 742       w = dest_and_filename.filename;
 743       wlen = strlen (w->word) - 1;
 744       if (w->word[wlen] == '-')         /* Yuck */
 745         {
 746           w->word[wlen] = '\0';
 747           if (all_digits (w->word) && legal_number (w->word, &lfd) && lfd == (int)lfd)
 748             {
 749               dispose_word (w);
 750               temp->instruction = (instruction == r_duplicating_input_word) ? r_move_input : r_move_output;
 751               temp->redirectee.dest = lfd;
 752             }
 753           else
 754             temp->instruction = (instruction == r_duplicating_input_word) ? r_move_input_word : r_move_output_word;
 755         }
 756
 757       break;
 758
 759     default:
 760       programming_error (_("make_redirection: redirection instruction `%d' out of range"), instruction);
 761       abort ();
 762       break;
 763     }
 764   return (temp);
 765 }
 766
 767 COMMAND *
 768 make_function_def (name, command, lineno, lstart)
 769      WORD_DESC *name;
 770      COMMAND *command;
 771      int lineno, lstart;
 772 {
 773   FUNCTION_DEF *temp;
 774 #if defined (ARRAY_VARS)
 775   SHELL_VAR *bash_source_v;
 776   ARRAY *bash_source_a;
 777 #endif
 778
 779   temp = (FUNCTION_DEF *)xmalloc (sizeof (FUNCTION_DEF));
 780   temp->command = command;
 781   temp->name = name;
 782   temp->line = lineno;
 783   temp->flags = 0;
 784   command->line = lstart;
 785
 786   /* Information used primarily for debugging. */
 787   temp->source_file = 0;
 788 #if defined (ARRAY_VARS)
 789   GET_ARRAY_FROM_VAR ("BASH_SOURCE", bash_source_v, bash_source_a);
 790   if (bash_source_a && array_num_elements (bash_source_a) > 0)
 791     temp->source_file = array_reference (bash_source_a, 0);
 792 #endif
 793 #if defined (DEBUGGER)
 794   bind_function_def (name->word, temp);
 795 #endif
 796
 797   temp->source_file = temp->source_file ? savestring (temp->source_file) : 0;
 798   return (make_command (cm_function_def, (SIMPLE_COM *)temp));
 799 }
 800
 801 COMMAND *
 802 make_subshell_command (command)
 803      COMMAND *command;
 804 {
 805   SUBSHELL_COM *temp;
 806
 807   temp = (SUBSHELL_COM *)xmalloc (sizeof (SUBSHELL_COM));
 808   temp->command = command;
 809   temp->flags = CMD_WANT_SUBSHELL;
 810   return (make_command (cm_subshell, (SIMPLE_COM *)temp));
 811 }
 812
 813 COMMAND *
 814 make_coproc_command (name, command)
 815      char *name;
 816      COMMAND *command;
 817 {
 818   COPROC_COM *temp;
 819
 820   temp = (COPROC_COM *)xmalloc (sizeof (COPROC_COM));
 821   temp->name = savestring (name);
 822   temp->command = command;
 823   temp->flags = CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
 824   return (make_command (cm_coproc, (SIMPLE_COM *)temp));
 825 }
 826
 827 /* Reverse the word list and redirection list in the simple command
 828    has just been parsed.  It seems simpler to do this here the one
 829    time then by any other method that I can think of. */
 830 COMMAND *
 831 clean_simple_command (command)
 832      COMMAND *command;
 833 {
 834   if (command->type != cm_simple)
 835     command_error ("clean_simple_command", CMDERR_BADTYPE, command->type, 0);
 836   else
 837     {
 838       command->value.Simple->words =
 839         REVERSE_LIST (command->value.Simple->words, WORD_LIST *);
 840       command->value.Simple->redirects =
 841         REVERSE_LIST (command->value.Simple->redirects, REDIRECT *);
 842     }
 843
 844   parser_state &= ~PST_REDIRLIST;
 845   return (command);
 846 }
 847
 848 /* The Yacc grammar productions have a problem, in that they take a
 849    list followed by an ampersand (`&') and do a simple command connection,
 850    making the entire list effectively asynchronous, instead of just
 851    the last command.  This means that when the list is executed, all
 852    the commands have stdin set to /dev/null when job control is not
 853    active, instead of just the last.  This is wrong, and needs fixing
 854    up.  This function takes the `&' and applies it to the last command
 855    in the list.  This is done only for lists connected by `;'; it makes
 856    `;' bind `tighter' than `&'. */
 857 COMMAND *
 858 connect_async_list (command, command2, connector)
 859      COMMAND *command, *command2;
 860      int connector;
 861 {
 862   COMMAND *t, *t1, *t2;
 863
 864   t1 = command;
 865   t = command->value.Connection->second;
 866
 867   if (!t || (command->flags & CMD_WANT_SUBSHELL) ||
 868       command->value.Connection->connector != ';')
 869     {
 870       t = command_connect (command, command2, connector);
 871       return t;
 872     }
 873
 874   /* This is just defensive programming.  The Yacc precedence rules
 875      will generally hand this function a command where t points directly
 876      to the command we want (e.g. given a ; b ; c ; d &, t1 will point
 877      to the `a ; b ; c' list and t will be the `d').  We only want to do
 878      this if the list is not being executed as a unit in the background
 879      with `( ... )', so we have to check for CMD_WANT_SUBSHELL.  That's
 880      the only way to tell. */
 881   while (((t->flags & CMD_WANT_SUBSHELL) == 0) && t->type == cm_connection &&
 882          t->value.Connection->connector == ';')
 883     {
 884       t1 = t;
 885       t = t->value.Connection->second;
 886     }
 887   /* Now we have t pointing to the last command in the list, and
 888      t1->value.Connection->second == t. */
 889   t2 = command_connect (t, command2, connector);
 890   t1->value.Connection->second = t2;
 891   return command;
 892 }