make_cmd.c

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