y.tab.c

   1 /* A Bison parser, made by GNU Bison 2.3.  */
   2
   3 /* Skeleton implementation for Bison's Yacc-like parsers in C
   4
   5    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
   6    Free Software Foundation, Inc.
   7
   8    This program 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 2, or (at your option)
  11    any later version.
  12
  13    This program 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 this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 /* As a special exception, you may create a larger work that contains
  24    part or all of the Bison parser skeleton and distribute that work
  25    under terms of your choice, so long as that work isn't itself a
  26    parser generator using the skeleton or a modified version thereof
  27    as a parser skeleton.  Alternatively, if you modify or redistribute
  28    the parser skeleton itself, you may (at your option) remove this
  29    special exception, which will cause the skeleton and the resulting
  30    Bison output files to be licensed under the GNU General Public
  31    License without this special exception.
  32
  33    This special exception was added by the Free Software Foundation in
  34    version 2.2 of Bison.  */
  35
  36 /* C LALR(1) parser skeleton written by Richard Stallman, by
  37    simplifying the original so-called "semantic" parser.  */
  38
  39 /* All symbols defined below should begin with yy or YY, to avoid
  40    infringing on user name space.  This should be done even for local
  41    variables, as they might otherwise be expanded by user macros.
  42    There are some unavoidable exceptions within include files to
  43    define necessary library symbols; they are noted "INFRINGES ON
  44    USER NAME SPACE" below.  */
  45
  46 /* Identify Bison output.  */
  47 #define YYBISON 1
  48
  49 /* Bison version.  */
  50 #define YYBISON_VERSION "2.3"
  51
  52 /* Skeleton name.  */
  53 #define YYSKELETON_NAME "yacc.c"
  54
  55 /* Pure parsers.  */
  56 #define YYPURE 0
  57
  58 /* Using locations.  */
  59 #define YYLSP_NEEDED 0
  60
  61
  62
  63 /* Tokens.  */
  64 #ifndef YYTOKENTYPE
  65 # define YYTOKENTYPE
  66    /* Put the tokens into the symbol table, so that GDB and other debuggers
  67       know about them.  */
  68    enum yytokentype {
  69      IF = 258,
  70      THEN = 259,
  71      ELSE = 260,
  72      ELIF = 261,
  73      FI = 262,
  74      CASE = 263,
  75      ESAC = 264,
  76      FOR = 265,
  77      SELECT = 266,
  78      WHILE = 267,
  79      UNTIL = 268,
  80      DO = 269,
  81      DONE = 270,
  82      FUNCTION = 271,
  83      COPROC = 272,
  84      COND_START = 273,
  85      COND_END = 274,
  86      COND_ERROR = 275,
  87      IN = 276,
  88      BANG = 277,
  89      TIME = 278,
  90      TIMEOPT = 279,
  91      WORD = 280,
  92      ASSIGNMENT_WORD = 281,
  93      REDIR_WORD = 282,
  94      NUMBER = 283,
  95      ARITH_CMD = 284,
  96      ARITH_FOR_EXPRS = 285,
  97      COND_CMD = 286,
  98      AND_AND = 287,
  99      OR_OR = 288,
 100      GREATER_GREATER = 289,
 101      LESS_LESS = 290,
 102      LESS_AND = 291,
 103      LESS_LESS_LESS = 292,
 104      GREATER_AND = 293,
 105      SEMI_SEMI = 294,
 106      SEMI_AND = 295,
 107      SEMI_SEMI_AND = 296,
 108      LESS_LESS_MINUS = 297,
 109      AND_GREATER = 298,
 110      AND_GREATER_GREATER = 299,
 111      LESS_GREATER = 300,
 112      GREATER_BAR = 301,
 113      BAR_AND = 302,
 114      yacc_EOF = 303
 115    };
 116 #endif
 117 /* Tokens.  */
 118 #define IF 258
 119 #define THEN 259
 120 #define ELSE 260
 121 #define ELIF 261
 122 #define FI 262
 123 #define CASE 263
 124 #define ESAC 264
 125 #define FOR 265
 126 #define SELECT 266
 127 #define WHILE 267
 128 #define UNTIL 268
 129 #define DO 269
 130 #define DONE 270
 131 #define FUNCTION 271
 132 #define COPROC 272
 133 #define COND_START 273
 134 #define COND_END 274
 135 #define COND_ERROR 275
 136 #define IN 276
 137 #define BANG 277
 138 #define TIME 278
 139 #define TIMEOPT 279
 140 #define WORD 280
 141 #define ASSIGNMENT_WORD 281
 142 #define REDIR_WORD 282
 143 #define NUMBER 283
 144 #define ARITH_CMD 284
 145 #define ARITH_FOR_EXPRS 285
 146 #define COND_CMD 286
 147 #define AND_AND 287
 148 #define OR_OR 288
 149 #define GREATER_GREATER 289
 150 #define LESS_LESS 290
 151 #define LESS_AND 291
 152 #define LESS_LESS_LESS 292
 153 #define GREATER_AND 293
 154 #define SEMI_SEMI 294
 155 #define SEMI_AND 295
 156 #define SEMI_SEMI_AND 296
 157 #define LESS_LESS_MINUS 297
 158 #define AND_GREATER 298
 159 #define AND_GREATER_GREATER 299
 160 #define LESS_GREATER 300
 161 #define GREATER_BAR 301
 162 #define BAR_AND 302
 163 #define yacc_EOF 303
 164
 165
 166
 167
 168 /* Copy the first part of user declarations.  */
 169 #line 21 "/Users/chet/src/bash/src/parse.y"
 170
 171 #include "config.h"
 172
 173 #include "bashtypes.h"
 174 #include "bashansi.h"
 175
 176 #include "filecntl.h"
 177
 178 #if defined (HAVE_UNISTD_H)
 179 #  include <unistd.h>
 180 #endif
 181
 182 #if defined (HAVE_LOCALE_H)
 183 #  include <locale.h>
 184 #endif
 185
 186 #include <stdio.h>
 187 #include "chartypes.h"
 188 #include <signal.h>
 189
 190 #include "memalloc.h"
 191
 192 #include "bashintl.h"
 193
 194 #define NEED_STRFTIME_DECL      /* used in externs.h */
 195
 196 #include "shell.h"
 197 #include "trap.h"
 198 #include "flags.h"
 199 #include "parser.h"
 200 #include "mailcheck.h"
 201 #include "test.h"
 202 #include "builtins.h"
 203 #include "builtins/common.h"
 204 #include "builtins/builtext.h"
 205
 206 #include "shmbutil.h"
 207
 208 #if defined (READLINE)
 209 #  include "bashline.h"
 210 #  include <readline/readline.h>
 211 #endif /* READLINE */
 212
 213 #if defined (HISTORY)
 214 #  include "bashhist.h"
 215 #  include <readline/history.h>
 216 #endif /* HISTORY */
 217
 218 #if defined (JOB_CONTROL)
 219 #  include "jobs.h"
 220 #endif /* JOB_CONTROL */
 221
 222 #if defined (ALIAS)
 223 #  include "alias.h"
 224 #else
 225 typedef void *alias_t;
 226 #endif /* ALIAS */
 227
 228 #if defined (PROMPT_STRING_DECODE)
 229 #  ifndef _MINIX
 230 #    include <sys/param.h>
 231 #  endif
 232 #  include <time.h>
 233 #  if defined (TM_IN_SYS_TIME)
 234 #    include <sys/types.h>
 235 #    include <sys/time.h>
 236 #  endif /* TM_IN_SYS_TIME */
 237 #  include "maxpath.h"
 238 #endif /* PROMPT_STRING_DECODE */
 239
 240 #define RE_READ_TOKEN   -99
 241 #define NO_EXPANSION    -100
 242
 243 #ifdef DEBUG
 244 #  define YYDEBUG 1
 245 #else
 246 #  define YYDEBUG 0
 247 #endif
 248
 249 #if defined (HANDLE_MULTIBYTE)
 250 #  define last_shell_getc_is_singlebyte \
 251         ((shell_input_line_index > 1) \
 252                 ? shell_input_line_property[shell_input_line_index - 1] \
 253                 : 1)
 254 #  define MBTEST(x)     ((x) && last_shell_getc_is_singlebyte)
 255 #else
 256 #  define last_shell_getc_is_singlebyte 1
 257 #  define MBTEST(x)     ((x))
 258 #endif
 259
 260 #if defined (EXTENDED_GLOB)
 261 extern int extended_glob;
 262 #endif
 263
 264 extern int eof_encountered;
 265 extern int no_line_editing, running_under_emacs;
 266 extern int current_command_number;
 267 extern int sourcelevel, parse_and_execute_level;
 268 extern int posixly_correct;
 269 extern int last_command_exit_value;
 270 extern pid_t last_command_subst_pid;
 271 extern char *shell_name, *current_host_name;
 272 extern char *dist_version;
 273 extern int patch_level;
 274 extern int dump_translatable_strings, dump_po_strings;
 275 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
 276 #if defined (BUFFERED_INPUT)
 277 extern int bash_input_fd_changed;
 278 #endif
 279
 280 extern int errno;
 281 /* **************************************************************** */
 282 /*                                                                  */
 283 /*                  "Forward" declarations                          */
 284 /*                                                                  */
 285 /* **************************************************************** */
 286
 287 #ifdef DEBUG
 288 static void debug_parser __P((int));
 289 #endif
 290
 291 static int yy_getc __P((void));
 292 static int yy_ungetc __P((int));
 293
 294 #if defined (READLINE)
 295 static int yy_readline_get __P((void));
 296 static int yy_readline_unget __P((int));
 297 #endif
 298
 299 static int yy_string_get __P((void));
 300 static int yy_string_unget __P((int));
 301 static void rewind_input_string __P((void));
 302 static int yy_stream_get __P((void));
 303 static int yy_stream_unget __P((int));
 304
 305 static int shell_getc __P((int));
 306 static void shell_ungetc __P((int));
 307 static void discard_until __P((int));
 308
 309 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
 310 static void push_string __P((char *, int, alias_t *));
 311 static void pop_string __P((void));
 312 static void free_string_list __P((void));
 313 #endif
 314
 315 static char *read_a_line __P((int));
 316
 317 static int reserved_word_acceptable __P((int));
 318 static int yylex __P((void));
 319 static int alias_expand_token __P((char *));
 320 static int time_command_acceptable __P((void));
 321 static int special_case_tokens __P((char *));
 322 static int read_token __P((int));
 323 static char *parse_matched_pair __P((int, int, int, int *, int));
 324 static char *parse_comsub __P((int, int, int, int *, int));
 325 #if defined (ARRAY_VARS)
 326 static char *parse_compound_assignment __P((int *));
 327 #endif
 328 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
 329 static int parse_dparen __P((int));
 330 static int parse_arith_cmd __P((char **, int));
 331 #endif
 332 #if defined (COND_COMMAND)
 333 static void cond_error __P((void));
 334 static COND_COM *cond_expr __P((void));
 335 static COND_COM *cond_or __P((void));
 336 static COND_COM *cond_and __P((void));
 337 static COND_COM *cond_term __P((void));
 338 static int cond_skip_newlines __P((void));
 339 static COMMAND *parse_cond_command __P((void));
 340 #endif
 341 #if defined (ARRAY_VARS)
 342 static int token_is_assignment __P((char *, int));
 343 static int token_is_ident __P((char *, int));
 344 #endif
 345 static int read_token_word __P((int));
 346 static void discard_parser_constructs __P((int));
 347
 348 static char *error_token_from_token __P((int));
 349 static char *error_token_from_text __P((void));
 350 static void print_offending_line __P((void));
 351 static void report_syntax_error __P((char *));
 352
 353 static void handle_eof_input_unit __P((void));
 354 static void prompt_again __P((void));
 355 #if 0
 356 static void reset_readline_prompt __P((void));
 357 #endif
 358 static void print_prompt __P((void));
 359
 360 #if defined (HANDLE_MULTIBYTE)
 361 static void set_line_mbstate __P((void));
 362 static char *shell_input_line_property = NULL;
 363 #else
 364 #  define set_line_mbstate()
 365 #endif
 366
 367 extern int yyerror __P((const char *));
 368
 369 #ifdef DEBUG
 370 extern int yydebug;
 371 #endif
 372
 373 /* Default prompt strings */
 374 char *primary_prompt = PPROMPT;
 375 char *secondary_prompt = SPROMPT;
 376
 377 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
 378 char *ps1_prompt, *ps2_prompt;
 379
 380 /* Handle on the current prompt string.  Indirectly points through
 381    ps1_ or ps2_prompt. */
 382 char **prompt_string_pointer = (char **)NULL;
 383 char *current_prompt_string;
 384
 385 /* Non-zero means we expand aliases in commands. */
 386 int expand_aliases = 0;
 387
 388 /* If non-zero, the decoded prompt string undergoes parameter and
 389    variable substitution, command substitution, arithmetic substitution,
 390    string expansion, process substitution, and quote removal in
 391    decode_prompt_string. */
 392 int promptvars = 1;
 393
 394 /* If non-zero, $'...' and $"..." are expanded when they appear within
 395    a ${...} expansion, even when the expansion appears within double
 396    quotes. */
 397 int extended_quote = 1;
 398
 399 /* The number of lines read from input while creating the current command. */
 400 int current_command_line_count;
 401
 402 /* The token that currently denotes the end of parse. */
 403 int shell_eof_token;
 404
 405 /* The token currently being read. */
 406 int current_token;
 407
 408 /* The current parser state. */
 409 int parser_state;
 410
 411 /* Variables to manage the task of reading here documents, because we need to
 412    defer the reading until after a complete command has been collected. */
 413 static REDIRECT *redir_stack[10];
 414 int need_here_doc;
 415
 416 /* Where shell input comes from.  History expansion is performed on each
 417    line when the shell is interactive. */
 418 static char *shell_input_line = (char *)NULL;
 419 static int shell_input_line_index;
 420 static int shell_input_line_size;       /* Amount allocated for shell_input_line. */
 421 static int shell_input_line_len;        /* strlen (shell_input_line) */
 422
 423 /* Either zero or EOF. */
 424 static int shell_input_line_terminator;
 425
 426 /* The line number in a script on which a function definition starts. */
 427 static int function_dstart;
 428
 429 /* The line number in a script on which a function body starts. */
 430 static int function_bstart;
 431
 432 /* The line number in a script at which an arithmetic for command starts. */
 433 static int arith_for_lineno;
 434
 435 /* The decoded prompt string.  Used if READLINE is not defined or if
 436    editing is turned off.  Analogous to current_readline_prompt. */
 437 static char *current_decoded_prompt;
 438
 439 /* The last read token, or NULL.  read_token () uses this for context
 440    checking. */
 441 static int last_read_token;
 442
 443 /* The token read prior to last_read_token. */
 444 static int token_before_that;
 445
 446 /* The token read prior to token_before_that. */
 447 static int two_tokens_ago;
 448
 449 static int global_extglob;
 450
 451 /* The line number in a script where the word in a `case WORD', `select WORD'
 452    or `for WORD' begins.  This is a nested command maximum, since the array
 453    index is decremented after a case, select, or for command is parsed. */
 454 #define MAX_CASE_NEST   128
 455 static int word_lineno[MAX_CASE_NEST];
 456 static int word_top = -1;
 457
 458 /* If non-zero, it is the token that we want read_token to return
 459    regardless of what text is (or isn't) present to be read.  This
 460    is reset by read_token.  If token_to_read == WORD or
 461    ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
 462 static int token_to_read;
 463 static WORD_DESC *word_desc_to_read;
 464
 465 static REDIRECTEE source;
 466 static REDIRECTEE redir;
 467
 468
 469 /* Enabling traces.  */
 470 #ifndef YYDEBUG
 471 # define YYDEBUG 0
 472 #endif
 473
 474 /* Enabling verbose error messages.  */
 475 #ifdef YYERROR_VERBOSE
 476 # undef YYERROR_VERBOSE
 477 # define YYERROR_VERBOSE 1
 478 #else
 479 # define YYERROR_VERBOSE 0
 480 #endif
 481
 482 /* Enabling the token table.  */
 483 #ifndef YYTOKEN_TABLE
 484 # define YYTOKEN_TABLE 0
 485 #endif
 486
 487 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
 488 typedef union YYSTYPE
 489 #line 320 "/Users/chet/src/bash/src/parse.y"
 490 {
 491   WORD_DESC *word;              /* the word that we read. */
 492   int number;                   /* the number that we read. */
 493   WORD_LIST *word_list;
 494   COMMAND *command;
 495   REDIRECT *redirect;
 496   ELEMENT element;
 497   PATTERN_LIST *pattern;
 498 }
 499 /* Line 187 of yacc.c.  */
 500 #line 501 "y.tab.c"
 501         YYSTYPE;
 502 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
 503 # define YYSTYPE_IS_DECLARED 1
 504 # define YYSTYPE_IS_TRIVIAL 1
 505 #endif
 506
 507
 508
 509 /* Copy the second part of user declarations.  */
 510
 511
 512 /* Line 216 of yacc.c.  */
 513 #line 514 "y.tab.c"
 514
 515 #ifdef short
 516 # undef short
 517 #endif
 518
 519 #ifdef YYTYPE_UINT8
 520 typedef YYTYPE_UINT8 yytype_uint8;
 521 #else
 522 typedef unsigned char yytype_uint8;
 523 #endif
 524
 525 #ifdef YYTYPE_INT8
 526 typedef YYTYPE_INT8 yytype_int8;
 527 #elif (defined __STDC__ || defined __C99__FUNC__ \
 528      || defined __cplusplus || defined _MSC_VER)
 529 typedef signed char yytype_int8;
 530 #else
 531 typedef short int yytype_int8;
 532 #endif
 533
 534 #ifdef YYTYPE_UINT16
 535 typedef YYTYPE_UINT16 yytype_uint16;
 536 #else
 537 typedef unsigned short int yytype_uint16;
 538 #endif
 539
 540 #ifdef YYTYPE_INT16
 541 typedef YYTYPE_INT16 yytype_int16;
 542 #else
 543 typedef short int yytype_int16;
 544 #endif
 545
 546 #ifndef YYSIZE_T
 547 # ifdef __SIZE_TYPE__
 548 #  define YYSIZE_T __SIZE_TYPE__
 549 # elif defined size_t
 550 #  define YYSIZE_T size_t
 551 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
 552      || defined __cplusplus || defined _MSC_VER)
 553 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
 554 #  define YYSIZE_T size_t
 555 # else
 556 #  define YYSIZE_T unsigned int
 557 # endif
 558 #endif
 559
 560 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 561
 562 #ifndef YY_
 563 # if YYENABLE_NLS
 564 #  if ENABLE_NLS
 565 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 566 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
 567 #  endif
 568 # endif
 569 # ifndef YY_
 570 #  define YY_(msgid) msgid
 571 # endif
 572 #endif
 573
 574 /* Suppress unused-variable warnings by "using" E.  */
 575 #if ! defined lint || defined __GNUC__
 576 # define YYUSE(e) ((void) (e))
 577 #else
 578 # define YYUSE(e) /* empty */
 579 #endif
 580
 581 /* Identity function, used to suppress warnings about constant conditions.  */
 582 #ifndef lint
 583 # define YYID(n) (n)
 584 #else
 585 #if (defined __STDC__ || defined __C99__FUNC__ \
 586      || defined __cplusplus || defined _MSC_VER)
 587 static int
 588 YYID (int i)
 589 #else
 590 static int
 591 YYID (i)
 592     int i;
 593 #endif
 594 {
 595   return i;
 596 }
 597 #endif
 598
 599 #if ! defined yyoverflow || YYERROR_VERBOSE
 600
 601 /* The parser invokes alloca or malloc; define the necessary symbols.  */
 602
 603 # ifdef YYSTACK_USE_ALLOCA
 604 #  if YYSTACK_USE_ALLOCA
 605 #   ifdef __GNUC__
 606 #    define YYSTACK_ALLOC __builtin_alloca
 607 #   elif defined __BUILTIN_VA_ARG_INCR
 608 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
 609 #   elif defined _AIX
 610 #    define YYSTACK_ALLOC __alloca
 611 #   elif defined _MSC_VER
 612 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
 613 #    define alloca _alloca
 614 #   else
 615 #    define YYSTACK_ALLOC alloca
 616 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 617      || defined __cplusplus || defined _MSC_VER)
 618 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 619 #     ifndef _STDLIB_H
 620 #      define _STDLIB_H 1
 621 #     endif
 622 #    endif
 623 #   endif
 624 #  endif
 625 # endif
 626
 627 # ifdef YYSTACK_ALLOC
 628    /* Pacify GCC's `empty if-body' warning.  */
 629 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
 630 #  ifndef YYSTACK_ALLOC_MAXIMUM
 631     /* The OS might guarantee only one guard page at the bottom of the stack,
 632        and a page size can be as small as 4096 bytes.  So we cannot safely
 633        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
 634        to allow for a few compiler-allocated temporary stack slots.  */
 635 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
 636 #  endif
 637 # else
 638 #  define YYSTACK_ALLOC YYMALLOC
 639 #  define YYSTACK_FREE YYFREE
 640 #  ifndef YYSTACK_ALLOC_MAXIMUM
 641 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 642 #  endif
 643 #  if (defined __cplusplus && ! defined _STDLIB_H \
 644        && ! ((defined YYMALLOC || defined malloc) \
 645              && (defined YYFREE || defined free)))
 646 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
 647 #   ifndef _STDLIB_H
 648 #    define _STDLIB_H 1
 649 #   endif
 650 #  endif
 651 #  ifndef YYMALLOC
 652 #   define YYMALLOC malloc
 653 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 654      || defined __cplusplus || defined _MSC_VER)
 655 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 656 #   endif
 657 #  endif
 658 #  ifndef YYFREE
 659 #   define YYFREE free
 660 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
 661      || defined __cplusplus || defined _MSC_VER)
 662 void free (void *); /* INFRINGES ON USER NAME SPACE */
 663 #   endif
 664 #  endif
 665 # endif
 666 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
 667
 668
 669 #if (! defined yyoverflow \
 670      && (! defined __cplusplus \
 671          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
 672
 673 /* A type that is properly aligned for any stack member.  */
 674 union yyalloc
 675 {
 676   yytype_int16 yyss;
 677   YYSTYPE yyvs;
 678   };
 679
 680 /* The size of the maximum gap between one aligned stack and the next.  */
 681 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
 682
 683 /* The size of an array large to enough to hold all stacks, each with
 684    N elements.  */
 685 # define YYSTACK_BYTES(N) \
 686      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
 687       + YYSTACK_GAP_MAXIMUM)
 688
 689 /* Copy COUNT objects from FROM to TO.  The source and destination do
 690    not overlap.  */
 691 # ifndef YYCOPY
 692 #  if defined __GNUC__ && 1 < __GNUC__
 693 #   define YYCOPY(To, From, Count) \
 694       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
 695 #  else
 696 #   define YYCOPY(To, From, Count)              \
 697       do                                        \
 698         {                                       \
 699           YYSIZE_T yyi;                         \
 700           for (yyi = 0; yyi < (Count); yyi++)   \
 701             (To)[yyi] = (From)[yyi];            \
 702         }                                       \
 703       while (YYID (0))
 704 #  endif
 705 # endif
 706
 707 /* Relocate STACK from its old location to the new one.  The
 708    local variables YYSIZE and YYSTACKSIZE give the old and new number of
 709    elements in the stack, and YYPTR gives the new location of the
 710    stack.  Advance YYPTR to a properly aligned location for the next
 711    stack.  */
 712 # define YYSTACK_RELOCATE(Stack)                                        \
 713     do                                                                  \
 714       {                                                                 \
 715         YYSIZE_T yynewbytes;                                            \
 716         YYCOPY (&yyptr->Stack, Stack, yysize);                          \
 717         Stack = &yyptr->Stack;                                          \
 718         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
 719         yyptr += yynewbytes / sizeof (*yyptr);                          \
 720       }                                                                 \
 721     while (YYID (0))
 722
 723 #endif
 724
 725 /* YYFINAL -- State number of the termination state.  */
 726 #define YYFINAL  113
 727 /* YYLAST -- Last index in YYTABLE.  */
 728 #define YYLAST   760
 729
 730 /* YYNTOKENS -- Number of terminals.  */
 731 #define YYNTOKENS  60
 732 /* YYNNTS -- Number of nonterminals.  */
 733 #define YYNNTS  38
 734 /* YYNRULES -- Number of rules.  */
 735 #define YYNRULES  167
 736 /* YYNRULES -- Number of states.  */
 737 #define YYNSTATES  344
 738
 739 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 740 #define YYUNDEFTOK  2
 741 #define YYMAXUTOK   303
 742
 743 #define YYTRANSLATE(YYX)                                                \
 744   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 745
 746 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
 747 static const yytype_uint8 yytranslate[] =
 748 {
 749        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 750       50,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 751        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 752        2,     2,     2,     2,     2,     2,     2,     2,    48,     2,
 753       58,    59,     2,     2,     2,    55,     2,     2,     2,     2,
 754        2,     2,     2,     2,     2,     2,     2,     2,     2,    49,
 755       54,     2,    53,     2,     2,     2,     2,     2,     2,     2,
 756        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 757        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 758        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 759        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 760        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 761        2,     2,     2,    56,    52,    57,     2,     2,     2,     2,
 762        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 763        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 764        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 765        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 766        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 767        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 768        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 769        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 770        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 771        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 772        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 773        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 774        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
 775        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
 776       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
 777       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
 778       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
 779       45,    46,    47,    51
 780 };
 781
 782 #if YYDEBUG
 783 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
 784    YYRHS.  */
 785 static const yytype_uint16 yyprhs[] =
 786 {
 787        0,     0,     3,     6,     8,    11,    13,    15,    18,    21,
 788       24,    28,    32,    36,    40,    43,    47,    51,    54,    58,
 789       62,    65,    69,    73,    76,    80,    84,    87,    91,    95,
 790       98,   102,   106,   109,   113,   117,   120,   124,   128,   131,
 791      135,   139,   142,   146,   150,   153,   157,   161,   164,   168,
 792      172,   175,   178,   180,   182,   184,   186,   189,   191,   194,
 793      196,   198,   201,   203,   205,   207,   209,   215,   221,   223,
 794      225,   227,   229,   231,   233,   235,   242,   249,   257,   265,
 795      276,   287,   297,   307,   315,   323,   329,   335,   342,   349,
 796      357,   365,   376,   387,   394,   402,   409,   415,   422,   427,
 797      429,   432,   436,   439,   443,   447,   452,   455,   461,   469,
 798      476,   480,   482,   486,   491,   498,   504,   506,   509,   514,
 799      519,   525,   531,   534,   538,   541,   545,   548,   552,   554,
 800      558,   561,   563,   566,   570,   574,   578,   583,   588,   593,
 801      598,   603,   605,   607,   609,   611,   613,   615,   616,   619,
 802      621,   624,   627,   632,   637,   641,   645,   647,   649,   652,
 803      655,   659,   663,   666,   671,   676,   678,   680
 804 };
 805
 806 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 807 static const yytype_int8 yyrhs[] =
 808 {
 809       61,     0,    -1,    93,    90,    -1,    50,    -1,     1,    50,
 810       -1,    51,    -1,    25,    -1,    62,    25,    -1,    53,    25,
 811       -1,    54,    25,    -1,    28,    53,    25,    -1,    28,    54,
 812       25,    -1,    27,    53,    25,    -1,    27,    54,    25,    -1,
 813       34,    25,    -1,    28,    34,    25,    -1,    27,    34,    25,
 814       -1,    46,    25,    -1,    28,    46,    25,    -1,    27,    46,
 815       25,    -1,    45,    25,    -1,    28,    45,    25,    -1,    27,
 816       45,    25,    -1,    35,    25,    -1,    28,    35,    25,    -1,
 817       27,    35,    25,    -1,    42,    25,    -1,    28,    42,    25,
 818       -1,    27,    42,    25,    -1,    37,    25,    -1,    28,    37,
 819       25,    -1,    27,    37,    25,    -1,    36,    28,    -1,    28,
 820       36,    28,    -1,    27,    36,    28,    -1,    38,    28,    -1,
 821       28,    38,    28,    -1,    27,    38,    28,    -1,    36,    25,
 822       -1,    28,    36,    25,    -1,    27,    36,    25,    -1,    38,
 823       25,    -1,    28,    38,    25,    -1,    27,    38,    25,    -1,
 824       38,    55,    -1,    28,    38,    55,    -1,    27,    38,    55,
 825       -1,    36,    55,    -1,    28,    36,    55,    -1,    27,    36,
 826       55,    -1,    43,    25,    -1,    44,    25,    -1,    25,    -1,
 827       26,    -1,    63,    -1,    63,    -1,    65,    63,    -1,    64,
 828       -1,    66,    64,    -1,    66,    -1,    68,    -1,    68,    65,
 829       -1,    73,    -1,    76,    -1,    69,    -1,    72,    -1,    12,
 830       87,    14,    87,    15,    -1,    13,    87,    14,    87,    15,
 831       -1,    71,    -1,    77,    -1,    75,    -1,    78,    -1,    79,
 832       -1,    80,    -1,    70,    -1,    10,    25,    92,    14,    87,
 833       15,    -1,    10,    25,    92,    56,    87,    57,    -1,    10,
 834       25,    49,    92,    14,    87,    15,    -1,    10,    25,    49,
 835       92,    56,    87,    57,    -1,    10,    25,    92,    21,    62,
 836       91,    92,    14,    87,    15,    -1,    10,    25,    92,    21,
 837       62,    91,    92,    56,    87,    57,    -1,    10,    25,    92,
 838       21,    91,    92,    14,    87,    15,    -1,    10,    25,    92,
 839       21,    91,    92,    56,    87,    57,    -1,    10,    30,    91,
 840       92,    14,    87,    15,    -1,    10,    30,    91,    92,    56,
 841       87,    57,    -1,    10,    30,    14,    87,    15,    -1,    10,
 842       30,    56,    87,    57,    -1,    11,    25,    92,    14,    86,
 843       15,    -1,    11,    25,    92,    56,    86,    57,    -1,    11,
 844       25,    49,    92,    14,    86,    15,    -1,    11,    25,    49,
 845       92,    56,    86,    57,    -1,    11,    25,    92,    21,    62,
 846       91,    92,    14,    86,    15,    -1,    11,    25,    92,    21,
 847       62,    91,    92,    56,    86,    57,    -1,     8,    25,    92,
 848       21,    92,     9,    -1,     8,    25,    92,    21,    84,    92,
 849        9,    -1,     8,    25,    92,    21,    82,     9,    -1,    25,
 850       58,    59,    92,    74,    -1,    16,    25,    58,    59,    92,
 851       74,    -1,    16,    25,    92,    74,    -1,    68,    -1,    68,
 852       65,    -1,    58,    87,    59,    -1,    17,    68,    -1,    17,
 853       68,    65,    -1,    17,    25,    68,    -1,    17,    25,    68,
 854       65,    -1,    17,    66,    -1,     3,    87,     4,    87,     7,
 855       -1,     3,    87,     4,    87,     5,    87,     7,    -1,     3,
 856       87,     4,    87,    81,     7,    -1,    56,    87,    57,    -1,
 857       29,    -1,    18,    31,    19,    -1,     6,    87,     4,    87,
 858       -1,     6,    87,     4,    87,     5,    87,    -1,     6,    87,
 859        4,    87,    81,    -1,    83,    -1,    84,    83,    -1,    92,
 860       85,    59,    87,    -1,    92,    85,    59,    92,    -1,    92,
 861       58,    85,    59,    87,    -1,    92,    58,    85,    59,    92,
 862       -1,    83,    39,    -1,    84,    83,    39,    -1,    83,    40,
 863       -1,    84,    83,    40,    -1,    83,    41,    -1,    84,    83,
 864       41,    -1,    25,    -1,    85,    52,    25,    -1,    92,    88,
 865       -1,    86,    -1,    92,    89,    -1,    89,    50,    92,    -1,
 866       89,    48,    92,    -1,    89,    49,    92,    -1,    89,    32,
 867       92,    89,    -1,    89,    33,    92,    89,    -1,    89,    48,
 868       92,    89,    -1,    89,    49,    92,    89,    -1,    89,    50,
 869       92,    89,    -1,    95,    -1,    50,    -1,    51,    -1,    50,
 870       -1,    49,    -1,    51,    -1,    -1,    92,    50,    -1,    94,
 871       -1,    94,    48,    -1,    94,    49,    -1,    94,    32,    92,
 872       94,    -1,    94,    33,    92,    94,    -1,    94,    48,    94,
 873       -1,    94,    49,    94,    -1,    95,    -1,    96,    -1,    22,
 874       96,    -1,    97,    96,    -1,    97,    22,    96,    -1,    22,
 875       97,    96,    -1,    97,    91,    -1,    96,    52,    92,    96,
 876       -1,    96,    47,    92,    96,    -1,    67,    -1,    23,    -1,
 877       23,    24,    -1
 878 };
 879
 880 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 881 static const yytype_uint16 yyrline[] =
 882 {
 883        0,   373,   373,   384,   393,   408,   418,   420,   424,   430,
 884      436,   442,   448,   454,   460,   466,   472,   478,   484,   490,
 885      496,   502,   508,   514,   521,   528,   535,   542,   549,   556,
 886      562,   568,   574,   580,   586,   592,   598,   604,   610,   616,
 887      622,   628,   634,   640,   646,   652,   658,   664,   670,   676,
 888      682,   688,   696,   698,   700,   704,   708,   719,   721,   725,
 889      727,   729,   745,   747,   751,   753,   755,   757,   759,   761,
 890      763,   765,   767,   769,   771,   775,   780,   785,   790,   795,
 891      800,   805,   810,   817,   822,   827,   832,   839,   844,   849,
 892      854,   859,   864,   871,   876,   881,   888,   891,   894,   898,
 893      900,   931,   938,   943,   960,   965,   982,   989,   991,   993,
 894      998,  1002,  1006,  1010,  1012,  1014,  1018,  1019,  1023,  1025,
 895     1027,  1029,  1033,  1035,  1037,  1039,  1041,  1043,  1047,  1049,
 896     1058,  1066,  1067,  1073,  1074,  1081,  1085,  1087,  1089,  1096,
 897     1098,  1100,  1104,  1105,  1108,  1110,  1112,  1116,  1117,  1126,
 898     1139,  1155,  1170,  1172,  1174,  1181,  1184,  1188,  1190,  1196,
 899     1202,  1208,  1214,  1234,  1236,  1259,  1263,  1265
 900 };
 901 #endif
 902
 903 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
 904 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 905    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
 906 static const char *const yytname[] =
 907 {
 908   "$end", "error", "$undefined", "IF", "THEN", "ELSE", "ELIF", "FI",
 909   "CASE", "ESAC", "FOR", "SELECT", "WHILE", "UNTIL", "DO", "DONE",
 910   "FUNCTION", "COPROC", "COND_START", "COND_END", "COND_ERROR", "IN",
 911   "BANG", "TIME", "TIMEOPT", "WORD", "ASSIGNMENT_WORD", "REDIR_WORD",
 912   "NUMBER", "ARITH_CMD", "ARITH_FOR_EXPRS", "COND_CMD", "AND_AND", "OR_OR",
 913   "GREATER_GREATER", "LESS_LESS", "LESS_AND", "LESS_LESS_LESS",
 914   "GREATER_AND", "SEMI_SEMI", "SEMI_AND", "SEMI_SEMI_AND",
 915   "LESS_LESS_MINUS", "AND_GREATER", "AND_GREATER_GREATER", "LESS_GREATER",
 916   "GREATER_BAR", "BAR_AND", "'&'", "';'", "'\\n'", "yacc_EOF", "'|'",
 917   "'>'", "'<'", "'-'", "'{'", "'}'", "'('", "')'", "$accept", "inputunit",
 918   "word_list", "redirection", "simple_command_element", "redirection_list",
 919   "simple_command", "command", "shell_command", "for_command",
 920   "arith_for_command", "select_command", "case_command", "function_def",
 921   "function_body", "subshell", "coproc", "if_command", "group_command",
 922   "arith_command", "cond_command", "elif_clause", "case_clause",
 923   "pattern_list", "case_clause_sequence", "pattern", "list",
 924   "compound_list", "list0", "list1", "simple_list_terminator",
 925   "list_terminator", "newline_list", "simple_list", "simple_list1",
 926   "pipeline_command", "pipeline", "timespec", 0
 927 };
 928 #endif
 929
 930 # ifdef YYPRINT
 931 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
 932    token YYLEX-NUM.  */
 933 static const yytype_uint16 yytoknum[] =
 934 {
 935        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
 936      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
 937      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
 938      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
 939      295,   296,   297,   298,   299,   300,   301,   302,    38,    59,
 940       10,   303,   124,    62,    60,    45,   123,   125,    40,    41
 941 };
 942 # endif
 943
 944 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 945 static const yytype_uint8 yyr1[] =
 946 {
 947        0,    60,    61,    61,    61,    61,    62,    62,    63,    63,
 948       63,    63,    63,    63,    63,    63,    63,    63,    63,    63,
 949       63,    63,    63,    63,    63,    63,    63,    63,    63,    63,
 950       63,    63,    63,    63,    63,    63,    63,    63,    63,    63,
 951       63,    63,    63,    63,    63,    63,    63,    63,    63,    63,
 952       63,    63,    64,    64,    64,    65,    65,    66,    66,    67,
 953       67,    67,    67,    67,    68,    68,    68,    68,    68,    68,
 954       68,    68,    68,    68,    68,    69,    69,    69,    69,    69,
 955       69,    69,    69,    70,    70,    70,    70,    71,    71,    71,
 956       71,    71,    71,    72,    72,    72,    73,    73,    73,    74,
 957       74,    75,    76,    76,    76,    76,    76,    77,    77,    77,
 958       78,    79,    80,    81,    81,    81,    82,    82,    83,    83,
 959       83,    83,    84,    84,    84,    84,    84,    84,    85,    85,
 960       86,    87,    87,    88,    88,    88,    89,    89,    89,    89,
 961       89,    89,    90,    90,    91,    91,    91,    92,    92,    93,
 962       93,    93,    94,    94,    94,    94,    94,    95,    95,    95,
 963       95,    95,    95,    96,    96,    96,    97,    97
 964 };
 965
 966 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 967 static const yytype_uint8 yyr2[] =
 968 {
 969        0,     2,     2,     1,     2,     1,     1,     2,     2,     2,
 970        3,     3,     3,     3,     2,     3,     3,     2,     3,     3,
 971        2,     3,     3,     2,     3,     3,     2,     3,     3,     2,
 972        3,     3,     2,     3,     3,     2,     3,     3,     2,     3,
 973        3,     2,     3,     3,     2,     3,     3,     2,     3,     3,
 974        2,     2,     1,     1,     1,     1,     2,     1,     2,     1,
 975        1,     2,     1,     1,     1,     1,     5,     5,     1,     1,
 976        1,     1,     1,     1,     1,     6,     6,     7,     7,    10,
 977       10,     9,     9,     7,     7,     5,     5,     6,     6,     7,
 978        7,    10,    10,     6,     7,     6,     5,     6,     4,     1,
 979        2,     3,     2,     3,     3,     4,     2,     5,     7,     6,
 980        3,     1,     3,     4,     6,     5,     1,     2,     4,     4,
 981        5,     5,     2,     3,     2,     3,     2,     3,     1,     3,
 982        2,     1,     2,     3,     3,     3,     4,     4,     4,     4,
 983        4,     1,     1,     1,     1,     1,     1,     0,     2,     1,
 984        2,     2,     4,     4,     3,     3,     1,     1,     2,     2,
 985        3,     3,     2,     4,     4,     1,     1,     2
 986 };
 987
 988 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
 989    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
 990    means the default is an error.  */
 991 static const yytype_uint8 yydefact[] =
 992 {
 993        0,     0,   147,     0,     0,     0,   147,   147,     0,     0,
 994        0,     0,   166,    52,    53,     0,     0,   111,     0,     0,
 995        0,     0,     0,     0,     0,     0,     0,     0,     3,     5,
 996        0,     0,   147,   147,     0,    54,    57,    59,   165,    60,
 997       64,    74,    68,    65,    62,    70,    63,    69,    71,    72,
 998       73,     0,   149,   156,   157,     0,     4,   131,     0,     0,
 999      147,   147,     0,   147,     0,     0,   147,    52,   106,   102,
1000        0,   158,     0,   167,     0,     0,     0,     0,     0,     0,
1001        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
1002        0,     0,     0,     0,     0,    14,    23,    38,    32,    47,
1003       29,    41,    35,    44,    26,    50,    51,    20,    17,     8,
1004        9,     0,     0,     1,    52,    58,    55,    61,   142,   143,
1005        2,   147,   147,   150,   151,   147,   147,     0,   145,   144,
1006      146,   162,   159,   147,   148,   130,   132,   141,     0,   147,
1007        0,   147,   147,   147,   147,     0,   147,   147,     0,     0,
1008      104,   103,   112,   161,   147,    16,    25,    40,    34,    49,
1009       31,    43,    37,    46,    28,    22,    19,    12,    13,    15,
1010       24,    39,    33,    48,    30,    42,    36,    45,    27,    21,
1011       18,    10,    11,   110,   101,    56,     0,     0,   154,   155,
1012        0,     0,   160,     0,   147,   147,   147,   147,   147,   147,
1013        0,   147,     0,   147,     0,     0,     0,     0,   147,     0,
1014      147,     0,     0,   147,    99,    98,   105,     0,   152,   153,
1015        0,     0,   164,   163,   147,   147,   107,     0,     0,     0,
1016      134,   135,   133,     0,   116,   147,     0,   147,   147,     0,
1017        6,     0,   147,     0,    85,    86,   147,   147,   147,   147,
1018        0,     0,     0,     0,    66,    67,     0,   100,    96,     0,
1019        0,   109,   136,   137,   138,   139,   140,    95,   122,   124,
1020      126,   117,     0,    93,   128,     0,     0,     0,     0,    75,
1021        7,   147,     0,    76,     0,     0,     0,     0,    87,     0,
1022      147,    88,    97,   108,   147,   147,   147,   147,   123,   125,
1023      127,    94,     0,     0,   147,    77,    78,     0,   147,   147,
1024       83,    84,    89,    90,     0,   113,     0,     0,     0,   147,
1025      129,   118,   119,   147,   147,     0,     0,   147,   147,   147,
1026      115,   120,   121,     0,     0,    81,    82,     0,     0,   114,
1027       79,    80,    91,    92
1028 };
1029
1030 /* YYDEFGOTO[NTERM-NUM].  */
1031 static const yytype_int16 yydefgoto[] =
1032 {
1033       -1,    34,   241,    35,    36,   117,    37,    38,    39,    40,
1034       41,    42,    43,    44,   215,    45,    46,    47,    48,    49,
1035       50,   227,   233,   234,   235,   276,    57,    58,   135,   136,
1036      120,   131,    59,    51,   188,   137,    54,    55
1037 };
1038
1039 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1040    STATE-NUM.  */
1041 #define YYPACT_NINF -212
1042 static const yytype_int16 yypact[] =
1043 {
1044      318,   -40,  -212,    11,    10,    32,  -212,  -212,    34,   661,
1045       39,   514,    52,    21,  -212,   255,   706,  -212,    65,    79,
1046       47,    98,    55,   133,   134,   139,   151,   152,  -212,  -212,
1047      156,   157,  -212,  -212,   142,  -212,  -212,   232,  -212,   693,
1048     -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,
1049     -212,    49,   213,  -212,   -28,   367,  -212,  -212,   150,   416,
1050     -212,   135,    -3,   137,   184,   194,   158,    31,   232,   693,
1051      191,   -28,   612,  -212,   166,   199,   202,    69,   209,   128,
1052      210,   214,   218,   219,   225,   227,   247,   165,   248,   181,
1053      256,   257,   258,   259,   262,  -212,  -212,  -212,  -212,  -212,
1054     -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,
1055     -212,   237,   236,  -212,  -212,  -212,  -212,   693,  -212,  -212,
1056     -212,  -212,  -212,   465,   465,  -212,  -212,   612,  -212,  -212,
1057     -212,  -212,   -28,  -212,  -212,  -212,   205,  -212,   -13,  -212,
1058      116,  -212,  -212,  -212,  -212,   117,  -212,  -212,   240,    53,
1059      693,   693,  -212,   -28,  -212,  -212,  -212,  -212,  -212,  -212,
1060     -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,
1061     -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,
1062     -212,  -212,  -212,  -212,  -212,  -212,   416,   416,    75,    75,
1063      563,   563,   -28,    15,  -212,  -212,  -212,  -212,  -212,  -212,
1064       72,  -212,   120,  -212,   281,   249,   105,   118,  -212,   279,
1065     -212,   290,   292,  -212,   693,  -212,   693,    53,  -212,  -212,
1066      465,   465,   -28,   -28,  -212,  -212,  -212,   303,   416,   416,
1067      416,   416,   416,   302,   174,  -212,     0,  -212,  -212,   297,
1068     -212,   179,  -212,   263,  -212,  -212,  -212,  -212,  -212,  -212,
1069      299,   416,   179,   265,  -212,  -212,    53,   693,  -212,   308,
1070      312,  -212,  -212,  -212,    80,    80,    80,  -212,  -212,  -212,
1071     -212,   224,    43,  -212,  -212,   300,    33,   309,   270,  -212,
1072     -212,  -212,   129,  -212,   317,   276,   322,   282,  -212,   205,
1073     -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,  -212,
1074     -212,  -212,    46,   313,  -212,  -212,  -212,   149,  -212,  -212,
1075     -212,  -212,  -212,  -212,   161,   115,   416,   416,   416,  -212,
1076     -212,  -212,   416,  -212,  -212,   327,   291,  -212,  -212,  -212,
1077     -212,  -212,   416,   334,   293,  -212,  -212,   336,   301,  -212,
1078     -212,  -212,  -212,  -212
1079 };
1080
1081 /* YYPGOTO[NTERM-NUM].  */
1082 static const yytype_int16 yypgoto[] =
1083 {
1084     -212,  -212,   148,   -36,     1,   -62,   350,  -212,    -5,  -212,
1085     -212,  -212,  -212,  -212,  -211,  -212,  -212,  -212,  -212,  -212,
1086     -212,    50,  -212,   131,  -212,    92,  -194,    -6,  -212,  -200,
1087     -212,   -45,   -48,  -212,     5,     2,    12,   362
1088 };
1089
1090 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
1091    positive, shift that token.  If negative, reduce the rule which
1092    number is the opposite.  If zero, do what YYDEFACT says.
1093    If YYTABLE_NINF, syntax error.  */
1094 #define YYTABLE_NINF -1
1095 static const yytype_uint16 yytable[] =
1096 {
1097       64,    65,    53,   116,    69,    52,   258,   151,   199,   273,
1098       56,   141,   138,   140,   250,   145,   253,   143,   149,   125,
1099      224,   225,   226,    71,   126,   274,   111,   112,   262,   263,
1100      264,   265,   266,   116,     2,    61,    60,   134,   115,     3,
1101       62,     4,     5,     6,     7,   292,   128,   129,   130,    10,
1102      134,   289,   301,   142,   286,   287,     2,    63,   275,    66,
1103       17,     3,   150,     4,     5,     6,     7,   132,   274,   115,
1104       70,    10,    97,   186,   187,    98,    73,   190,   191,    74,
1105      101,   185,    17,   102,   153,   303,   237,    32,   216,    33,
1106       95,   200,   304,   134,   157,   206,   207,   158,   303,   118,
1107      119,   275,    99,   134,    96,   319,   217,   121,   122,    32,
1108      103,    33,   194,   195,   116,   185,   264,   265,   266,   246,
1109      329,   225,   134,   100,   159,    53,    53,   193,   238,   189,
1110      201,   208,   248,   337,   338,   204,   205,   202,   209,   192,
1111      211,   212,   113,   308,   214,   240,   228,   229,   230,   231,
1112      232,   236,   257,   161,   133,   134,   162,   242,   104,   105,
1113      251,   247,   251,   323,   106,   256,   134,   134,   134,   128,
1114      129,   130,   203,   210,   249,   327,   107,   108,   116,   134,
1115      185,   109,   110,   163,   139,   309,   144,   272,    53,    53,
1116      171,   218,   219,   172,   282,   239,   281,   243,   146,   134,
1117      251,   251,   222,   223,   280,   324,   175,   290,   147,   176,
1118      152,   134,   214,   268,   269,   270,   148,   328,   259,   260,
1119      173,   185,    53,    53,   155,   154,   189,   156,   128,   129,
1120      130,   277,   278,   307,   160,   164,   177,   194,   195,   165,
1121      284,   285,   314,   166,   167,   121,   122,   316,   317,   318,
1122      168,   214,   169,   196,   197,   198,   322,   114,    14,    15,
1123       16,   123,   124,   298,   299,   300,    18,    19,    20,    21,
1124       22,   332,   170,   174,    23,    24,    25,    26,    27,   251,
1125      251,   178,   179,   180,   181,    30,    31,   182,   315,    75,
1126       76,    77,    78,    79,   183,   184,   244,    80,   321,   213,
1127       81,    82,   325,   326,   240,   254,   245,   255,    83,    84,
1128      261,   267,   279,   331,   288,   293,   294,   333,   334,     1,
1129      283,     2,   291,   339,   305,   274,     3,   306,     4,     5,
1130        6,     7,   310,   311,     8,     9,    10,   312,   320,   313,
1131       11,    12,   335,    13,    14,    15,    16,    17,   336,   340,
1132      341,   342,    18,    19,    20,    21,    22,   252,   343,    68,
1133       23,    24,    25,    26,    27,   330,   271,   302,    28,    29,
1134        2,    30,    31,    72,    32,     3,    33,     4,     5,     6,
1135        7,     0,     0,     8,     9,    10,     0,     0,     0,   127,
1136        0,     0,    13,    14,    15,    16,    17,     0,     0,     0,
1137        0,    18,    19,    20,    21,    22,     0,     0,     0,    23,
1138       24,    25,    26,    27,     0,     0,   128,   129,   130,     2,
1139       30,    31,     0,    32,     3,    33,     4,     5,     6,     7,
1140        0,     0,     8,     9,    10,     0,     0,     0,    11,    12,
1141        0,    13,    14,    15,    16,    17,     0,     0,     0,     0,
1142       18,    19,    20,    21,    22,     0,     0,     0,    23,    24,
1143       25,    26,    27,     0,     0,     0,   134,     0,     2,    30,
1144       31,     0,    32,     3,    33,     4,     5,     6,     7,     0,
1145        0,     8,     9,    10,     0,     0,     0,    11,    12,     0,
1146       13,    14,    15,    16,    17,     0,     0,     0,     0,    18,
1147       19,    20,    21,    22,     0,     0,     0,    23,    24,    25,
1148       26,    27,     0,     0,     0,     0,     0,     2,    30,    31,
1149        0,    32,     3,    33,     4,     5,     6,     7,     0,     0,
1150        8,     9,    10,     0,     0,     0,     0,    12,     0,    13,
1151       14,    15,    16,    17,     0,     0,     0,     0,    18,    19,
1152       20,    21,    22,     0,     0,     0,    23,    24,    25,    26,
1153       27,     0,     0,     0,     0,     0,     2,    30,    31,     0,
1154       32,     3,    33,     4,     5,     6,     7,     0,     0,     8,
1155        9,    10,     0,     0,     0,     0,     0,     0,    13,    14,
1156       15,    16,    17,     0,     0,     0,     0,    18,    19,    20,
1157       21,    22,     0,     0,     0,    23,    24,    25,    26,    27,
1158        0,     0,     0,   134,     0,     2,    30,    31,     0,    32,
1159        3,    33,     4,     5,     6,     7,     0,     0,     8,     9,
1160       10,     0,     0,     0,     0,     0,     0,    13,    14,    15,
1161       16,    17,     0,     0,     0,     0,    18,    19,    20,    21,
1162       22,     0,     0,     0,    23,    24,    25,    26,    27,     0,
1163        0,     0,     0,     0,     2,    30,    31,     0,    32,     3,
1164       33,     4,     5,     6,     7,     0,     0,     0,     0,    10,
1165        0,     0,     0,     0,     0,     0,    67,    14,    15,    16,
1166       17,     0,     0,     0,     0,    18,    19,    20,    21,    22,
1167        0,     0,     0,    23,    24,    25,    26,    27,     0,     0,
1168        0,     0,     0,     0,    30,    31,     0,    32,     0,    33,
1169       15,    16,     0,     0,     0,     0,     0,    18,    19,    20,
1170       21,    22,     0,     0,     0,    23,    24,    25,    26,    27,
1171       85,    86,    87,    88,    89,     0,    30,    31,    90,     0,
1172        0,    91,    92,     0,     0,     0,     0,     0,     0,    93,
1173       94
1174 };
1175
1176 static const yytype_int16 yycheck[] =
1177 {
1178        6,     7,     0,    39,     9,     0,   217,    69,    21,     9,
1179       50,    14,    60,    61,   208,    63,   210,    62,    66,    47,
1180        5,     6,     7,    11,    52,    25,    32,    33,   228,   229,
1181      230,   231,   232,    69,     3,    25,    25,    50,    37,     8,
1182       30,    10,    11,    12,    13,   256,    49,    50,    51,    18,
1183       50,   251,     9,    56,   248,   249,     3,    25,    58,    25,
1184       29,     8,    67,    10,    11,    12,    13,    55,    25,    68,
1185       31,    18,    25,   121,   122,    28,    24,   125,   126,    58,
1186       25,   117,    29,    28,    72,    52,    14,    56,   150,    58,
1187       25,   139,    59,    50,    25,   143,   144,    28,    52,    50,
1188       51,    58,    55,    50,    25,    59,   154,    32,    33,    56,
1189       55,    58,    32,    33,   150,   151,   316,   317,   318,    14,
1190        5,     6,    50,    25,    55,   123,   124,   133,    56,   124,
1191       14,    14,    14,   327,   328,   141,   142,    21,    21,   127,
1192      146,   147,     0,    14,   149,    25,   194,   195,   196,   197,
1193      198,   199,   214,    25,     4,    50,    28,   202,    25,    25,
1194      208,    56,   210,    14,    25,   213,    50,    50,    50,    49,
1195       50,    51,    56,    56,    56,    14,    25,    25,   214,    50,
1196      216,    25,    25,    55,    49,    56,    49,   235,   186,   187,
1197       25,   186,   187,    28,   242,   201,   241,   203,    14,    50,
1198      248,   249,   190,   191,    25,    56,    25,   252,    14,    28,
1199       19,    50,   217,    39,    40,    41,    58,    56,   224,   225,
1200       55,   257,   220,   221,    25,    59,   221,    25,    49,    50,
1201       51,   237,   238,   281,    25,    25,    55,    32,    33,    25,
1202      246,   247,   290,    25,    25,    32,    33,   295,   296,   297,
1203       25,   256,    25,    48,    49,    50,   304,    25,    26,    27,
1204       28,    48,    49,    39,    40,    41,    34,    35,    36,    37,
1205       38,   319,    25,    25,    42,    43,    44,    45,    46,   327,
1206      328,    25,    25,    25,    25,    53,    54,    25,   294,    34,
1207       35,    36,    37,    38,    57,    59,    15,    42,   304,    59,
1208       45,    46,   308,   309,    25,    15,    57,    15,    53,    54,
1209        7,     9,    15,   319,    15,     7,     4,   323,   324,     1,
1210       57,     3,    57,   329,    15,    25,     8,    57,    10,    11,
1211       12,    13,    15,    57,    16,    17,    18,    15,    25,    57,
1212       22,    23,    15,    25,    26,    27,    28,    29,    57,    15,
1213       57,    15,    34,    35,    36,    37,    38,   209,    57,     9,
1214       42,    43,    44,    45,    46,   315,   235,   275,    50,    51,
1215        3,    53,    54,    11,    56,     8,    58,    10,    11,    12,
1216       13,    -1,    -1,    16,    17,    18,    -1,    -1,    -1,    22,
1217       -1,    -1,    25,    26,    27,    28,    29,    -1,    -1,    -1,
1218       -1,    34,    35,    36,    37,    38,    -1,    -1,    -1,    42,
1219       43,    44,    45,    46,    -1,    -1,    49,    50,    51,     3,
1220       53,    54,    -1,    56,     8,    58,    10,    11,    12,    13,
1221       -1,    -1,    16,    17,    18,    -1,    -1,    -1,    22,    23,
1222       -1,    25,    26,    27,    28,    29,    -1,    -1,    -1,    -1,
1223       34,    35,    36,    37,    38,    -1,    -1,    -1,    42,    43,
1224       44,    45,    46,    -1,    -1,    -1,    50,    -1,     3,    53,
1225       54,    -1,    56,     8,    58,    10,    11,    12,    13,    -1,
1226       -1,    16,    17,    18,    -1,    -1,    -1,    22,    23,    -1,
1227       25,    26,    27,    28,    29,    -1,    -1,    -1,    -1,    34,
1228       35,    36,    37,    38,    -1,    -1,    -1,    42,    43,    44,
1229       45,    46,    -1,    -1,    -1,    -1,    -1,     3,    53,    54,
1230       -1,    56,     8,    58,    10,    11,    12,    13,    -1,    -1,
1231       16,    17,    18,    -1,    -1,    -1,    -1,    23,    -1,    25,
1232       26,    27,    28,    29,    -1,    -1,    -1,    -1,    34,    35,
1233       36,    37,    38,    -1,    -1,    -1,    42,    43,    44,    45,
1234       46,    -1,    -1,    -1,    -1,    -1,     3,    53,    54,    -1,
1235       56,     8,    58,    10,    11,    12,    13,    -1,    -1,    16,
1236       17,    18,    -1,    -1,    -1,    -1,    -1,    -1,    25,    26,
1237       27,    28,    29,    -1,    -1,    -1,    -1,    34,    35,    36,
1238       37,    38,    -1,    -1,    -1,    42,    43,    44,    45,    46,
1239       -1,    -1,    -1,    50,    -1,     3,    53,    54,    -1,    56,
1240        8,    58,    10,    11,    12,    13,    -1,    -1,    16,    17,
1241       18,    -1,    -1,    -1,    -1,    -1,    -1,    25,    26,    27,
1242       28,    29,    -1,    -1,    -1,    -1,    34,    35,    36,    37,
1243       38,    -1,    -1,    -1,    42,    43,    44,    45,    46,    -1,
1244       -1,    -1,    -1,    -1,     3,    53,    54,    -1,    56,     8,
1245       58,    10,    11,    12,    13,    -1,    -1,    -1,    -1,    18,
1246       -1,    -1,    -1,    -1,    -1,    -1,    25,    26,    27,    28,
1247       29,    -1,    -1,    -1,    -1,    34,    35,    36,    37,    38,
1248       -1,    -1,    -1,    42,    43,    44,    45,    46,    -1,    -1,
1249       -1,    -1,    -1,    -1,    53,    54,    -1,    56,    -1,    58,
1250       27,    28,    -1,    -1,    -1,    -1,    -1,    34,    35,    36,
1251       37,    38,    -1,    -1,    -1,    42,    43,    44,    45,    46,
1252       34,    35,    36,    37,    38,    -1,    53,    54,    42,    -1,
1253       -1,    45,    46,    -1,    -1,    -1,    -1,    -1,    -1,    53,
1254       54
1255 };
1256
1257 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1258    symbol of state STATE-NUM.  */
1259 static const yytype_uint8 yystos[] =
1260 {
1261        0,     1,     3,     8,    10,    11,    12,    13,    16,    17,
1262       18,    22,    23,    25,    26,    27,    28,    29,    34,    35,
1263       36,    37,    38,    42,    43,    44,    45,    46,    50,    51,
1264       53,    54,    56,    58,    61,    63,    64,    66,    67,    68,
1265       69,    70,    71,    72,    73,    75,    76,    77,    78,    79,
1266       80,    93,    94,    95,    96,    97,    50,    86,    87,    92,
1267       25,    25,    30,    25,    87,    87,    25,    25,    66,    68,
1268       31,    96,    97,    24,    58,    34,    35,    36,    37,    38,
1269       42,    45,    46,    53,    54,    34,    35,    36,    37,    38,
1270       42,    45,    46,    53,    54,    25,    25,    25,    28,    55,
1271       25,    25,    28,    55,    25,    25,    25,    25,    25,    25,
1272       25,    87,    87,     0,    25,    64,    63,    65,    50,    51,
1273       90,    32,    33,    48,    49,    47,    52,    22,    49,    50,
1274       51,    91,    96,     4,    50,    88,    89,    95,    92,    49,
1275       92,    14,    56,    91,    49,    92,    14,    14,    58,    92,
1276       68,    65,    19,    96,    59,    25,    25,    25,    28,    55,
1277       25,    25,    28,    55,    25,    25,    25,    25,    25,    25,
1278       25,    25,    28,    55,    25,    25,    28,    55,    25,    25,
1279       25,    25,    25,    57,    59,    63,    92,    92,    94,    94,
1280       92,    92,    96,    87,    32,    33,    48,    49,    50,    21,
1281       92,    14,    21,    56,    87,    87,    92,    92,    14,    21,
1282       56,    87,    87,    59,    68,    74,    65,    92,    94,    94,
1283       48,    49,    96,    96,     5,     6,     7,    81,    92,    92,
1284       92,    92,    92,    82,    83,    84,    92,    14,    56,    87,
1285       25,    62,    91,    87,    15,    57,    14,    56,    14,    56,
1286       86,    92,    62,    86,    15,    15,    92,    65,    74,    87,
1287       87,     7,    89,    89,    89,    89,    89,     9,    39,    40,
1288       41,    83,    92,     9,    25,    58,    85,    87,    87,    15,
1289       25,    91,    92,    57,    87,    87,    86,    86,    15,    89,
1290       91,    57,    74,     7,     4,    48,    49,    50,    39,    40,
1291       41,     9,    85,    52,    59,    15,    57,    92,    14,    56,
1292       15,    57,    15,    57,    92,    87,    92,    92,    92,    59,
1293       25,    87,    92,    14,    56,    87,    87,    14,    56,     5,
1294       81,    87,    92,    87,    87,    15,    57,    86,    86,    87,
1295       15,    57,    15,    57
1296 };
1297
1298 #define yyerrok         (yyerrstatus = 0)
1299 #define yyclearin       (yychar = YYEMPTY)
1300 #define YYEMPTY         (-2)
1301 #define YYEOF           0
1302
1303 #define YYACCEPT        goto yyacceptlab
1304 #define YYABORT         goto yyabortlab
1305 #define YYERROR         goto yyerrorlab
1306
1307
1308 /* Like YYERROR except do call yyerror.  This remains here temporarily
1309    to ease the transition to the new meaning of YYERROR, for GCC.
1310    Once GCC version 2 has supplanted version 1, this can go.  */
1311
1312 #define YYFAIL          goto yyerrlab
1313
1314 #define YYRECOVERING()  (!!yyerrstatus)
1315
1316 #define YYBACKUP(Token, Value)                                  \
1317 do                                                              \
1318   if (yychar == YYEMPTY && yylen == 1)                          \
1319     {                                                           \
1320       yychar = (Token);                                         \
1321       yylval = (Value);                                         \
1322       yytoken = YYTRANSLATE (yychar);                           \
1323       YYPOPSTACK (1);                                           \
1324       goto yybackup;                                            \
1325     }                                                           \
1326   else                                                          \
1327     {                                                           \
1328       yyerror (YY_("syntax error: cannot back up")); \
1329       YYERROR;                                                  \
1330     }                                                           \
1331 while (YYID (0))
1332
1333
1334 #define YYTERROR        1
1335 #define YYERRCODE       256
1336
1337
1338 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1339    If N is 0, then set CURRENT to the empty location which ends
1340    the previous symbol: RHS[0] (always defined).  */
1341
1342 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1343 #ifndef YYLLOC_DEFAULT
1344 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
1345     do                                                                  \
1346       if (YYID (N))                                                    \
1347         {                                                               \
1348           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
1349           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
1350           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
1351           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
1352         }                                                               \
1353       else                                                              \
1354         {                                                               \
1355           (Current).first_line   = (Current).last_line   =              \
1356             YYRHSLOC (Rhs, 0).last_line;                                \
1357           (Current).first_column = (Current).last_column =              \
1358             YYRHSLOC (Rhs, 0).last_column;                              \
1359         }                                                               \
1360     while (YYID (0))
1361 #endif
1362
1363
1364 /* YY_LOCATION_PRINT -- Print the location on the stream.
1365    This macro was not mandated originally: define only if we know
1366    we won't break user code: when these are the locations we know.  */
1367
1368 #ifndef YY_LOCATION_PRINT
1369 # if YYLTYPE_IS_TRIVIAL
1370 #  define YY_LOCATION_PRINT(File, Loc)                  \
1371      fprintf (File, "%d.%d-%d.%d",                      \
1372               (Loc).first_line, (Loc).first_column,     \
1373               (Loc).last_line,  (Loc).last_column)
1374 # else
1375 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1376 # endif
1377 #endif
1378
1379
1380 /* YYLEX -- calling `yylex' with the right arguments.  */
1381
1382 #ifdef YYLEX_PARAM
1383 # define YYLEX yylex (YYLEX_PARAM)
1384 #else
1385 # define YYLEX yylex ()
1386 #endif
1387
1388 /* Enable debugging if requested.  */
1389 #if YYDEBUG
1390
1391 # ifndef YYFPRINTF
1392 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1393 #  define YYFPRINTF fprintf
1394 # endif
1395
1396 # define YYDPRINTF(Args)                        \
1397 do {                                            \
1398   if (yydebug)                                  \
1399     YYFPRINTF Args;                             \
1400 } while (YYID (0))
1401
1402 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
1403 do {                                                                      \
1404   if (yydebug)                                                            \
1405     {                                                                     \
1406       YYFPRINTF (stderr, "%s ", Title);                                   \
1407       yy_symbol_print (stderr,                                            \
1408                   Type, Value); \
1409       YYFPRINTF (stderr, "\n");                                           \
1410     }                                                                     \
1411 } while (YYID (0))
1412
1413
1414 /*--------------------------------.
1415 | Print this symbol on YYOUTPUT.  |
1416 `--------------------------------*/
1417
1418 /*ARGSUSED*/
1419 #if (defined __STDC__ || defined __C99__FUNC__ \
1420      || defined __cplusplus || defined _MSC_VER)
1421 static void
1422 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1423 #else
1424 static void
1425 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1426     FILE *yyoutput;
1427     int yytype;
1428     YYSTYPE const * const yyvaluep;
1429 #endif
1430 {
1431   if (!yyvaluep)
1432     return;
1433 # ifdef YYPRINT
1434   if (yytype < YYNTOKENS)
1435     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1436 # else
1437   YYUSE (yyoutput);
1438 # endif
1439   switch (yytype)
1440     {
1441       default:
1442         break;
1443     }
1444 }
1445
1446
1447 /*--------------------------------.
1448 | Print this symbol on YYOUTPUT.  |
1449 `--------------------------------*/
1450
1451 #if (defined __STDC__ || defined __C99__FUNC__ \
1452      || defined __cplusplus || defined _MSC_VER)
1453 static void
1454 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1455 #else
1456 static void
1457 yy_symbol_print (yyoutput, yytype, yyvaluep)
1458     FILE *yyoutput;
1459     int yytype;
1460     YYSTYPE const * const yyvaluep;
1461 #endif
1462 {
1463   if (yytype < YYNTOKENS)
1464     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1465   else
1466     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1467
1468   yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1469   YYFPRINTF (yyoutput, ")");
1470 }
1471
1472 /*------------------------------------------------------------------.
1473 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1474 | TOP (included).                                                   |
1475 `------------------------------------------------------------------*/
1476
1477 #if (defined __STDC__ || defined __C99__FUNC__ \
1478      || defined __cplusplus || defined _MSC_VER)
1479 static void
1480 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1481 #else
1482 static void
1483 yy_stack_print (bottom, top)
1484     yytype_int16 *bottom;
1485     yytype_int16 *top;
1486 #endif
1487 {
1488   YYFPRINTF (stderr, "Stack now");
1489   for (; bottom <= top; ++bottom)
1490     YYFPRINTF (stderr, " %d", *bottom);
1491   YYFPRINTF (stderr, "\n");
1492 }
1493
1494 # define YY_STACK_PRINT(Bottom, Top)                            \
1495 do {                                                            \
1496   if (yydebug)                                                  \
1497     yy_stack_print ((Bottom), (Top));                           \
1498 } while (YYID (0))
1499
1500
1501 /*------------------------------------------------.
1502 | Report that the YYRULE is going to be reduced.  |
1503 `------------------------------------------------*/
1504
1505 #if (defined __STDC__ || defined __C99__FUNC__ \
1506      || defined __cplusplus || defined _MSC_VER)
1507 static void
1508 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1509 #else
1510 static void
1511 yy_reduce_print (yyvsp, yyrule)
1512     YYSTYPE *yyvsp;
1513     int yyrule;
1514 #endif
1515 {
1516   int yynrhs = yyr2[yyrule];
1517   int yyi;
1518   unsigned long int yylno = yyrline[yyrule];
1519   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1520              yyrule - 1, yylno);
1521   /* The symbols being reduced.  */
1522   for (yyi = 0; yyi < yynrhs; yyi++)
1523     {
1524       fprintf (stderr, "   $%d = ", yyi + 1);
1525       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1526                        &(yyvsp[(yyi + 1) - (yynrhs)])
1527                                        );
1528       fprintf (stderr, "\n");
1529     }
1530 }
1531
1532 # define YY_REDUCE_PRINT(Rule)          \
1533 do {                                    \
1534   if (yydebug)                          \
1535     yy_reduce_print (yyvsp, Rule); \
1536 } while (YYID (0))
1537
1538 /* Nonzero means print parse trace.  It is left uninitialized so that
1539    multiple parsers can coexist.  */
1540 int yydebug;
1541 #else /* !YYDEBUG */
1542 # define YYDPRINTF(Args)
1543 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1544 # define YY_STACK_PRINT(Bottom, Top)
1545 # define YY_REDUCE_PRINT(Rule)
1546 #endif /* !YYDEBUG */
1547
1548
1549 /* YYINITDEPTH -- initial size of the parser's stacks.  */
1550 #ifndef YYINITDEPTH
1551 # define YYINITDEPTH 200
1552 #endif
1553
1554 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1555    if the built-in stack extension method is used).
1556
1557    Do not make this value too large; the results are undefined if
1558    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1559    evaluated with infinite-precision integer arithmetic.  */
1560
1561 #ifndef YYMAXDEPTH
1562 # define YYMAXDEPTH 10000
1563 #endif
1564
1565 \f
1566
1567 #if YYERROR_VERBOSE
1568
1569 # ifndef yystrlen
1570 #  if defined __GLIBC__ && defined _STRING_H
1571 #   define yystrlen strlen
1572 #  else
1573 /* Return the length of YYSTR.  */
1574 #if (defined __STDC__ || defined __C99__FUNC__ \
1575      || defined __cplusplus || defined _MSC_VER)
1576 static YYSIZE_T
1577 yystrlen (const char *yystr)
1578 #else
1579 static YYSIZE_T
1580 yystrlen (yystr)
1581     const char *yystr;
1582 #endif
1583 {
1584   YYSIZE_T yylen;
1585   for (yylen = 0; yystr[yylen]; yylen++)
1586     continue;
1587   return yylen;
1588 }
1589 #  endif
1590 # endif
1591
1592 # ifndef yystpcpy
1593 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1594 #   define yystpcpy stpcpy
1595 #  else
1596 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1597    YYDEST.  */
1598 #if (defined __STDC__ || defined __C99__FUNC__ \
1599      || defined __cplusplus || defined _MSC_VER)
1600 static char *
1601 yystpcpy (char *yydest, const char *yysrc)
1602 #else
1603 static char *
1604 yystpcpy (yydest, yysrc)
1605     char *yydest;
1606     const char *yysrc;
1607 #endif
1608 {
1609   char *yyd = yydest;
1610   const char *yys = yysrc;
1611
1612   while ((*yyd++ = *yys++) != '\0')
1613     continue;
1614
1615   return yyd - 1;
1616 }
1617 #  endif
1618 # endif
1619
1620 # ifndef yytnamerr
1621 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1622    quotes and backslashes, so that it's suitable for yyerror.  The
1623    heuristic is that double-quoting is unnecessary unless the string
1624    contains an apostrophe, a comma, or backslash (other than
1625    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
1626    null, do not copy; instead, return the length of what the result
1627    would have been.  */
1628 static YYSIZE_T
1629 yytnamerr (char *yyres, const char *yystr)
1630 {
1631   if (*yystr == '"')
1632     {
1633       YYSIZE_T yyn = 0;
1634       char const *yyp = yystr;
1635
1636       for (;;)
1637         switch (*++yyp)
1638           {
1639           case '\'':
1640           case ',':
1641             goto do_not_strip_quotes;
1642
1643           case '\\':
1644             if (*++yyp != '\\')
1645               goto do_not_strip_quotes;
1646             /* Fall through.  */
1647           default:
1648             if (yyres)
1649               yyres[yyn] = *yyp;
1650             yyn++;
1651             break;
1652
1653           case '"':
1654             if (yyres)
1655               yyres[yyn] = '\0';
1656             return yyn;
1657           }
1658     do_not_strip_quotes: ;
1659     }
1660
1661   if (! yyres)
1662     return yystrlen (yystr);
1663
1664   return yystpcpy (yyres, yystr) - yyres;
1665 }
1666 # endif
1667
1668 /* Copy into YYRESULT an error message about the unexpected token
1669    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
1670    including the terminating null byte.  If YYRESULT is null, do not
1671    copy anything; just return the number of bytes that would be
1672    copied.  As a special case, return 0 if an ordinary "syntax error"
1673    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
1674    size calculation.  */
1675 static YYSIZE_T
1676 yysyntax_error (char *yyresult, int yystate, int yychar)
1677 {
1678   int yyn = yypact[yystate];
1679
1680   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
1681     return 0;
1682   else
1683     {
1684       int yytype = YYTRANSLATE (yychar);
1685       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
1686       YYSIZE_T yysize = yysize0;
1687       YYSIZE_T yysize1;
1688       int yysize_overflow = 0;
1689       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1690       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1691       int yyx;
1692
1693 # if 0
1694       /* This is so xgettext sees the translatable formats that are
1695          constructed on the fly.  */
1696       YY_("syntax error, unexpected %s");
1697       YY_("syntax error, unexpected %s, expecting %s");
1698       YY_("syntax error, unexpected %s, expecting %s or %s");
1699       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
1700       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
1701 # endif
1702       char *yyfmt;
1703       char const *yyf;
1704       static char const yyunexpected[] = "syntax error, unexpected %s";
1705       static char const yyexpecting[] = ", expecting %s";
1706       static char const yyor[] = " or %s";
1707       char yyformat[sizeof yyunexpected
1708                     + sizeof yyexpecting - 1
1709                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1710                        * (sizeof yyor - 1))];
1711       char const *yyprefix = yyexpecting;
1712
1713       /* Start YYX at -YYN if negative to avoid negative indexes in
1714          YYCHECK.  */
1715       int yyxbegin = yyn < 0 ? -yyn : 0;
1716
1717       /* Stay within bounds of both yycheck and yytname.  */
1718       int yychecklim = YYLAST - yyn + 1;
1719       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1720       int yycount = 1;
1721
1722       yyarg[0] = yytname[yytype];
1723       yyfmt = yystpcpy (yyformat, yyunexpected);
1724
1725       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1726         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1727           {
1728             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1729               {
1730                 yycount = 1;
1731                 yysize = yysize0;
1732                 yyformat[sizeof yyunexpected - 1] = '\0';
1733                 break;
1734               }
1735             yyarg[yycount++] = yytname[yyx];
1736             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1737             yysize_overflow |= (yysize1 < yysize);
1738             yysize = yysize1;
1739             yyfmt = yystpcpy (yyfmt, yyprefix);
1740             yyprefix = yyor;
1741           }
1742
1743       yyf = YY_(yyformat);
1744       yysize1 = yysize + yystrlen (yyf);
1745       yysize_overflow |= (yysize1 < yysize);
1746       yysize = yysize1;
1747
1748       if (yysize_overflow)
1749         return YYSIZE_MAXIMUM;
1750
1751       if (yyresult)
1752         {
1753           /* Avoid sprintf, as that infringes on the user's name space.
1754              Don't have undefined behavior even if the translation
1755              produced a string with the wrong number of "%s"s.  */
1756           char *yyp = yyresult;
1757           int yyi = 0;
1758           while ((*yyp = *yyf) != '\0')
1759             {
1760               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1761                 {
1762                   yyp += yytnamerr (yyp, yyarg[yyi++]);
1763                   yyf += 2;
1764                 }
1765               else
1766                 {
1767                   yyp++;
1768                   yyf++;
1769                 }
1770             }
1771         }
1772       return yysize;
1773     }
1774 }
1775 #endif /* YYERROR_VERBOSE */
1776 \f
1777
1778 /*-----------------------------------------------.
1779 | Release the memory associated to this symbol.  |
1780 `-----------------------------------------------*/
1781
1782 /*ARGSUSED*/
1783 #if (defined __STDC__ || defined __C99__FUNC__ \
1784      || defined __cplusplus || defined _MSC_VER)
1785 static void
1786 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1787 #else
1788 static void
1789 yydestruct (yymsg, yytype, yyvaluep)
1790     const char *yymsg;
1791     int yytype;
1792     YYSTYPE *yyvaluep;
1793 #endif
1794 {
1795   YYUSE (yyvaluep);
1796
1797   if (!yymsg)
1798     yymsg = "Deleting";
1799   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1800
1801   switch (yytype)
1802     {
1803
1804       default:
1805         break;
1806     }
1807 }
1808 \f
1809
1810 /* Prevent warnings from -Wmissing-prototypes.  */
1811
1812 #ifdef YYPARSE_PARAM
1813 #if defined __STDC__ || defined __cplusplus
1814 int yyparse (void *YYPARSE_PARAM);
1815 #else
1816 int yyparse ();
1817 #endif
1818 #else /* ! YYPARSE_PARAM */
1819 #if defined __STDC__ || defined __cplusplus
1820 int yyparse (void);
1821 #else
1822 int yyparse ();
1823 #endif
1824 #endif /* ! YYPARSE_PARAM */
1825
1826
1827
1828 /* The look-ahead symbol.  */
1829 int yychar;
1830
1831 /* The semantic value of the look-ahead symbol.  */
1832 YYSTYPE yylval;
1833
1834 /* Number of syntax errors so far.  */
1835 int yynerrs;
1836
1837
1838
1839 /*----------.
1840 | yyparse.  |
1841 `----------*/
1842
1843 #ifdef YYPARSE_PARAM
1844 #if (defined __STDC__ || defined __C99__FUNC__ \
1845      || defined __cplusplus || defined _MSC_VER)
1846 int
1847 yyparse (void *YYPARSE_PARAM)
1848 #else
1849 int
1850 yyparse (YYPARSE_PARAM)
1851     void *YYPARSE_PARAM;
1852 #endif
1853 #else /* ! YYPARSE_PARAM */
1854 #if (defined __STDC__ || defined __C99__FUNC__ \
1855      || defined __cplusplus || defined _MSC_VER)
1856 int
1857 yyparse (void)
1858 #else
1859 int
1860 yyparse ()
1861
1862 #endif
1863 #endif
1864 {
1865
1866   int yystate;
1867   int yyn;
1868   int yyresult;
1869   /* Number of tokens to shift before error messages enabled.  */
1870   int yyerrstatus;
1871   /* Look-ahead token as an internal (translated) token number.  */
1872   int yytoken = 0;
1873 #if YYERROR_VERBOSE
1874   /* Buffer for error messages, and its allocated size.  */
1875   char yymsgbuf[128];
1876   char *yymsg = yymsgbuf;
1877   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1878 #endif
1879
1880   /* Three stacks and their tools:
1881      `yyss': related to states,
1882      `yyvs': related to semantic values,
1883      `yyls': related to locations.
1884
1885      Refer to the stacks thru separate pointers, to allow yyoverflow
1886      to reallocate them elsewhere.  */
1887
1888   /* The state stack.  */
1889   yytype_int16 yyssa[YYINITDEPTH];
1890   yytype_int16 *yyss = yyssa;
1891   yytype_int16 *yyssp;
1892
1893   /* The semantic value stack.  */
1894   YYSTYPE yyvsa[YYINITDEPTH];
1895   YYSTYPE *yyvs = yyvsa;
1896   YYSTYPE *yyvsp;
1897
1898
1899
1900 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1901
1902   YYSIZE_T yystacksize = YYINITDEPTH;
1903
1904   /* The variables used to return semantic value and location from the
1905      action routines.  */
1906   YYSTYPE yyval;
1907
1908
1909   /* The number of symbols on the RHS of the reduced rule.
1910      Keep to zero when no symbol should be popped.  */
1911   int yylen = 0;
1912
1913   YYDPRINTF ((stderr, "Starting parse\n"));
1914
1915   yystate = 0;
1916   yyerrstatus = 0;
1917   yynerrs = 0;
1918   yychar = YYEMPTY;             /* Cause a token to be read.  */
1919
1920   /* Initialize stack pointers.
1921      Waste one element of value and location stack
1922      so that they stay on the same level as the state stack.
1923      The wasted elements are never initialized.  */
1924
1925   yyssp = yyss;
1926   yyvsp = yyvs;
1927
1928   goto yysetstate;
1929
1930 /*------------------------------------------------------------.
1931 | yynewstate -- Push a new state, which is found in yystate.  |
1932 `------------------------------------------------------------*/
1933  yynewstate:
1934   /* In all cases, when you get here, the value and location stacks
1935      have just been pushed.  So pushing a state here evens the stacks.  */
1936   yyssp++;
1937
1938  yysetstate:
1939   *yyssp = yystate;
1940
1941   if (yyss + yystacksize - 1 <= yyssp)
1942     {
1943       /* Get the current used size of the three stacks, in elements.  */
1944       YYSIZE_T yysize = yyssp - yyss + 1;
1945
1946 #ifdef yyoverflow
1947       {
1948         /* Give user a chance to reallocate the stack.  Use copies of
1949            these so that the &'s don't force the real ones into
1950            memory.  */
1951         YYSTYPE *yyvs1 = yyvs;
1952         yytype_int16 *yyss1 = yyss;
1953
1954
1955         /* Each stack pointer address is followed by the size of the
1956            data in use in that stack, in bytes.  This used to be a
1957            conditional around just the two extra args, but that might
1958            be undefined if yyoverflow is a macro.  */
1959         yyoverflow (YY_("memory exhausted"),
1960                     &yyss1, yysize * sizeof (*yyssp),
1961                     &yyvs1, yysize * sizeof (*yyvsp),
1962
1963                     &yystacksize);
1964
1965         yyss = yyss1;
1966         yyvs = yyvs1;
1967       }
1968 #else /* no yyoverflow */
1969 # ifndef YYSTACK_RELOCATE
1970       goto yyexhaustedlab;
1971 # else
1972       /* Extend the stack our own way.  */
1973       if (YYMAXDEPTH <= yystacksize)
1974         goto yyexhaustedlab;
1975       yystacksize *= 2;
1976       if (YYMAXDEPTH < yystacksize)
1977         yystacksize = YYMAXDEPTH;
1978
1979       {
1980         yytype_int16 *yyss1 = yyss;
1981         union yyalloc *yyptr =
1982           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1983         if (! yyptr)
1984           goto yyexhaustedlab;
1985         YYSTACK_RELOCATE (yyss);
1986         YYSTACK_RELOCATE (yyvs);
1987
1988 #  undef YYSTACK_RELOCATE
1989         if (yyss1 != yyssa)
1990           YYSTACK_FREE (yyss1);
1991       }
1992 # endif
1993 #endif /* no yyoverflow */
1994
1995       yyssp = yyss + yysize - 1;
1996       yyvsp = yyvs + yysize - 1;
1997
1998
1999       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2000                   (unsigned long int) yystacksize));
2001
2002       if (yyss + yystacksize - 1 <= yyssp)
2003         YYABORT;
2004     }
2005
2006   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2007
2008   goto yybackup;
2009
2010 /*-----------.
2011 | yybackup.  |
2012 `-----------*/
2013 yybackup:
2014
2015   /* Do appropriate processing given the current state.  Read a
2016      look-ahead token if we need one and don't already have one.  */
2017
2018   /* First try to decide what to do without reference to look-ahead token.  */
2019   yyn = yypact[yystate];
2020   if (yyn == YYPACT_NINF)
2021     goto yydefault;
2022
2023   /* Not known => get a look-ahead token if don't already have one.  */
2024
2025   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
2026   if (yychar == YYEMPTY)
2027     {
2028       YYDPRINTF ((stderr, "Reading a token: "));
2029       yychar = YYLEX;
2030     }
2031
2032   if (yychar <= YYEOF)
2033     {
2034       yychar = yytoken = YYEOF;
2035       YYDPRINTF ((stderr, "Now at end of input.\n"));
2036     }
2037   else
2038     {
2039       yytoken = YYTRANSLATE (yychar);
2040       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2041     }
2042
2043   /* If the proper action on seeing token YYTOKEN is to reduce or to
2044      detect an error, take that action.  */
2045   yyn += yytoken;
2046   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2047     goto yydefault;
2048   yyn = yytable[yyn];
2049   if (yyn <= 0)
2050     {
2051       if (yyn == 0 || yyn == YYTABLE_NINF)
2052         goto yyerrlab;
2053       yyn = -yyn;
2054       goto yyreduce;
2055     }
2056
2057   if (yyn == YYFINAL)
2058     YYACCEPT;
2059
2060   /* Count tokens shifted since error; after three, turn off error
2061      status.  */
2062   if (yyerrstatus)
2063     yyerrstatus--;
2064
2065   /* Shift the look-ahead token.  */
2066   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2067
2068   /* Discard the shifted token unless it is eof.  */
2069   if (yychar != YYEOF)
2070     yychar = YYEMPTY;
2071
2072   yystate = yyn;
2073   *++yyvsp = yylval;
2074
2075   goto yynewstate;
2076
2077
2078 /*-----------------------------------------------------------.
2079 | yydefault -- do the default action for the current state.  |
2080 `-----------------------------------------------------------*/
2081 yydefault:
2082   yyn = yydefact[yystate];
2083   if (yyn == 0)
2084     goto yyerrlab;
2085   goto yyreduce;
2086
2087
2088 /*-----------------------------.
2089 | yyreduce -- Do a reduction.  |
2090 `-----------------------------*/
2091 yyreduce:
2092   /* yyn is the number of a rule to reduce with.  */
2093   yylen = yyr2[yyn];
2094
2095   /* If YYLEN is nonzero, implement the default value of the action:
2096      `$$ = $1'.
2097
2098      Otherwise, the following line sets YYVAL to garbage.
2099      This behavior is undocumented and Bison
2100      users should not rely upon it.  Assigning to YYVAL
2101      unconditionally makes the parser a bit smaller, and it avoids a
2102      GCC warning that YYVAL may be used uninitialized.  */
2103   yyval = yyvsp[1-yylen];
2104
2105
2106   YY_REDUCE_PRINT (yyn);
2107   switch (yyn)
2108     {
2109         case 2:
2110 #line 374 "/Users/chet/src/bash/src/parse.y"
2111     {
2112                           /* Case of regular command.  Discard the error
2113                              safety net,and return the command just parsed. */
2114                           global_command = (yyvsp[(1) - (2)].command);
2115                           eof_encountered = 0;
2116                           /* discard_parser_constructs (0); */
2117                           if (parser_state & PST_CMDSUBST)
2118                             parser_state |= PST_EOFTOKEN;
2119                           YYACCEPT;
2120                         }
2121     break;
2122
2123   case 3:
2124 #line 385 "/Users/chet/src/bash/src/parse.y"
2125     {
2126                           /* Case of regular command, but not a very
2127                              interesting one.  Return a NULL command. */
2128                           global_command = (COMMAND *)NULL;
2129                           if (parser_state & PST_CMDSUBST)
2130                             parser_state |= PST_EOFTOKEN;
2131                           YYACCEPT;
2132                         }
2133     break;
2134
2135   case 4:
2136 #line 394 "/Users/chet/src/bash/src/parse.y"
2137     {
2138                           /* Error during parsing.  Return NULL command. */
2139                           global_command = (COMMAND *)NULL;
2140                           eof_encountered = 0;
2141                           /* discard_parser_constructs (1); */
2142                           if (interactive && parse_and_execute_level == 0)
2143                             {
2144                               YYACCEPT;
2145                             }
2146                           else
2147                             {
2148                               YYABORT;
2149                             }
2150                         }
2151     break;
2152
2153   case 5:
2154 #line 409 "/Users/chet/src/bash/src/parse.y"
2155     {
2156                           /* Case of EOF seen by itself.  Do ignoreeof or
2157                              not. */
2158                           global_command = (COMMAND *)NULL;
2159                           handle_eof_input_unit ();
2160                           YYACCEPT;
2161                         }
2162     break;
2163
2164   case 6:
2165 #line 419 "/Users/chet/src/bash/src/parse.y"
2166     { (yyval.word_list) = make_word_list ((yyvsp[(1) - (1)].word), (WORD_LIST *)NULL); }
2167     break;
2168
2169   case 7:
2170 #line 421 "/Users/chet/src/bash/src/parse.y"
2171     { (yyval.word_list) = make_word_list ((yyvsp[(2) - (2)].word), (yyvsp[(1) - (2)].word_list)); }
2172     break;
2173
2174   case 8:
2175 #line 425 "/Users/chet/src/bash/src/parse.y"
2176     {
2177                           source.dest = 1;
2178                           redir.filename = (yyvsp[(2) - (2)].word);
2179                           (yyval.redirect) = make_redirection (source, r_output_direction, redir, 0);
2180                         }
2181     break;
2182
2183   case 9:
2184 #line 431 "/Users/chet/src/bash/src/parse.y"
2185     {
2186                           source.dest = 0;
2187                           redir.filename = (yyvsp[(2) - (2)].word);
2188                           (yyval.redirect) = make_redirection (source, r_input_direction, redir, 0);
2189                         }
2190     break;
2191
2192   case 10:
2193 #line 437 "/Users/chet/src/bash/src/parse.y"
2194     {
2195                           source.dest = (yyvsp[(1) - (3)].number);
2196                           redir.filename = (yyvsp[(3) - (3)].word);
2197                           (yyval.redirect) = make_redirection (source, r_output_direction, redir, 0);
2198                         }
2199     break;
2200
2201   case 11:
2202 #line 443 "/Users/chet/src/bash/src/parse.y"
2203     {
2204                           source.dest = (yyvsp[(1) - (3)].number);
2205                           redir.filename = (yyvsp[(3) - (3)].word);
2206                           (yyval.redirect) = make_redirection (source, r_input_direction, redir, 0);
2207                         }
2208     break;
2209
2210   case 12:
2211 #line 449 "/Users/chet/src/bash/src/parse.y"
2212     {
2213                           source.filename = (yyvsp[(1) - (3)].word);
2214                           redir.filename = (yyvsp[(3) - (3)].word);
2215                           (yyval.redirect) = make_redirection (source, r_output_direction, redir, REDIR_VARASSIGN);
2216                         }
2217     break;
2218
2219   case 13:
2220 #line 455 "/Users/chet/src/bash/src/parse.y"
2221     {
2222                           source.filename = (yyvsp[(1) - (3)].word);
2223                           redir.filename = (yyvsp[(3) - (3)].word);
2224                           (yyval.redirect) = make_redirection (source, r_input_direction, redir, REDIR_VARASSIGN);
2225                         }
2226     break;
2227
2228   case 14:
2229 #line 461 "/Users/chet/src/bash/src/parse.y"
2230     {
2231                           source.dest = 1;
2232                           redir.filename = (yyvsp[(2) - (2)].word);
2233                           (yyval.redirect) = make_redirection (source, r_appending_to, redir, 0);
2234                         }
2235     break;
2236
2237   case 15:
2238 #line 467 "/Users/chet/src/bash/src/parse.y"
2239     {
2240                           source.dest = (yyvsp[(1) - (3)].number);
2241                           redir.filename = (yyvsp[(3) - (3)].word);
2242                           (yyval.redirect) = make_redirection (source, r_appending_to, redir, 0);
2243                         }
2244     break;
2245
2246   case 16:
2247 #line 473 "/Users/chet/src/bash/src/parse.y"
2248     {
2249                           source.filename = (yyvsp[(1) - (3)].word);
2250                           redir.filename = (yyvsp[(3) - (3)].word);
2251                           (yyval.redirect) = make_redirection (source, r_appending_to, redir, REDIR_VARASSIGN);
2252                         }
2253     break;
2254
2255   case 17:
2256 #line 479 "/Users/chet/src/bash/src/parse.y"
2257     {
2258                           source.dest = 1;
2259                           redir.filename = (yyvsp[(2) - (2)].word);
2260                           (yyval.redirect) = make_redirection (source, r_output_force, redir, 0);
2261                         }
2262     break;
2263
2264   case 18:
2265 #line 485 "/Users/chet/src/bash/src/parse.y"
2266     {
2267                           source.dest = (yyvsp[(1) - (3)].number);
2268                           redir.filename = (yyvsp[(3) - (3)].word);
2269                           (yyval.redirect) = make_redirection (source, r_output_force, redir, 0);
2270                         }
2271     break;
2272
2273   case 19:
2274 #line 491 "/Users/chet/src/bash/src/parse.y"
2275     {
2276                           source.filename = (yyvsp[(1) - (3)].word);
2277                           redir.filename = (yyvsp[(3) - (3)].word);
2278                           (yyval.redirect) = make_redirection (source, r_output_force, redir, REDIR_VARASSIGN);
2279                         }
2280     break;
2281
2282   case 20:
2283 #line 497 "/Users/chet/src/bash/src/parse.y"
2284     {
2285                           source.dest = 0;
2286                           redir.filename = (yyvsp[(2) - (2)].word);
2287                           (yyval.redirect) = make_redirection (source, r_input_output, redir, 0);
2288                         }
2289     break;
2290
2291   case 21:
2292 #line 503 "/Users/chet/src/bash/src/parse.y"
2293     {
2294                           source.dest = (yyvsp[(1) - (3)].number);
2295                           redir.filename = (yyvsp[(3) - (3)].word);
2296                           (yyval.redirect) = make_redirection (source, r_input_output, redir, 0);
2297                         }
2298     break;
2299
2300   case 22:
2301 #line 509 "/Users/chet/src/bash/src/parse.y"
2302     {
2303                           source.filename = (yyvsp[(1) - (3)].word);
2304                           redir.filename = (yyvsp[(3) - (3)].word);
2305                           (yyval.redirect) = make_redirection (source, r_input_output, redir, REDIR_VARASSIGN);
2306                         }
2307     break;
2308
2309   case 23:
2310 #line 515 "/Users/chet/src/bash/src/parse.y"
2311     {
2312                           source.dest = 0;
2313                           redir.filename = (yyvsp[(2) - (2)].word);
2314                           (yyval.redirect) = make_redirection (source, r_reading_until, redir, 0);
2315                           redir_stack[need_here_doc++] = (yyval.redirect);
2316                         }
2317     break;
2318
2319   case 24:
2320 #line 522 "/Users/chet/src/bash/src/parse.y"
2321     {
2322                           source.dest = (yyvsp[(1) - (3)].number);
2323                           redir.filename = (yyvsp[(3) - (3)].word);
2324                           (yyval.redirect) = make_redirection (source, r_reading_until, redir, 0);
2325                           redir_stack[need_here_doc++] = (yyval.redirect);
2326                         }
2327     break;
2328
2329   case 25:
2330 #line 529 "/Users/chet/src/bash/src/parse.y"
2331     {
2332                           source.filename = (yyvsp[(1) - (3)].word);
2333                           redir.filename = (yyvsp[(3) - (3)].word);
2334                           (yyval.redirect) = make_redirection (source, r_reading_until, redir, REDIR_VARASSIGN);
2335                           redir_stack[need_here_doc++] = (yyval.redirect);
2336                         }
2337     break;
2338
2339   case 26:
2340 #line 536 "/Users/chet/src/bash/src/parse.y"
2341     {
2342                           source.dest = 0;
2343                           redir.filename = (yyvsp[(2) - (2)].word);
2344                           (yyval.redirect) = make_redirection (source, r_deblank_reading_until, redir, 0);
2345                           redir_stack[need_here_doc++] = (yyval.redirect);
2346                         }
2347     break;
2348
2349   case 27:
2350 #line 543 "/Users/chet/src/bash/src/parse.y"
2351     {
2352                           source.dest = (yyvsp[(1) - (3)].number);
2353                           redir.filename = (yyvsp[(3) - (3)].word);
2354                           (yyval.redirect) = make_redirection (source, r_deblank_reading_until, redir, 0);
2355                           redir_stack[need_here_doc++] = (yyval.redirect);
2356                         }
2357     break;
2358
2359   case 28:
2360 #line 550 "/Users/chet/src/bash/src/parse.y"
2361     {
2362                           source.filename = (yyvsp[(1) - (3)].word);
2363                           redir.filename = (yyvsp[(3) - (3)].word);
2364                           (yyval.redirect) = make_redirection (source, r_deblank_reading_until, redir, REDIR_VARASSIGN);
2365                           redir_stack[need_here_doc++] = (yyval.redirect);
2366                         }
2367     break;
2368
2369   case 29:
2370 #line 557 "/Users/chet/src/bash/src/parse.y"
2371     {
2372                           source.dest = 0;
2373                           redir.filename = (yyvsp[(2) - (2)].word);
2374                           (yyval.redirect) = make_redirection (source, r_reading_string, redir, 0);
2375                         }
2376     break;
2377
2378   case 30:
2379 #line 563 "/Users/chet/src/bash/src/parse.y"
2380     {
2381                           source.dest = (yyvsp[(1) - (3)].number);
2382                           redir.filename = (yyvsp[(3) - (3)].word);
2383                           (yyval.redirect) = make_redirection (source, r_reading_string, redir, 0);
2384                         }
2385     break;
2386
2387   case 31:
2388 #line 569 "/Users/chet/src/bash/src/parse.y"
2389     {
2390                           source.filename = (yyvsp[(1) - (3)].word);
2391                           redir.filename = (yyvsp[(3) - (3)].word);
2392                           (yyval.redirect) = make_redirection (source, r_reading_string, redir, REDIR_VARASSIGN);
2393                         }
2394     break;
2395
2396   case 32:
2397 #line 575 "/Users/chet/src/bash/src/parse.y"
2398     {
2399                           source.dest = 0;
2400                           redir.dest = (yyvsp[(2) - (2)].number);
2401                           (yyval.redirect) = make_redirection (source, r_duplicating_input, redir, 0);
2402                         }
2403     break;
2404
2405   case 33:
2406 #line 581 "/Users/chet/src/bash/src/parse.y"
2407     {
2408                           source.dest = (yyvsp[(1) - (3)].number);
2409                           redir.dest = (yyvsp[(3) - (3)].number);
2410                           (yyval.redirect) = make_redirection (source, r_duplicating_input, redir, 0);
2411                         }
2412     break;
2413
2414   case 34:
2415 #line 587 "/Users/chet/src/bash/src/parse.y"
2416     {
2417                           source.filename = (yyvsp[(1) - (3)].word);
2418                           redir.dest = (yyvsp[(3) - (3)].number);
2419                           (yyval.redirect) = make_redirection (source, r_duplicating_input, redir, REDIR_VARASSIGN);
2420                         }
2421     break;
2422
2423   case 35:
2424 #line 593 "/Users/chet/src/bash/src/parse.y"
2425     {
2426                           source.dest = 1;
2427                           redir.dest = (yyvsp[(2) - (2)].number);
2428                           (yyval.redirect) = make_redirection (source, r_duplicating_output, redir, 0);
2429                         }
2430     break;
2431
2432   case 36:
2433 #line 599 "/Users/chet/src/bash/src/parse.y"
2434     {
2435                           source.dest = (yyvsp[(1) - (3)].number);
2436                           redir.dest = (yyvsp[(3) - (3)].number);
2437                           (yyval.redirect) = make_redirection (source, r_duplicating_output, redir, 0);
2438                         }
2439     break;
2440
2441   case 37:
2442 #line 605 "/Users/chet/src/bash/src/parse.y"
2443     {
2444                           source.filename = (yyvsp[(1) - (3)].word);
2445                           redir.dest = (yyvsp[(3) - (3)].number);
2446                           (yyval.redirect) = make_redirection (source, r_duplicating_output, redir, REDIR_VARASSIGN);
2447                         }
2448     break;
2449
2450   case 38:
2451 #line 611 "/Users/chet/src/bash/src/parse.y"
2452     {
2453                           source.dest = 0;
2454                           redir.filename = (yyvsp[(2) - (2)].word);
2455                           (yyval.redirect) = make_redirection (source, r_duplicating_input_word, redir, 0);
2456                         }
2457     break;
2458
2459   case 39:
2460 #line 617 "/Users/chet/src/bash/src/parse.y"
2461     {
2462                           source.dest = (yyvsp[(1) - (3)].number);
2463                           redir.filename = (yyvsp[(3) - (3)].word);
2464                           (yyval.redirect) = make_redirection (source, r_duplicating_input_word, redir, 0);
2465                         }
2466     break;
2467
2468   case 40:
2469 #line 623 "/Users/chet/src/bash/src/parse.y"
2470     {
2471                           source.filename = (yyvsp[(1) - (3)].word);
2472                           redir.filename = (yyvsp[(3) - (3)].word);
2473                           (yyval.redirect) = make_redirection (source, r_duplicating_input_word, redir, REDIR_VARASSIGN);
2474                         }
2475     break;
2476
2477   case 41:
2478 #line 629 "/Users/chet/src/bash/src/parse.y"
2479     {
2480                           source.dest = 1;
2481                           redir.filename = (yyvsp[(2) - (2)].word);
2482                           (yyval.redirect) = make_redirection (source, r_duplicating_output_word, redir, 0);
2483                         }
2484     break;
2485
2486   case 42:
2487 #line 635 "/Users/chet/src/bash/src/parse.y"
2488     {
2489                           source.dest = (yyvsp[(1) - (3)].number);
2490                           redir.filename = (yyvsp[(3) - (3)].word);
2491                           (yyval.redirect) = make_redirection (source, r_duplicating_output_word, redir, 0);
2492                         }
2493     break;
2494
2495   case 43:
2496 #line 641 "/Users/chet/src/bash/src/parse.y"
2497     {
2498                           source.filename = (yyvsp[(1) - (3)].word);
2499                           redir.filename = (yyvsp[(3) - (3)].word);
2500                           (yyval.redirect) = make_redirection (source, r_duplicating_output_word, redir, REDIR_VARASSIGN);
2501                         }
2502     break;
2503
2504   case 44:
2505 #line 647 "/Users/chet/src/bash/src/parse.y"
2506     {
2507                           source.dest = 1;
2508                           redir.dest = 0;
2509                           (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
2510                         }
2511     break;
2512
2513   case 45:
2514 #line 653 "/Users/chet/src/bash/src/parse.y"
2515     {
2516                           source.dest = (yyvsp[(1) - (3)].number);
2517                           redir.dest = 0;
2518                           (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
2519                         }
2520     break;
2521
2522   case 46:
2523 #line 659 "/Users/chet/src/bash/src/parse.y"
2524     {
2525                           source.filename = (yyvsp[(1) - (3)].word);
2526                           redir.dest = 0;
2527                           (yyval.redirect) = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
2528                         }
2529     break;
2530
2531   case 47:
2532 #line 665 "/Users/chet/src/bash/src/parse.y"
2533     {
2534                           source.dest = 0;
2535                           redir.dest = 0;
2536                           (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
2537                         }
2538     break;
2539
2540   case 48:
2541 #line 671 "/Users/chet/src/bash/src/parse.y"
2542     {
2543                           source.dest = (yyvsp[(1) - (3)].number);
2544                           redir.dest = 0;
2545                           (yyval.redirect) = make_redirection (source, r_close_this, redir, 0);
2546                         }
2547     break;
2548
2549   case 49:
2550 #line 677 "/Users/chet/src/bash/src/parse.y"
2551     {
2552                           source.filename = (yyvsp[(1) - (3)].word);
2553                           redir.dest = 0;
2554                           (yyval.redirect) = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
2555                         }
2556     break;
2557
2558   case 50:
2559 #line 683 "/Users/chet/src/bash/src/parse.y"
2560     {
2561                           source.dest = 1;
2562                           redir.filename = (yyvsp[(2) - (2)].word);
2563                           (yyval.redirect) = make_redirection (source, r_err_and_out, redir, 0);
2564                         }
2565     break;
2566
2567   case 51:
2568 #line 689 "/Users/chet/src/bash/src/parse.y"
2569     {
2570                           source.dest = 1;
2571                           redir.filename = (yyvsp[(2) - (2)].word);
2572                           (yyval.redirect) = make_redirection (source, r_append_err_and_out, redir, 0);
2573                         }
2574     break;
2575
2576   case 52:
2577 #line 697 "/Users/chet/src/bash/src/parse.y"
2578     { (yyval.element).word = (yyvsp[(1) - (1)].word); (yyval.element).redirect = 0; }
2579     break;
2580
2581   case 53:
2582 #line 699 "/Users/chet/src/bash/src/parse.y"
2583     { (yyval.element).word = (yyvsp[(1) - (1)].word); (yyval.element).redirect = 0; }
2584     break;
2585
2586   case 54:
2587 #line 701 "/Users/chet/src/bash/src/parse.y"
2588     { (yyval.element).redirect = (yyvsp[(1) - (1)].redirect); (yyval.element).word = 0; }
2589     break;
2590
2591   case 55:
2592 #line 705 "/Users/chet/src/bash/src/parse.y"
2593     {
2594                           (yyval.redirect) = (yyvsp[(1) - (1)].redirect);
2595                         }
2596     break;
2597
2598   case 56:
2599 #line 709 "/Users/chet/src/bash/src/parse.y"
2600     {
2601                           register REDIRECT *t;
2602
2603                           for (t = (yyvsp[(1) - (2)].redirect); t->next; t = t->next)
2604                             ;
2605                           t->next = (yyvsp[(2) - (2)].redirect);
2606                           (yyval.redirect) = (yyvsp[(1) - (2)].redirect);
2607                         }
2608     break;
2609
2610   case 57:
2611 #line 720 "/Users/chet/src/bash/src/parse.y"
2612     { (yyval.command) = make_simple_command ((yyvsp[(1) - (1)].element), (COMMAND *)NULL); }
2613     break;
2614
2615   case 58:
2616 #line 722 "/Users/chet/src/bash/src/parse.y"
2617     { (yyval.command) = make_simple_command ((yyvsp[(2) - (2)].element), (yyvsp[(1) - (2)].command)); }
2618     break;
2619
2620   case 59:
2621 #line 726 "/Users/chet/src/bash/src/parse.y"
2622     { (yyval.command) = clean_simple_command ((yyvsp[(1) - (1)].command)); }
2623     break;
2624
2625   case 60:
2626 #line 728 "/Users/chet/src/bash/src/parse.y"
2627     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2628     break;
2629
2630   case 61:
2631 #line 730 "/Users/chet/src/bash/src/parse.y"
2632     {
2633                           COMMAND *tc;
2634
2635                           tc = (yyvsp[(1) - (2)].command);
2636                           if (tc->redirects)
2637                             {
2638                               register REDIRECT *t;
2639                               for (t = tc->redirects; t->next; t = t->next)
2640                                 ;
2641                               t->next = (yyvsp[(2) - (2)].redirect);
2642                             }
2643                           else
2644                             tc->redirects = (yyvsp[(2) - (2)].redirect);
2645                           (yyval.command) = (yyvsp[(1) - (2)].command);
2646                         }
2647     break;
2648
2649   case 62:
2650 #line 746 "/Users/chet/src/bash/src/parse.y"
2651     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2652     break;
2653
2654   case 63:
2655 #line 748 "/Users/chet/src/bash/src/parse.y"
2656     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2657     break;
2658
2659   case 64:
2660 #line 752 "/Users/chet/src/bash/src/parse.y"
2661     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2662     break;
2663
2664   case 65:
2665 #line 754 "/Users/chet/src/bash/src/parse.y"
2666     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2667     break;
2668
2669   case 66:
2670 #line 756 "/Users/chet/src/bash/src/parse.y"
2671     { (yyval.command) = make_while_command ((yyvsp[(2) - (5)].command), (yyvsp[(4) - (5)].command)); }
2672     break;
2673
2674   case 67:
2675 #line 758 "/Users/chet/src/bash/src/parse.y"
2676     { (yyval.command) = make_until_command ((yyvsp[(2) - (5)].command), (yyvsp[(4) - (5)].command)); }
2677     break;
2678
2679   case 68:
2680 #line 760 "/Users/chet/src/bash/src/parse.y"
2681     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2682     break;
2683
2684   case 69:
2685 #line 762 "/Users/chet/src/bash/src/parse.y"
2686     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2687     break;
2688
2689   case 70:
2690 #line 764 "/Users/chet/src/bash/src/parse.y"
2691     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2692     break;
2693
2694   case 71:
2695 #line 766 "/Users/chet/src/bash/src/parse.y"
2696     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2697     break;
2698
2699   case 72:
2700 #line 768 "/Users/chet/src/bash/src/parse.y"
2701     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2702     break;
2703
2704   case 73:
2705 #line 770 "/Users/chet/src/bash/src/parse.y"
2706     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2707     break;
2708
2709   case 74:
2710 #line 772 "/Users/chet/src/bash/src/parse.y"
2711     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2712     break;
2713
2714   case 75:
2715 #line 776 "/Users/chet/src/bash/src/parse.y"
2716     {
2717                           (yyval.command) = make_for_command ((yyvsp[(2) - (6)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(5) - (6)].command), word_lineno[word_top]);
2718                           if (word_top > 0) word_top--;
2719                         }
2720     break;
2721
2722   case 76:
2723 #line 781 "/Users/chet/src/bash/src/parse.y"
2724     {
2725                           (yyval.command) = make_for_command ((yyvsp[(2) - (6)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(5) - (6)].command), word_lineno[word_top]);
2726                           if (word_top > 0) word_top--;
2727                         }
2728     break;
2729
2730   case 77:
2731 #line 786 "/Users/chet/src/bash/src/parse.y"
2732     {
2733                           (yyval.command) = make_for_command ((yyvsp[(2) - (7)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(6) - (7)].command), word_lineno[word_top]);
2734                           if (word_top > 0) word_top--;
2735                         }
2736     break;
2737
2738   case 78:
2739 #line 791 "/Users/chet/src/bash/src/parse.y"
2740     {
2741                           (yyval.command) = make_for_command ((yyvsp[(2) - (7)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(6) - (7)].command), word_lineno[word_top]);
2742                           if (word_top > 0) word_top--;
2743                         }
2744     break;
2745
2746   case 79:
2747 #line 796 "/Users/chet/src/bash/src/parse.y"
2748     {
2749                           (yyval.command) = make_for_command ((yyvsp[(2) - (10)].word), REVERSE_LIST ((yyvsp[(5) - (10)].word_list), WORD_LIST *), (yyvsp[(9) - (10)].command), word_lineno[word_top]);
2750                           if (word_top > 0) word_top--;
2751                         }
2752     break;
2753
2754   case 80:
2755 #line 801 "/Users/chet/src/bash/src/parse.y"
2756     {
2757                           (yyval.command) = make_for_command ((yyvsp[(2) - (10)].word), REVERSE_LIST ((yyvsp[(5) - (10)].word_list), WORD_LIST *), (yyvsp[(9) - (10)].command), word_lineno[word_top]);
2758                           if (word_top > 0) word_top--;
2759                         }
2760     break;
2761
2762   case 81:
2763 #line 806 "/Users/chet/src/bash/src/parse.y"
2764     {
2765                           (yyval.command) = make_for_command ((yyvsp[(2) - (9)].word), (WORD_LIST *)NULL, (yyvsp[(8) - (9)].command), word_lineno[word_top]);
2766                           if (word_top > 0) word_top--;
2767                         }
2768     break;
2769
2770   case 82:
2771 #line 811 "/Users/chet/src/bash/src/parse.y"
2772     {
2773                           (yyval.command) = make_for_command ((yyvsp[(2) - (9)].word), (WORD_LIST *)NULL, (yyvsp[(8) - (9)].command), word_lineno[word_top]);
2774                           if (word_top > 0) word_top--;
2775                         }
2776     break;
2777
2778   case 83:
2779 #line 818 "/Users/chet/src/bash/src/parse.y"
2780     {
2781                                   (yyval.command) = make_arith_for_command ((yyvsp[(2) - (7)].word_list), (yyvsp[(6) - (7)].command), arith_for_lineno);
2782                                   if (word_top > 0) word_top--;
2783                                 }
2784     break;
2785
2786   case 84:
2787 #line 823 "/Users/chet/src/bash/src/parse.y"
2788     {
2789                                   (yyval.command) = make_arith_for_command ((yyvsp[(2) - (7)].word_list), (yyvsp[(6) - (7)].command), arith_for_lineno);
2790                                   if (word_top > 0) word_top--;
2791                                 }
2792     break;
2793
2794   case 85:
2795 #line 828 "/Users/chet/src/bash/src/parse.y"
2796     {
2797                                   (yyval.command) = make_arith_for_command ((yyvsp[(2) - (5)].word_list), (yyvsp[(4) - (5)].command), arith_for_lineno);
2798                                   if (word_top > 0) word_top--;
2799                                 }
2800     break;
2801
2802   case 86:
2803 #line 833 "/Users/chet/src/bash/src/parse.y"
2804     {
2805                                   (yyval.command) = make_arith_for_command ((yyvsp[(2) - (5)].word_list), (yyvsp[(4) - (5)].command), arith_for_lineno);
2806                                   if (word_top > 0) word_top--;
2807                                 }
2808     break;
2809
2810   case 87:
2811 #line 840 "/Users/chet/src/bash/src/parse.y"
2812     {
2813                           (yyval.command) = make_select_command ((yyvsp[(2) - (6)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(5) - (6)].command), word_lineno[word_top]);
2814                           if (word_top > 0) word_top--;
2815                         }
2816     break;
2817
2818   case 88:
2819 #line 845 "/Users/chet/src/bash/src/parse.y"
2820     {
2821                           (yyval.command) = make_select_command ((yyvsp[(2) - (6)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(5) - (6)].command), word_lineno[word_top]);
2822                           if (word_top > 0) word_top--;
2823                         }
2824     break;
2825
2826   case 89:
2827 #line 850 "/Users/chet/src/bash/src/parse.y"
2828     {
2829                           (yyval.command) = make_select_command ((yyvsp[(2) - (7)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(6) - (7)].command), word_lineno[word_top]);
2830                           if (word_top > 0) word_top--;
2831                         }
2832     break;
2833
2834   case 90:
2835 #line 855 "/Users/chet/src/bash/src/parse.y"
2836     {
2837                           (yyval.command) = make_select_command ((yyvsp[(2) - (7)].word), add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), (yyvsp[(6) - (7)].command), word_lineno[word_top]);
2838                           if (word_top > 0) word_top--;
2839                         }
2840     break;
2841
2842   case 91:
2843 #line 860 "/Users/chet/src/bash/src/parse.y"
2844     {
2845                           (yyval.command) = make_select_command ((yyvsp[(2) - (10)].word), REVERSE_LIST ((yyvsp[(5) - (10)].word_list), WORD_LIST *), (yyvsp[(9) - (10)].command), word_lineno[word_top]);
2846                           if (word_top > 0) word_top--;
2847                         }
2848     break;
2849
2850   case 92:
2851 #line 865 "/Users/chet/src/bash/src/parse.y"
2852     {
2853                           (yyval.command) = make_select_command ((yyvsp[(2) - (10)].word), REVERSE_LIST ((yyvsp[(5) - (10)].word_list), WORD_LIST *), (yyvsp[(9) - (10)].command), word_lineno[word_top]);
2854                           if (word_top > 0) word_top--;
2855                         }
2856     break;
2857
2858   case 93:
2859 #line 872 "/Users/chet/src/bash/src/parse.y"
2860     {
2861                           (yyval.command) = make_case_command ((yyvsp[(2) - (6)].word), (PATTERN_LIST *)NULL, word_lineno[word_top]);
2862                           if (word_top > 0) word_top--;
2863                         }
2864     break;
2865
2866   case 94:
2867 #line 877 "/Users/chet/src/bash/src/parse.y"
2868     {
2869                           (yyval.command) = make_case_command ((yyvsp[(2) - (7)].word), (yyvsp[(5) - (7)].pattern), word_lineno[word_top]);
2870                           if (word_top > 0) word_top--;
2871                         }
2872     break;
2873
2874   case 95:
2875 #line 882 "/Users/chet/src/bash/src/parse.y"
2876     {
2877                           (yyval.command) = make_case_command ((yyvsp[(2) - (6)].word), (yyvsp[(5) - (6)].pattern), word_lineno[word_top]);
2878                           if (word_top > 0) word_top--;
2879                         }
2880     break;
2881
2882   case 96:
2883 #line 889 "/Users/chet/src/bash/src/parse.y"
2884     { (yyval.command) = make_function_def ((yyvsp[(1) - (5)].word), (yyvsp[(5) - (5)].command), function_dstart, function_bstart); }
2885     break;
2886
2887   case 97:
2888 #line 892 "/Users/chet/src/bash/src/parse.y"
2889     { (yyval.command) = make_function_def ((yyvsp[(2) - (6)].word), (yyvsp[(6) - (6)].command), function_dstart, function_bstart); }
2890     break;
2891
2892   case 98:
2893 #line 895 "/Users/chet/src/bash/src/parse.y"
2894     { (yyval.command) = make_function_def ((yyvsp[(2) - (4)].word), (yyvsp[(4) - (4)].command), function_dstart, function_bstart); }
2895     break;
2896
2897   case 99:
2898 #line 899 "/Users/chet/src/bash/src/parse.y"
2899     { (yyval.command) = (yyvsp[(1) - (1)].command); }
2900     break;
2901
2902   case 100:
2903 #line 901 "/Users/chet/src/bash/src/parse.y"
2904     {
2905                           COMMAND *tc;
2906
2907                           tc = (yyvsp[(1) - (2)].command);
2908                           /* According to Posix.2 3.9.5, redirections
2909                              specified after the body of a function should
2910                              be attached to the function and performed when
2911                              the function is executed, not as part of the
2912                              function definition command. */
2913                           /* XXX - I don't think it matters, but we might
2914                              want to change this in the future to avoid
2915                              problems differentiating between a function
2916                              definition with a redirection and a function
2917                              definition containing a single command with a
2918                              redirection.  The two are semantically equivalent,
2919                              though -- the only difference is in how the
2920                              command printing code displays the redirections. */
2921                           if (tc->redirects)
2922                             {
2923                               register REDIRECT *t;
2924                               for (t = tc->redirects; t->next; t = t->next)
2925                                 ;
2926                               t->next = (yyvsp[(2) - (2)].redirect);
2927                             }
2928                           else
2929                             tc->redirects = (yyvsp[(2) - (2)].redirect);
2930                           (yyval.command) = (yyvsp[(1) - (2)].command);
2931                         }
2932     break;
2933
2934   case 101:
2935 #line 932 "/Users/chet/src/bash/src/parse.y"
2936     {
2937                           (yyval.command) = make_subshell_command ((yyvsp[(2) - (3)].command));
2938                           (yyval.command)->flags |= CMD_WANT_SUBSHELL;
2939                         }
2940     break;
2941
2942   case 102:
2943 #line 939 "/Users/chet/src/bash/src/parse.y"
2944     {
2945                           (yyval.command) = make_coproc_command ("COPROC", (yyvsp[(2) - (2)].command));
2946                           (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
2947                         }
2948     break;
2949
2950   case 103:
2951 #line 944 "/Users/chet/src/bash/src/parse.y"
2952     {
2953                           COMMAND *tc;
2954
2955                           tc = (yyvsp[(2) - (3)].command);
2956                           if (tc->redirects)
2957                             {
2958                               register REDIRECT *t;
2959                               for (t = tc->redirects; t->next; t = t->next)
2960                                 ;
2961                               t->next = (yyvsp[(3) - (3)].redirect);
2962                             }
2963                           else
2964                             tc->redirects = (yyvsp[(3) - (3)].redirect);
2965                           (yyval.command) = make_coproc_command ("COPROC", (yyvsp[(2) - (3)].command));
2966                           (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
2967                         }
2968     break;
2969
2970   case 104:
2971 #line 961 "/Users/chet/src/bash/src/parse.y"
2972     {
2973                           (yyval.command) = make_coproc_command ((yyvsp[(2) - (3)].word)->word, (yyvsp[(3) - (3)].command));
2974                           (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
2975                         }
2976     break;
2977
2978   case 105:
2979 #line 966 "/Users/chet/src/bash/src/parse.y"
2980     {
2981                           COMMAND *tc;
2982
2983                           tc = (yyvsp[(3) - (4)].command);
2984                           if (tc->redirects)
2985                             {
2986                               register REDIRECT *t;
2987                               for (t = tc->redirects; t->next; t = t->next)
2988                                 ;
2989                               t->next = (yyvsp[(4) - (4)].redirect);
2990                             }
2991                           else
2992                             tc->redirects = (yyvsp[(4) - (4)].redirect);
2993                           (yyval.command) = make_coproc_command ((yyvsp[(2) - (4)].word)->word, (yyvsp[(3) - (4)].command));
2994                           (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
2995                         }
2996     break;
2997
2998   case 106:
2999 #line 983 "/Users/chet/src/bash/src/parse.y"
3000     {
3001                           (yyval.command) = make_coproc_command ("COPROC", clean_simple_command ((yyvsp[(2) - (2)].command)));
3002                           (yyval.command)->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
3003                         }
3004     break;
3005
3006   case 107:
3007 #line 990 "/Users/chet/src/bash/src/parse.y"
3008     { (yyval.command) = make_if_command ((yyvsp[(2) - (5)].command), (yyvsp[(4) - (5)].command), (COMMAND *)NULL); }
3009     break;
3010
3011   case 108:
3012 #line 992 "/Users/chet/src/bash/src/parse.y"
3013     { (yyval.command) = make_if_command ((yyvsp[(2) - (7)].command), (yyvsp[(4) - (7)].command), (yyvsp[(6) - (7)].command)); }
3014     break;
3015
3016   case 109:
3017 #line 994 "/Users/chet/src/bash/src/parse.y"
3018     { (yyval.command) = make_if_command ((yyvsp[(2) - (6)].command), (yyvsp[(4) - (6)].command), (yyvsp[(5) - (6)].command)); }
3019     break;
3020
3021   case 110:
3022 #line 999 "/Users/chet/src/bash/src/parse.y"
3023     { (yyval.command) = make_group_command ((yyvsp[(2) - (3)].command)); }
3024     break;
3025
3026   case 111:
3027 #line 1003 "/Users/chet/src/bash/src/parse.y"
3028     { (yyval.command) = make_arith_command ((yyvsp[(1) - (1)].word_list)); }
3029     break;
3030
3031   case 112:
3032 #line 1007 "/Users/chet/src/bash/src/parse.y"
3033     { (yyval.command) = (yyvsp[(2) - (3)].command); }
3034     break;
3035
3036   case 113:
3037 #line 1011 "/Users/chet/src/bash/src/parse.y"
3038     { (yyval.command) = make_if_command ((yyvsp[(2) - (4)].command), (yyvsp[(4) - (4)].command), (COMMAND *)NULL); }
3039     break;
3040
3041   case 114:
3042 #line 1013 "/Users/chet/src/bash/src/parse.y"
3043     { (yyval.command) = make_if_command ((yyvsp[(2) - (6)].command), (yyvsp[(4) - (6)].command), (yyvsp[(6) - (6)].command)); }
3044     break;
3045
3046   case 115:
3047 #line 1015 "/Users/chet/src/bash/src/parse.y"
3048     { (yyval.command) = make_if_command ((yyvsp[(2) - (5)].command), (yyvsp[(4) - (5)].command), (yyvsp[(5) - (5)].command)); }
3049     break;
3050
3051   case 117:
3052 #line 1020 "/Users/chet/src/bash/src/parse.y"
3053     { (yyvsp[(2) - (2)].pattern)->next = (yyvsp[(1) - (2)].pattern); (yyval.pattern) = (yyvsp[(2) - (2)].pattern); }
3054     break;
3055
3056   case 118:
3057 #line 1024 "/Users/chet/src/bash/src/parse.y"
3058     { (yyval.pattern) = make_pattern_list ((yyvsp[(2) - (4)].word_list), (yyvsp[(4) - (4)].command)); }
3059     break;
3060
3061   case 119:
3062 #line 1026 "/Users/chet/src/bash/src/parse.y"
3063     { (yyval.pattern) = make_pattern_list ((yyvsp[(2) - (4)].word_list), (COMMAND *)NULL); }
3064     break;
3065
3066   case 120:
3067 #line 1028 "/Users/chet/src/bash/src/parse.y"
3068     { (yyval.pattern) = make_pattern_list ((yyvsp[(3) - (5)].word_list), (yyvsp[(5) - (5)].command)); }
3069     break;
3070
3071   case 121:
3072 #line 1030 "/Users/chet/src/bash/src/parse.y"
3073     { (yyval.pattern) = make_pattern_list ((yyvsp[(3) - (5)].word_list), (COMMAND *)NULL); }
3074     break;
3075
3076   case 122:
3077 #line 1034 "/Users/chet/src/bash/src/parse.y"
3078     { (yyval.pattern) = (yyvsp[(1) - (2)].pattern); }
3079     break;
3080
3081   case 123:
3082 #line 1036 "/Users/chet/src/bash/src/parse.y"
3083     { (yyvsp[(2) - (3)].pattern)->next = (yyvsp[(1) - (3)].pattern); (yyval.pattern) = (yyvsp[(2) - (3)].pattern); }
3084     break;
3085
3086   case 124:
3087 #line 1038 "/Users/chet/src/bash/src/parse.y"
3088     { (yyvsp[(1) - (2)].pattern)->flags |= CASEPAT_FALLTHROUGH; (yyval.pattern) = (yyvsp[(1) - (2)].pattern); }
3089     break;
3090
3091   case 125:
3092 #line 1040 "/Users/chet/src/bash/src/parse.y"
3093     { (yyvsp[(2) - (3)].pattern)->flags |= CASEPAT_FALLTHROUGH; (yyvsp[(2) - (3)].pattern)->next = (yyvsp[(1) - (3)].pattern); (yyval.pattern) = (yyvsp[(2) - (3)].pattern); }
3094     break;
3095
3096   case 126:
3097 #line 1042 "/Users/chet/src/bash/src/parse.y"
3098     { (yyvsp[(1) - (2)].pattern)->flags |= CASEPAT_TESTNEXT; (yyval.pattern) = (yyvsp[(1) - (2)].pattern); }
3099     break;
3100
3101   case 127:
3102 #line 1044 "/Users/chet/src/bash/src/parse.y"
3103     { (yyvsp[(2) - (3)].pattern)->flags |= CASEPAT_TESTNEXT; (yyvsp[(2) - (3)].pattern)->next = (yyvsp[(1) - (3)].pattern); (yyval.pattern) = (yyvsp[(2) - (3)].pattern); }
3104     break;
3105
3106   case 128:
3107 #line 1048 "/Users/chet/src/bash/src/parse.y"
3108     { (yyval.word_list) = make_word_list ((yyvsp[(1) - (1)].word), (WORD_LIST *)NULL); }
3109     break;
3110
3111   case 129:
3112 #line 1050 "/Users/chet/src/bash/src/parse.y"
3113     { (yyval.word_list) = make_word_list ((yyvsp[(3) - (3)].word), (yyvsp[(1) - (3)].word_list)); }
3114     break;
3115
3116   case 130:
3117 #line 1059 "/Users/chet/src/bash/src/parse.y"
3118     {
3119                           (yyval.command) = (yyvsp[(2) - (2)].command);
3120                           if (need_here_doc)
3121                             gather_here_documents ();
3122                          }
3123     break;
3124
3125   case 132:
3126 #line 1068 "/Users/chet/src/bash/src/parse.y"
3127     {
3128                           (yyval.command) = (yyvsp[(2) - (2)].command);
3129                         }
3130     break;
3131
3132   case 134:
3133 #line 1075 "/Users/chet/src/bash/src/parse.y"
3134     {
3135                           if ((yyvsp[(1) - (3)].command)->type == cm_connection)
3136                             (yyval.command) = connect_async_list ((yyvsp[(1) - (3)].command), (COMMAND *)NULL, '&');
3137                           else
3138                             (yyval.command) = command_connect ((yyvsp[(1) - (3)].command), (COMMAND *)NULL, '&');
3139                         }
3140     break;
3141
3142   case 136:
3143 #line 1086 "/Users/chet/src/bash/src/parse.y"
3144     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), AND_AND); }
3145     break;
3146
3147   case 137:
3148 #line 1088 "/Users/chet/src/bash/src/parse.y"
3149     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), OR_OR); }
3150     break;
3151
3152   case 138:
3153 #line 1090 "/Users/chet/src/bash/src/parse.y"
3154     {
3155                           if ((yyvsp[(1) - (4)].command)->type == cm_connection)
3156                             (yyval.command) = connect_async_list ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), '&');
3157                           else
3158                             (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), '&');
3159                         }
3160     break;
3161
3162   case 139:
3163 #line 1097 "/Users/chet/src/bash/src/parse.y"
3164     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), ';'); }
3165     break;
3166
3167   case 140:
3168 #line 1099 "/Users/chet/src/bash/src/parse.y"
3169     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), ';'); }
3170     break;
3171
3172   case 141:
3173 #line 1101 "/Users/chet/src/bash/src/parse.y"
3174     { (yyval.command) = (yyvsp[(1) - (1)].command); }
3175     break;
3176
3177   case 144:
3178 #line 1109 "/Users/chet/src/bash/src/parse.y"
3179     { (yyval.number) = '\n'; }
3180     break;
3181
3182   case 145:
3183 #line 1111 "/Users/chet/src/bash/src/parse.y"
3184     { (yyval.number) = ';'; }
3185     break;
3186
3187   case 146:
3188 #line 1113 "/Users/chet/src/bash/src/parse.y"
3189     { (yyval.number) = yacc_EOF; }
3190     break;
3191
3192   case 149:
3193 #line 1127 "/Users/chet/src/bash/src/parse.y"
3194     {
3195                           (yyval.command) = (yyvsp[(1) - (1)].command);
3196                           if (need_here_doc)
3197                             gather_here_documents ();
3198                           if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
3199                             {
3200                               global_command = (yyvsp[(1) - (1)].command);
3201                               eof_encountered = 0;
3202                               rewind_input_string ();
3203                               YYACCEPT;
3204                             }
3205                         }
3206     break;
3207
3208   case 150:
3209 #line 1140 "/Users/chet/src/bash/src/parse.y"
3210     {
3211                           if ((yyvsp[(1) - (2)].command)->type == cm_connection)
3212                             (yyval.command) = connect_async_list ((yyvsp[(1) - (2)].command), (COMMAND *)NULL, '&');
3213                           else
3214                             (yyval.command) = command_connect ((yyvsp[(1) - (2)].command), (COMMAND *)NULL, '&');
3215                           if (need_here_doc)
3216                             gather_here_documents ();
3217                           if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
3218                             {
3219                               global_command = (yyvsp[(1) - (2)].command);
3220                               eof_encountered = 0;
3221                               rewind_input_string ();
3222                               YYACCEPT;
3223                             }
3224                         }
3225     break;
3226
3227   case 151:
3228 #line 1156 "/Users/chet/src/bash/src/parse.y"
3229     {
3230                           (yyval.command) = (yyvsp[(1) - (2)].command);
3231                           if (need_here_doc)
3232                             gather_here_documents ();
3233                           if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
3234                             {
3235                               global_command = (yyvsp[(1) - (2)].command);
3236                               eof_encountered = 0;
3237                               rewind_input_string ();
3238                               YYACCEPT;
3239                             }
3240                         }
3241     break;
3242
3243   case 152:
3244 #line 1171 "/Users/chet/src/bash/src/parse.y"
3245     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), AND_AND); }
3246     break;
3247
3248   case 153:
3249 #line 1173 "/Users/chet/src/bash/src/parse.y"
3250     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), OR_OR); }
3251     break;
3252
3253   case 154:
3254 #line 1175 "/Users/chet/src/bash/src/parse.y"
3255     {
3256                           if ((yyvsp[(1) - (3)].command)->type == cm_connection)
3257                             (yyval.command) = connect_async_list ((yyvsp[(1) - (3)].command), (yyvsp[(3) - (3)].command), '&');
3258                           else
3259                             (yyval.command) = command_connect ((yyvsp[(1) - (3)].command), (yyvsp[(3) - (3)].command), '&');
3260                         }
3261     break;
3262
3263   case 155:
3264 #line 1182 "/Users/chet/src/bash/src/parse.y"
3265     { (yyval.command) = command_connect ((yyvsp[(1) - (3)].command), (yyvsp[(3) - (3)].command), ';'); }
3266     break;
3267
3268   case 156:
3269 #line 1185 "/Users/chet/src/bash/src/parse.y"
3270     { (yyval.command) = (yyvsp[(1) - (1)].command); }
3271     break;
3272
3273   case 157:
3274 #line 1189 "/Users/chet/src/bash/src/parse.y"
3275     { (yyval.command) = (yyvsp[(1) - (1)].command); }
3276     break;
3277
3278   case 158:
3279 #line 1191 "/Users/chet/src/bash/src/parse.y"
3280     {
3281                           if ((yyvsp[(2) - (2)].command))
3282                             (yyvsp[(2) - (2)].command)->flags |= CMD_INVERT_RETURN;
3283                           (yyval.command) = (yyvsp[(2) - (2)].command);
3284                         }
3285     break;
3286
3287   case 159:
3288 #line 1197 "/Users/chet/src/bash/src/parse.y"
3289     {
3290                           if ((yyvsp[(2) - (2)].command))
3291                             (yyvsp[(2) - (2)].command)->flags |= (yyvsp[(1) - (2)].number);
3292                           (yyval.command) = (yyvsp[(2) - (2)].command);
3293                         }
3294     break;
3295
3296   case 160:
3297 #line 1203 "/Users/chet/src/bash/src/parse.y"
3298     {
3299                           if ((yyvsp[(3) - (3)].command))
3300                             (yyvsp[(3) - (3)].command)->flags |= (yyvsp[(1) - (3)].number)|CMD_INVERT_RETURN;
3301                           (yyval.command) = (yyvsp[(3) - (3)].command);
3302                         }
3303     break;
3304
3305   case 161:
3306 #line 1209 "/Users/chet/src/bash/src/parse.y"
3307     {
3308                           if ((yyvsp[(3) - (3)].command))
3309                             (yyvsp[(3) - (3)].command)->flags |= (yyvsp[(2) - (3)].number)|CMD_INVERT_RETURN;
3310                           (yyval.command) = (yyvsp[(3) - (3)].command);
3311                         }
3312     break;
3313
3314   case 162:
3315 #line 1215 "/Users/chet/src/bash/src/parse.y"
3316     {
3317                           ELEMENT x;
3318
3319                           /* Boy, this is unclean.  `time' by itself can
3320                              time a null command.  We cheat and push a
3321                              newline back if the list_terminator was a newline
3322                              to avoid the double-newline problem (one to
3323                              terminate this, one to terminate the command) */
3324                           x.word = 0;
3325                           x.redirect = 0;
3326                           (yyval.command) = make_simple_command (x, (COMMAND *)NULL);
3327                           (yyval.command)->flags |= (yyvsp[(1) - (2)].number);
3328                           /* XXX - let's cheat and push a newline back */
3329                           if ((yyvsp[(2) - (2)].number) == '\n')
3330                             token_to_read = '\n';
3331                         }
3332     break;
3333
3334   case 163:
3335 #line 1235 "/Users/chet/src/bash/src/parse.y"
3336     { (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), '|'); }
3337     break;
3338
3339   case 164:
3340 #line 1237 "/Users/chet/src/bash/src/parse.y"
3341     {
3342                           /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */
3343                           COMMAND *tc;
3344                           REDIRECTEE rd, sd;
3345                           REDIRECT *r;
3346
3347                           tc = (yyvsp[(1) - (4)].command)->type == cm_simple ? (COMMAND *)(yyvsp[(1) - (4)].command)->value.Simple : (yyvsp[(1) - (4)].command);
3348                           sd.dest = 2;
3349                           rd.dest = 1;
3350                           r = make_redirection (sd, r_duplicating_output, rd, 0);
3351                           if (tc->redirects)
3352                             {
3353                               register REDIRECT *t;
3354                               for (t = tc->redirects; t->next; t = t->next)
3355                                 ;
3356                               t->next = r;
3357                             }
3358                           else
3359                             tc->redirects = r;
3360
3361                           (yyval.command) = command_connect ((yyvsp[(1) - (4)].command), (yyvsp[(4) - (4)].command), '|');
3362                         }
3363     break;
3364
3365   case 165:
3366 #line 1260 "/Users/chet/src/bash/src/parse.y"
3367     { (yyval.command) = (yyvsp[(1) - (1)].command); }
3368     break;
3369
3370   case 166:
3371 #line 1264 "/Users/chet/src/bash/src/parse.y"
3372     { (yyval.number) = CMD_TIME_PIPELINE; }
3373     break;
3374
3375   case 167:
3376 #line 1266 "/Users/chet/src/bash/src/parse.y"
3377     { (yyval.number) = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
3378     break;
3379
3380
3381 /* Line 1267 of yacc.c.  */
3382 #line 3383 "y.tab.c"
3383       default: break;
3384     }
3385   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3386
3387   YYPOPSTACK (yylen);
3388   yylen = 0;
3389   YY_STACK_PRINT (yyss, yyssp);
3390
3391   *++yyvsp = yyval;
3392
3393
3394   /* Now `shift' the result of the reduction.  Determine what state
3395      that goes to, based on the state we popped back to and the rule
3396      number reduced by.  */
3397
3398   yyn = yyr1[yyn];
3399
3400   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3401   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3402     yystate = yytable[yystate];
3403   else
3404     yystate = yydefgoto[yyn - YYNTOKENS];
3405
3406   goto yynewstate;
3407
3408
3409 /*------------------------------------.
3410 | yyerrlab -- here on detecting error |
3411 `------------------------------------*/
3412 yyerrlab:
3413   /* If not already recovering from an error, report this error.  */
3414   if (!yyerrstatus)
3415     {
3416       ++yynerrs;
3417 #if ! YYERROR_VERBOSE
3418       yyerror (YY_("syntax error"));
3419 #else
3420       {
3421         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3422         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3423           {
3424             YYSIZE_T yyalloc = 2 * yysize;
3425             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3426               yyalloc = YYSTACK_ALLOC_MAXIMUM;
3427             if (yymsg != yymsgbuf)
3428               YYSTACK_FREE (yymsg);
3429             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3430             if (yymsg)
3431               yymsg_alloc = yyalloc;
3432             else
3433               {
3434                 yymsg = yymsgbuf;
3435                 yymsg_alloc = sizeof yymsgbuf;
3436               }
3437           }
3438
3439         if (0 < yysize && yysize <= yymsg_alloc)
3440           {
3441             (void) yysyntax_error (yymsg, yystate, yychar);
3442             yyerror (yymsg);
3443           }
3444         else
3445           {
3446             yyerror (YY_("syntax error"));
3447             if (yysize != 0)
3448               goto yyexhaustedlab;
3449           }
3450       }
3451 #endif
3452     }
3453
3454
3455
3456   if (yyerrstatus == 3)
3457     {
3458       /* If just tried and failed to reuse look-ahead token after an
3459          error, discard it.  */
3460
3461       if (yychar <= YYEOF)
3462         {
3463           /* Return failure if at end of input.  */
3464           if (yychar == YYEOF)
3465             YYABORT;
3466         }
3467       else
3468         {
3469           yydestruct ("Error: discarding",
3470                       yytoken, &yylval);
3471           yychar = YYEMPTY;
3472         }
3473     }
3474
3475   /* Else will try to reuse look-ahead token after shifting the error
3476      token.  */
3477   goto yyerrlab1;
3478
3479
3480 /*---------------------------------------------------.
3481 | yyerrorlab -- error raised explicitly by YYERROR.  |
3482 `---------------------------------------------------*/
3483 yyerrorlab:
3484
3485   /* Pacify compilers like GCC when the user code never invokes
3486      YYERROR and the label yyerrorlab therefore never appears in user
3487      code.  */
3488   if (/*CONSTCOND*/ 0)
3489      goto yyerrorlab;
3490
3491   /* Do not reclaim the symbols of the rule which action triggered
3492      this YYERROR.  */
3493   YYPOPSTACK (yylen);
3494   yylen = 0;
3495   YY_STACK_PRINT (yyss, yyssp);
3496   yystate = *yyssp;
3497   goto yyerrlab1;
3498
3499
3500 /*-------------------------------------------------------------.
3501 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
3502 `-------------------------------------------------------------*/
3503 yyerrlab1:
3504   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
3505
3506   for (;;)
3507     {
3508       yyn = yypact[yystate];
3509       if (yyn != YYPACT_NINF)
3510         {
3511           yyn += YYTERROR;
3512           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3513             {
3514               yyn = yytable[yyn];
3515               if (0 < yyn)
3516                 break;
3517             }
3518         }
3519
3520       /* Pop the current state because it cannot handle the error token.  */
3521       if (yyssp == yyss)
3522         YYABORT;
3523
3524
3525       yydestruct ("Error: popping",
3526                   yystos[yystate], yyvsp);
3527       YYPOPSTACK (1);
3528       yystate = *yyssp;
3529       YY_STACK_PRINT (yyss, yyssp);
3530     }
3531
3532   if (yyn == YYFINAL)
3533     YYACCEPT;
3534
3535   *++yyvsp = yylval;
3536
3537
3538   /* Shift the error token.  */
3539   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3540
3541   yystate = yyn;
3542   goto yynewstate;
3543
3544
3545 /*-------------------------------------.
3546 | yyacceptlab -- YYACCEPT comes here.  |
3547 `-------------------------------------*/
3548 yyacceptlab:
3549   yyresult = 0;
3550   goto yyreturn;
3551
3552 /*-----------------------------------.
3553 | yyabortlab -- YYABORT comes here.  |
3554 `-----------------------------------*/
3555 yyabortlab:
3556   yyresult = 1;
3557   goto yyreturn;
3558
3559 #ifndef yyoverflow
3560 /*-------------------------------------------------.
3561 | yyexhaustedlab -- memory exhaustion comes here.  |
3562 `-------------------------------------------------*/
3563 yyexhaustedlab:
3564   yyerror (YY_("memory exhausted"));
3565   yyresult = 2;
3566   /* Fall through.  */
3567 #endif
3568
3569 yyreturn:
3570   if (yychar != YYEOF && yychar != YYEMPTY)
3571      yydestruct ("Cleanup: discarding lookahead",
3572                  yytoken, &yylval);
3573   /* Do not reclaim the symbols of the rule which action triggered
3574      this YYABORT or YYACCEPT.  */
3575   YYPOPSTACK (yylen);
3576   YY_STACK_PRINT (yyss, yyssp);
3577   while (yyssp != yyss)
3578     {
3579       yydestruct ("Cleanup: popping",
3580                   yystos[*yyssp], yyvsp);
3581       YYPOPSTACK (1);
3582     }
3583 #ifndef yyoverflow
3584   if (yyss != yyssa)
3585     YYSTACK_FREE (yyss);
3586 #endif
3587 #if YYERROR_VERBOSE
3588   if (yymsg != yymsgbuf)
3589     YYSTACK_FREE (yymsg);
3590 #endif
3591   /* Make sure YYID is used.  */
3592   return YYID (yyresult);
3593 }
3594
3595
3596 #line 1268 "/Users/chet/src/bash/src/parse.y"
3597
3598
3599 /* Initial size to allocate for tokens, and the
3600    amount to grow them by. */
3601 #define TOKEN_DEFAULT_INITIAL_SIZE 496
3602 #define TOKEN_DEFAULT_GROW_SIZE 512
3603
3604 /* Should we call prompt_again? */
3605 #define SHOULD_PROMPT() \
3606   (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
3607
3608 #if defined (ALIAS)
3609 #  define expanding_alias() (pushed_string_list && pushed_string_list->expander)
3610 #else
3611 #  define expanding_alias() 0
3612 #endif
3613
3614 /* Global var is non-zero when end of file has been reached. */
3615 int EOF_Reached = 0;
3616
3617 #ifdef DEBUG
3618 static void
3619 debug_parser (i)
3620      int i;
3621 {
3622 #if YYDEBUG != 0
3623   yydebug = i;
3624 #endif
3625 }
3626 #endif
3627
3628 /* yy_getc () returns the next available character from input or EOF.
3629    yy_ungetc (c) makes `c' the next character to read.
3630    init_yy_io (get, unget, type, location) makes the function GET the
3631    installed function for getting the next character, makes UNGET the
3632    installed function for un-getting a character, sets the type of stream
3633    (either string or file) from TYPE, and makes LOCATION point to where
3634    the input is coming from. */
3635
3636 /* Unconditionally returns end-of-file. */
3637 int
3638 return_EOF ()
3639 {
3640   return (EOF);
3641 }
3642
3643 /* Variable containing the current get and unget functions.
3644    See ./input.h for a clearer description. */
3645 BASH_INPUT bash_input;
3646
3647 /* Set all of the fields in BASH_INPUT to NULL.  Free bash_input.name if it
3648    is non-null, avoiding a memory leak. */
3649 void
3650 initialize_bash_input ()
3651 {
3652   bash_input.type = st_none;
3653   FREE (bash_input.name);
3654   bash_input.name = (char *)NULL;
3655   bash_input.location.file = (FILE *)NULL;
3656   bash_input.location.string = (char *)NULL;
3657   bash_input.getter = (sh_cget_func_t *)NULL;
3658   bash_input.ungetter = (sh_cunget_func_t *)NULL;
3659 }
3660
3661 /* Set the contents of the current bash input stream from
3662    GET, UNGET, TYPE, NAME, and LOCATION. */
3663 void
3664 init_yy_io (get, unget, type, name, location)
3665      sh_cget_func_t *get;
3666      sh_cunget_func_t *unget;
3667      enum stream_type type;
3668      const char *name;
3669      INPUT_STREAM location;
3670 {
3671   bash_input.type = type;
3672   FREE (bash_input.name);
3673   bash_input.name = name ? savestring (name) : (char *)NULL;
3674
3675   /* XXX */
3676 #if defined (CRAY)
3677   memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
3678 #else
3679   bash_input.location = location;
3680 #endif
3681   bash_input.getter = get;
3682   bash_input.ungetter = unget;
3683 }
3684
3685 char *
3686 yy_input_name ()
3687 {
3688   return (bash_input.name ? bash_input.name : "stdin");
3689 }
3690
3691 /* Call this to get the next character of input. */
3692 static int
3693 yy_getc ()
3694 {
3695   return (*(bash_input.getter)) ();
3696 }
3697
3698 /* Call this to unget C.  That is, to make C the next character
3699    to be read. */
3700 static int
3701 yy_ungetc (c)
3702      int c;
3703 {
3704   return (*(bash_input.ungetter)) (c);
3705 }
3706
3707 #if defined (BUFFERED_INPUT)
3708 #ifdef INCLUDE_UNUSED
3709 int
3710 input_file_descriptor ()
3711 {
3712   switch (bash_input.type)
3713     {
3714     case st_stream:
3715       return (fileno (bash_input.location.file));
3716     case st_bstream:
3717       return (bash_input.location.buffered_fd);
3718     case st_stdin:
3719     default:
3720       return (fileno (stdin));
3721     }
3722 }
3723 #endif
3724 #endif /* BUFFERED_INPUT */
3725
3726 /* **************************************************************** */
3727 /*                                                                  */
3728 /*                Let input be read from readline ().               */
3729 /*                                                                  */
3730 /* **************************************************************** */
3731
3732 #if defined (READLINE)
3733 char *current_readline_prompt = (char *)NULL;
3734 char *current_readline_line = (char *)NULL;
3735 int current_readline_line_index = 0;
3736
3737 static int
3738 yy_readline_get ()
3739 {
3740   SigHandler *old_sigint;
3741   int line_len;
3742   unsigned char c;
3743
3744   if (!current_readline_line)
3745     {
3746       if (!bash_readline_initialized)
3747         initialize_readline ();
3748
3749 #if defined (JOB_CONTROL)
3750       if (job_control)
3751         give_terminal_to (shell_pgrp, 0);
3752 #endif /* JOB_CONTROL */
3753
3754       old_sigint = (SigHandler *)NULL;
3755       if (signal_is_ignored (SIGINT) == 0)
3756         {
3757           old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
3758           interrupt_immediately++;
3759         }
3760       terminate_immediately = 1;
3761
3762       current_readline_line = readline (current_readline_prompt ?
3763                                           current_readline_prompt : "");
3764
3765       terminate_immediately = 0;
3766       if (signal_is_ignored (SIGINT) == 0 && old_sigint)
3767         {
3768           interrupt_immediately--;
3769           set_signal_handler (SIGINT, old_sigint);
3770         }
3771
3772 #if 0
3773       /* Reset the prompt to the decoded value of prompt_string_pointer. */
3774       reset_readline_prompt ();
3775 #endif
3776
3777       if (current_readline_line == 0)
3778         return (EOF);
3779
3780       current_readline_line_index = 0;
3781       line_len = strlen (current_readline_line);
3782
3783       current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
3784       current_readline_line[line_len++] = '\n';
3785       current_readline_line[line_len] = '\0';
3786     }
3787
3788   if (current_readline_line[current_readline_line_index] == 0)
3789     {
3790       free (current_readline_line);
3791       current_readline_line = (char *)NULL;
3792       return (yy_readline_get ());
3793     }
3794   else
3795     {
3796       c = current_readline_line[current_readline_line_index++];
3797       return (c);
3798     }
3799 }
3800
3801 static int
3802 yy_readline_unget (c)
3803      int c;
3804 {
3805   if (current_readline_line_index && current_readline_line)
3806     current_readline_line[--current_readline_line_index] = c;
3807   return (c);
3808 }
3809
3810 void
3811 with_input_from_stdin ()
3812 {
3813   INPUT_STREAM location;
3814
3815   if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
3816     {
3817       location.string = current_readline_line;
3818       init_yy_io (yy_readline_get, yy_readline_unget,
3819                   st_stdin, "readline stdin", location);
3820     }
3821 }
3822
3823 #else  /* !READLINE */
3824
3825 void
3826 with_input_from_stdin ()
3827 {
3828   with_input_from_stream (stdin, "stdin");
3829 }
3830 #endif  /* !READLINE */
3831
3832 /* **************************************************************** */
3833 /*                                                                  */
3834 /*   Let input come from STRING.  STRING is zero terminated.        */
3835 /*                                                                  */
3836 /* **************************************************************** */
3837
3838 static int
3839 yy_string_get ()
3840 {
3841   register char *string;
3842   register unsigned char c;
3843
3844   string = bash_input.location.string;
3845
3846   /* If the string doesn't exist, or is empty, EOF found. */
3847   if (string && *string)
3848     {
3849       c = *string++;
3850       bash_input.location.string = string;
3851       return (c);
3852     }
3853   else
3854     return (EOF);
3855 }
3856
3857 static int
3858 yy_string_unget (c)
3859      int c;
3860 {
3861   *(--bash_input.location.string) = c;
3862   return (c);
3863 }
3864
3865 void
3866 with_input_from_string (string, name)
3867      char *string;
3868      const char *name;
3869 {
3870   INPUT_STREAM location;
3871
3872   location.string = string;
3873   init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
3874 }
3875
3876 /* Count the number of characters we've consumed from bash_input.location.string
3877    and read into shell_input_line, but have not returned from shell_getc.
3878    That is the true input location.  Rewind bash_input.location.string by
3879    that number of characters, so it points to the last character actually
3880    consumed by the parser. */
3881 static void
3882 rewind_input_string ()
3883 {
3884   int xchars;
3885
3886   /* number of unconsumed characters in the input -- XXX need to take newlines
3887      into account, e.g., $(...\n) */
3888   xchars = shell_input_line_len - shell_input_line_index;
3889   if (bash_input.location.string[-1] == '\n')
3890     xchars++;
3891
3892   /* XXX - how to reflect bash_input.location.string back to string passed to
3893      parse_and_execute or xparse_dolparen?  xparse_dolparen needs to know how
3894      far into the string we parsed.  parse_and_execute knows where bash_input.
3895      location.string is, and how far from orig_string that is -- that's the
3896      number of characters the command consumed. */
3897
3898   /* bash_input.location.string - xchars should be where we parsed to */
3899   /* need to do more validation on xchars value for sanity -- test cases. */
3900   bash_input.location.string -= xchars;
3901 }
3902
3903 /* **************************************************************** */
3904 /*                                                                  */
3905 /*                   Let input come from STREAM.                    */
3906 /*                                                                  */
3907 /* **************************************************************** */
3908
3909 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
3910    define, and just use getc/ungetc if it was defined, but since bash
3911    installs its signal handlers without the SA_RESTART flag, some signals
3912    (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
3913    the read to be restarted.  We need to restart it ourselves. */
3914
3915 static int
3916 yy_stream_get ()
3917 {
3918   int result;
3919
3920   result = EOF;
3921   if (bash_input.location.file)
3922     {
3923       if (interactive)
3924         {
3925           interrupt_immediately++;
3926           terminate_immediately++;
3927         }
3928       result = getc_with_restart (bash_input.location.file);
3929       if (interactive)
3930         {
3931           interrupt_immediately--;
3932           terminate_immediately--;
3933         }
3934     }
3935   return (result);
3936 }
3937
3938 static int
3939 yy_stream_unget (c)
3940      int c;
3941 {
3942   return (ungetc_with_restart (c, bash_input.location.file));
3943 }
3944
3945 void
3946 with_input_from_stream (stream, name)
3947      FILE *stream;
3948      const char *name;
3949 {
3950   INPUT_STREAM location;
3951
3952   location.file = stream;
3953   init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
3954 }
3955
3956 typedef struct stream_saver {
3957   struct stream_saver *next;
3958   BASH_INPUT bash_input;
3959   int line;
3960 #if defined (BUFFERED_INPUT)
3961   BUFFERED_STREAM *bstream;
3962 #endif /* BUFFERED_INPUT */
3963 } STREAM_SAVER;
3964
3965 /* The globally known line number. */
3966 int line_number = 0;
3967
3968 #if defined (COND_COMMAND)
3969 static int cond_lineno;
3970 static int cond_token;
3971 #endif
3972
3973 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
3974
3975 void
3976 push_stream (reset_lineno)
3977      int reset_lineno;
3978 {
3979   STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
3980
3981   xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
3982
3983 #if defined (BUFFERED_INPUT)
3984   saver->bstream = (BUFFERED_STREAM *)NULL;
3985   /* If we have a buffered stream, clear out buffers[fd]. */
3986   if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
3987     saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
3988                                           (BUFFERED_STREAM *)NULL);
3989 #endif /* BUFFERED_INPUT */
3990
3991   saver->line = line_number;
3992   bash_input.name = (char *)NULL;
3993   saver->next = stream_list;
3994   stream_list = saver;
3995   EOF_Reached = 0;
3996   if (reset_lineno)
3997     line_number = 0;
3998 }
3999
4000 void
4001 pop_stream ()
4002 {
4003   if (!stream_list)
4004     EOF_Reached = 1;
4005   else
4006     {
4007       STREAM_SAVER *saver = stream_list;
4008
4009       EOF_Reached = 0;
4010       stream_list = stream_list->next;
4011
4012       init_yy_io (saver->bash_input.getter,
4013                   saver->bash_input.ungetter,
4014                   saver->bash_input.type,
4015                   saver->bash_input.name,
4016                   saver->bash_input.location);
4017
4018 #if defined (BUFFERED_INPUT)
4019       /* If we have a buffered stream, restore buffers[fd]. */
4020       /* If the input file descriptor was changed while this was on the
4021          save stack, update the buffered fd to the new file descriptor and
4022          re-establish the buffer <-> bash_input fd correspondence. */
4023       if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
4024         {
4025           if (bash_input_fd_changed)
4026             {
4027               bash_input_fd_changed = 0;
4028               if (default_buffered_input >= 0)
4029                 {
4030                   bash_input.location.buffered_fd = default_buffered_input;
4031                   saver->bstream->b_fd = default_buffered_input;
4032                   SET_CLOSE_ON_EXEC (default_buffered_input);
4033                 }
4034             }
4035           /* XXX could free buffered stream returned as result here. */
4036           set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
4037         }
4038 #endif /* BUFFERED_INPUT */
4039
4040       line_number = saver->line;
4041
4042       FREE (saver->bash_input.name);
4043       free (saver);
4044     }
4045 }
4046
4047 /* Return 1 if a stream of type TYPE is saved on the stack. */
4048 int
4049 stream_on_stack (type)
4050      enum stream_type type;
4051 {
4052   register STREAM_SAVER *s;
4053
4054   for (s = stream_list; s; s = s->next)
4055     if (s->bash_input.type == type)
4056       return 1;
4057   return 0;
4058 }
4059
4060 /* Save the current token state and return it in a malloced array. */
4061 int *
4062 save_token_state ()
4063 {
4064   int *ret;
4065
4066   ret = (int *)xmalloc (4 * sizeof (int));
4067   ret[0] = last_read_token;
4068   ret[1] = token_before_that;
4069   ret[2] = two_tokens_ago;
4070   ret[3] = current_token;
4071   return ret;
4072 }
4073
4074 void
4075 restore_token_state (ts)
4076      int *ts;
4077 {
4078   if (ts == 0)
4079     return;
4080   last_read_token = ts[0];
4081   token_before_that = ts[1];
4082   two_tokens_ago = ts[2];
4083   current_token = ts[3];
4084 }
4085
4086 /*
4087  * This is used to inhibit alias expansion and reserved word recognition
4088  * inside case statement pattern lists.  A `case statement pattern list' is:
4089  *
4090  *      everything between the `in' in a `case word in' and the next ')'
4091  *      or `esac'
4092  *      everything between a `;;' and the next `)' or `esac'
4093  */
4094
4095 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
4096
4097 #define END_OF_ALIAS 0
4098
4099 /*
4100  * Pseudo-global variables used in implementing token-wise alias expansion.
4101  */
4102
4103 /*
4104  * Pushing and popping strings.  This works together with shell_getc to
4105  * implement alias expansion on a per-token basis.
4106  */
4107
4108 typedef struct string_saver {
4109   struct string_saver *next;
4110   int expand_alias;  /* Value to set expand_alias to when string is popped. */
4111   char *saved_line;
4112 #if defined (ALIAS)
4113   alias_t *expander;   /* alias that caused this line to be pushed. */
4114 #endif
4115   int saved_line_size, saved_line_index, saved_line_terminator;
4116 } STRING_SAVER;
4117
4118 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
4119
4120 /*
4121  * Push the current shell_input_line onto a stack of such lines and make S
4122  * the current input.  Used when expanding aliases.  EXPAND is used to set
4123  * the value of expand_next_token when the string is popped, so that the
4124  * word after the alias in the original line is handled correctly when the
4125  * alias expands to multiple words.  TOKEN is the token that was expanded
4126  * into S; it is saved and used to prevent infinite recursive expansion.
4127  */
4128 static void
4129 push_string (s, expand, ap)
4130      char *s;
4131      int expand;
4132      alias_t *ap;
4133 {
4134   STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
4135
4136   temp->expand_alias = expand;
4137   temp->saved_line = shell_input_line;
4138   temp->saved_line_size = shell_input_line_size;
4139   temp->saved_line_index = shell_input_line_index;
4140   temp->saved_line_terminator = shell_input_line_terminator;
4141 #if defined (ALIAS)
4142   temp->expander = ap;
4143 #endif
4144   temp->next = pushed_string_list;
4145   pushed_string_list = temp;
4146
4147 #if defined (ALIAS)
4148   if (ap)
4149     ap->flags |= AL_BEINGEXPANDED;
4150 #endif
4151
4152   shell_input_line = s;
4153   shell_input_line_size = strlen (s);
4154   shell_input_line_index = 0;
4155   shell_input_line_terminator = '\0';
4156 #if 0
4157   parser_state &= ~PST_ALEXPNEXT;       /* XXX */
4158 #endif
4159
4160   set_line_mbstate ();
4161 }
4162
4163 /*
4164  * Make the top of the pushed_string stack be the current shell input.
4165  * Only called when there is something on the stack.  Called from shell_getc
4166  * when it thinks it has consumed the string generated by an alias expansion
4167  * and needs to return to the original input line.
4168  */
4169 static void
4170 pop_string ()
4171 {
4172   STRING_SAVER *t;
4173
4174   FREE (shell_input_line);
4175   shell_input_line = pushed_string_list->saved_line;
4176   shell_input_line_index = pushed_string_list->saved_line_index;
4177   shell_input_line_size = pushed_string_list->saved_line_size;
4178   shell_input_line_terminator = pushed_string_list->saved_line_terminator;
4179
4180   if (pushed_string_list->expand_alias)
4181     parser_state |= PST_ALEXPNEXT;
4182   else
4183     parser_state &= ~PST_ALEXPNEXT;
4184
4185   t = pushed_string_list;
4186   pushed_string_list = pushed_string_list->next;
4187
4188 #if defined (ALIAS)
4189   if (t->expander)
4190     t->expander->flags &= ~AL_BEINGEXPANDED;
4191 #endif
4192
4193   free ((char *)t);
4194
4195   set_line_mbstate ();
4196 }
4197
4198 static void
4199 free_string_list ()
4200 {
4201   register STRING_SAVER *t, *t1;
4202
4203   for (t = pushed_string_list; t; )
4204     {
4205       t1 = t->next;
4206       FREE (t->saved_line);
4207 #if defined (ALIAS)
4208       if (t->expander)
4209         t->expander->flags &= ~AL_BEINGEXPANDED;
4210 #endif
4211       free ((char *)t);
4212       t = t1;
4213     }
4214   pushed_string_list = (STRING_SAVER *)NULL;
4215 }
4216
4217 #endif /* ALIAS || DPAREN_ARITHMETIC */
4218
4219 void
4220 free_pushed_string_input ()
4221 {
4222 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
4223   free_string_list ();
4224 #endif
4225 }
4226
4227 /* Return a line of text, taken from wherever yylex () reads input.
4228    If there is no more input, then we return NULL.  If REMOVE_QUOTED_NEWLINE
4229    is non-zero, we remove unquoted \<newline> pairs.  This is used by
4230    read_secondary_line to read here documents. */
4231 static char *
4232 read_a_line (remove_quoted_newline)
4233      int remove_quoted_newline;
4234 {
4235   static char *line_buffer = (char *)NULL;
4236   static int buffer_size = 0;
4237   int indx, c, peekc, pass_next;
4238
4239 #if defined (READLINE)
4240   if (no_line_editing && SHOULD_PROMPT ())
4241 #else
4242   if (SHOULD_PROMPT ())
4243 #endif
4244     print_prompt ();
4245
4246   pass_next = indx = 0;
4247   while (1)
4248     {
4249       /* Allow immediate exit if interrupted during input. */
4250       QUIT;
4251
4252       c = yy_getc ();
4253
4254       /* Ignore null bytes in input. */
4255       if (c == 0)
4256         {
4257 #if 0
4258           internal_warning ("read_a_line: ignored null byte in input");
4259 #endif
4260           continue;
4261         }
4262
4263       /* If there is no more input, then we return NULL. */
4264       if (c == EOF)
4265         {
4266           if (interactive && bash_input.type == st_stream)
4267             clearerr (stdin);
4268           if (indx == 0)
4269             return ((char *)NULL);
4270           c = '\n';
4271         }
4272
4273       /* `+2' in case the final character in the buffer is a newline. */
4274       RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
4275
4276       /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
4277          here document with an unquoted delimiter.  In this case,
4278          the line will be expanded as if it were in double quotes.
4279          We allow a backslash to escape the next character, but we
4280          need to treat the backslash specially only if a backslash
4281          quoting a backslash-newline pair appears in the line. */
4282       if (pass_next)
4283         {
4284           line_buffer[indx++] = c;
4285           pass_next = 0;
4286         }
4287       else if (c == '\\' && remove_quoted_newline)
4288         {
4289           peekc = yy_getc ();
4290           if (peekc == '\n')
4291             {
4292               line_number++;
4293               continue; /* Make the unquoted \<newline> pair disappear. */
4294             }
4295           else
4296             {
4297               yy_ungetc (peekc);
4298               pass_next = 1;
4299               line_buffer[indx++] = c;          /* Preserve the backslash. */
4300             }
4301         }
4302       else
4303         line_buffer[indx++] = c;
4304
4305       if (c == '\n')
4306         {
4307           line_buffer[indx] = '\0';
4308           return (line_buffer);
4309         }
4310     }
4311 }
4312
4313 /* Return a line as in read_a_line (), but insure that the prompt is
4314    the secondary prompt.  This is used to read the lines of a here
4315    document.  REMOVE_QUOTED_NEWLINE is non-zero if we should remove
4316    newlines quoted with backslashes while reading the line.  It is
4317    non-zero unless the delimiter of the here document was quoted. */
4318 char *
4319 read_secondary_line (remove_quoted_newline)
4320      int remove_quoted_newline;
4321 {
4322   char *ret;
4323   int n, c;
4324
4325   prompt_string_pointer = &ps2_prompt;
4326   if (SHOULD_PROMPT())
4327     prompt_again ();
4328   ret = read_a_line (remove_quoted_newline);
4329 #if defined (HISTORY)
4330   if (ret && remember_on_history && (parser_state & PST_HEREDOC))
4331     {
4332       /* To make adding the the here-document body right, we need to rely
4333          on history_delimiting_chars() returning \n for the first line of
4334          the here-document body and the null string for the second and
4335          subsequent lines, so we avoid double newlines.
4336          current_command_line_count == 2 for the first line of the body. */
4337
4338       current_command_line_count++;
4339       maybe_add_history (ret);
4340     }
4341 #endif /* HISTORY */
4342   return ret;
4343 }
4344
4345 /* **************************************************************** */
4346 /*                                                                  */
4347 /*                              YYLEX ()                            */
4348 /*                                                                  */
4349 /* **************************************************************** */
4350
4351 /* Reserved words.  These are only recognized as the first word of a
4352    command. */
4353 STRING_INT_ALIST word_token_alist[] = {
4354   { "if", IF },
4355   { "then", THEN },
4356   { "else", ELSE },
4357   { "elif", ELIF },
4358   { "fi", FI },
4359   { "case", CASE },
4360   { "esac", ESAC },
4361   { "for", FOR },
4362 #if defined (SELECT_COMMAND)
4363   { "select", SELECT },
4364 #endif
4365   { "while", WHILE },
4366   { "until", UNTIL },
4367   { "do", DO },
4368   { "done", DONE },
4369   { "in", IN },
4370   { "function", FUNCTION },
4371 #if defined (COMMAND_TIMING)
4372   { "time", TIME },
4373 #endif
4374   { "{", '{' },
4375   { "}", '}' },
4376   { "!", BANG },
4377 #if defined (COND_COMMAND)
4378   { "[[", COND_START },
4379   { "]]", COND_END },
4380 #endif
4381 #if defined (COPROCESS_SUPPORT)
4382   { "coproc", COPROC },
4383 #endif
4384   { (char *)NULL, 0}
4385 };
4386
4387 /* other tokens that can be returned by read_token() */
4388 STRING_INT_ALIST other_token_alist[] = {
4389   /* Multiple-character tokens with special values */
4390   { "-p", TIMEOPT },
4391   { "&&", AND_AND },
4392   { "||", OR_OR },
4393   { ">>", GREATER_GREATER },
4394   { "<<", LESS_LESS },
4395   { "<&", LESS_AND },
4396   { ">&", GREATER_AND },
4397   { ";;", SEMI_SEMI },
4398   { ";&", SEMI_AND },
4399   { ";;&", SEMI_SEMI_AND },
4400   { "<<-", LESS_LESS_MINUS },
4401   { "<<<", LESS_LESS_LESS },
4402   { "&>", AND_GREATER },
4403   { "&>>", AND_GREATER_GREATER },
4404   { "<>", LESS_GREATER },
4405   { ">|", GREATER_BAR },
4406   { "|&", BAR_AND },
4407   { "EOF", yacc_EOF },
4408   /* Tokens whose value is the character itself */
4409   { ">", '>' },
4410   { "<", '<' },
4411   { "-", '-' },
4412   { "{", '{' },
4413   { "}", '}' },
4414   { ";", ';' },
4415   { "(", '(' },
4416   { ")", ')' },
4417   { "|", '|' },
4418   { "&", '&' },
4419   { "newline", '\n' },
4420   { (char *)NULL, 0}
4421 };
4422
4423 /* others not listed here:
4424         WORD                    look at yylval.word
4425         ASSIGNMENT_WORD         look at yylval.word
4426         NUMBER                  look at yylval.number
4427         ARITH_CMD               look at yylval.word_list
4428         ARITH_FOR_EXPRS         look at yylval.word_list
4429         COND_CMD                look at yylval.command
4430 */
4431
4432 /* These are used by read_token_word, but appear up here so that shell_getc
4433    can use them to decide when to add otherwise blank lines to the history. */
4434
4435 /* The primary delimiter stack. */
4436 struct dstack dstack = {  (char *)NULL, 0, 0 };
4437
4438 /* A temporary delimiter stack to be used when decoding prompt strings.
4439    This is needed because command substitutions in prompt strings (e.g., PS2)
4440    can screw up the parser's quoting state. */
4441 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
4442
4443 /* Macro for accessing the top delimiter on the stack.  Returns the
4444    delimiter or zero if none. */
4445 #define current_delimiter(ds) \
4446   (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
4447
4448 #define push_delimiter(ds, character) \
4449   do \
4450     { \
4451       if (ds.delimiter_depth + 2 > ds.delimiter_space) \
4452         ds.delimiters = (char *)xrealloc \
4453           (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
4454       ds.delimiters[ds.delimiter_depth] = character; \
4455       ds.delimiter_depth++; \
4456     } \
4457   while (0)
4458
4459 #define pop_delimiter(ds)       ds.delimiter_depth--
4460
4461 /* Return the next shell input character.  This always reads characters
4462    from shell_input_line; when that line is exhausted, it is time to
4463    read the next line.  This is called by read_token when the shell is
4464    processing normal command input. */
4465
4466 /* This implements one-character lookahead/lookbehind across physical input
4467    lines, to avoid something being lost because it's pushed back with
4468    shell_ungetc when we're at the start of a line. */
4469 static int eol_ungetc_lookahead = 0;
4470
4471 static int
4472 shell_getc (remove_quoted_newline)
4473      int remove_quoted_newline;
4474 {
4475   register int i;
4476   int c;
4477   unsigned char uc;
4478
4479   QUIT;
4480
4481   if (sigwinch_received)
4482     {
4483       sigwinch_received = 0;
4484       get_new_window_size (0, (int *)0, (int *)0);
4485     }
4486
4487   if (eol_ungetc_lookahead)
4488     {
4489       c = eol_ungetc_lookahead;
4490       eol_ungetc_lookahead = 0;
4491       return (c);
4492     }
4493
4494 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
4495   /* If shell_input_line[shell_input_line_index] == 0, but there is
4496      something on the pushed list of strings, then we don't want to go
4497      off and get another line.  We let the code down below handle it. */
4498
4499   if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
4500                             (pushed_string_list == (STRING_SAVER *)NULL)))
4501 #else /* !ALIAS && !DPAREN_ARITHMETIC */
4502   if (!shell_input_line || !shell_input_line[shell_input_line_index])
4503 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
4504     {
4505       line_number++;
4506
4507     restart_read:
4508
4509       /* Allow immediate exit if interrupted during input. */
4510       QUIT;
4511
4512       i = 0;
4513       shell_input_line_terminator = 0;
4514
4515       /* If the shell is interatctive, but not currently printing a prompt
4516          (interactive_shell && interactive == 0), we don't want to print
4517          notifies or cleanup the jobs -- we want to defer it until we do
4518          print the next prompt. */
4519       if (interactive_shell == 0 || SHOULD_PROMPT())
4520         {
4521 #if defined (JOB_CONTROL)
4522       /* This can cause a problem when reading a command as the result
4523          of a trap, when the trap is called from flush_child.  This call
4524          had better not cause jobs to disappear from the job table in
4525          that case, or we will have big trouble. */
4526           notify_and_cleanup ();
4527 #else /* !JOB_CONTROL */
4528           cleanup_dead_jobs ();
4529 #endif /* !JOB_CONTROL */
4530         }
4531
4532 #if defined (READLINE)
4533       if (no_line_editing && SHOULD_PROMPT())
4534 #else
4535       if (SHOULD_PROMPT())
4536 #endif
4537         print_prompt ();
4538
4539       if (bash_input.type == st_stream)
4540         clearerr (stdin);
4541
4542       while (1)
4543         {
4544           c = yy_getc ();
4545
4546           /* Allow immediate exit if interrupted during input. */
4547           QUIT;
4548
4549           if (c == '\0')
4550             {
4551 #if 0
4552               internal_warning ("shell_getc: ignored null byte in input");
4553 #endif
4554               continue;
4555             }
4556
4557           RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
4558
4559           if (c == EOF)
4560             {
4561               if (bash_input.type == st_stream)
4562                 clearerr (stdin);
4563
4564               if (i == 0)
4565                 shell_input_line_terminator = EOF;
4566
4567               shell_input_line[i] = '\0';
4568               break;
4569             }
4570
4571           shell_input_line[i++] = c;
4572
4573           if (c == '\n')
4574             {
4575               shell_input_line[--i] = '\0';
4576               current_command_line_count++;
4577               break;
4578             }
4579         }
4580
4581       shell_input_line_index = 0;
4582       shell_input_line_len = i;         /* == strlen (shell_input_line) */
4583
4584       set_line_mbstate ();
4585
4586 #if defined (HISTORY)
4587       if (remember_on_history && shell_input_line && shell_input_line[0])
4588         {
4589           char *expansions;
4590 #  if defined (BANG_HISTORY)
4591           int old_hist;
4592
4593           /* If the current delimiter is a single quote, we should not be
4594              performing history expansion, even if we're on a different
4595              line from the original single quote. */
4596           old_hist = history_expansion_inhibited;
4597           if (current_delimiter (dstack) == '\'')
4598             history_expansion_inhibited = 1;
4599 #  endif
4600           expansions = pre_process_line (shell_input_line, 1, 1);
4601 #  if defined (BANG_HISTORY)
4602           history_expansion_inhibited = old_hist;
4603 #  endif
4604           if (expansions != shell_input_line)
4605             {
4606               free (shell_input_line);
4607               shell_input_line = expansions;
4608               shell_input_line_len = shell_input_line ?
4609                                         strlen (shell_input_line) : 0;
4610               if (!shell_input_line_len)
4611                 current_command_line_count--;
4612
4613               /* We have to force the xrealloc below because we don't know
4614                  the true allocated size of shell_input_line anymore. */
4615               shell_input_line_size = shell_input_line_len;
4616
4617               set_line_mbstate ();
4618             }
4619         }
4620       /* Try to do something intelligent with blank lines encountered while
4621          entering multi-line commands.  XXX - this is grotesque */
4622       else if (remember_on_history && shell_input_line &&
4623                shell_input_line[0] == '\0' &&
4624                current_command_line_count > 1)
4625         {
4626           if (current_delimiter (dstack))
4627             /* We know shell_input_line[0] == 0 and we're reading some sort of
4628                quoted string.  This means we've got a line consisting of only
4629                a newline in a quoted string.  We want to make sure this line
4630                gets added to the history. */
4631             maybe_add_history (shell_input_line);
4632           else
4633             {
4634               char *hdcs;
4635               hdcs = history_delimiting_chars ();
4636               if (hdcs && hdcs[0] == ';')
4637                 maybe_add_history (shell_input_line);
4638             }
4639         }
4640
4641 #endif /* HISTORY */
4642
4643       if (shell_input_line)
4644         {
4645           /* Lines that signify the end of the shell's input should not be
4646              echoed. */
4647           if (echo_input_at_read && (shell_input_line[0] ||
4648                                      shell_input_line_terminator != EOF))
4649             fprintf (stderr, "%s\n", shell_input_line);
4650         }
4651       else
4652         {
4653           shell_input_line_size = 0;
4654           prompt_string_pointer = &current_prompt_string;
4655           if (SHOULD_PROMPT ())
4656             prompt_again ();
4657           goto restart_read;
4658         }
4659
4660       /* Add the newline to the end of this string, iff the string does
4661          not already end in an EOF character.  */
4662       if (shell_input_line_terminator != EOF)
4663         {
4664           if (shell_input_line_len + 3 > shell_input_line_size)
4665             shell_input_line = (char *)xrealloc (shell_input_line,
4666                                         1 + (shell_input_line_size += 2));
4667
4668           shell_input_line[shell_input_line_len] = '\n';
4669           shell_input_line[shell_input_line_len + 1] = '\0';
4670
4671           set_line_mbstate ();
4672         }
4673     }
4674
4675   uc = shell_input_line[shell_input_line_index];
4676
4677   if (uc)
4678     shell_input_line_index++;
4679
4680 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
4681   /* If UC is NULL, we have reached the end of the current input string.  If
4682      pushed_string_list is non-empty, it's time to pop to the previous string
4683      because we have fully consumed the result of the last alias expansion.
4684      Do it transparently; just return the next character of the string popped
4685      to. */
4686 pop_alias:
4687   if (!uc && (pushed_string_list != (STRING_SAVER *)NULL))
4688     {
4689       pop_string ();
4690       uc = shell_input_line[shell_input_line_index];
4691       if (uc)
4692         shell_input_line_index++;
4693     }
4694 #endif /* ALIAS || DPAREN_ARITHMETIC */
4695
4696   if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
4697     {
4698         if (SHOULD_PROMPT ())
4699           prompt_again ();
4700         line_number++;
4701         /* XXX - what do we do here if we're expanding an alias whose definition
4702            ends with a newline?  Recall that we inhibit the appending of a
4703            space in mk_alexpansion() if newline is the last character. */
4704 #if 0   /* XXX - bash-4.2 (jonathan@claggett.org) */
4705         if (expanding_alias () && shell_input_line[shell_input_line_index+1] == '\0')
4706           {
4707             uc = 0;
4708             goto pop_alias;
4709           }
4710 #endif
4711
4712         goto restart_read;
4713     }
4714
4715   if (!uc && shell_input_line_terminator == EOF)
4716     return ((shell_input_line_index != 0) ? '\n' : EOF);
4717
4718   return (uc);
4719 }
4720
4721 /* Put C back into the input for the shell.  This might need changes for
4722    HANDLE_MULTIBYTE around EOLs.  Since we (currently) never push back a
4723    character different than we read, shell_input_line_property doesn't need
4724    to change when manipulating shell_input_line.  The define for
4725    last_shell_getc_is_singlebyte should take care of it, though. */
4726 static void
4727 shell_ungetc (c)
4728      int c;
4729 {
4730   if (shell_input_line && shell_input_line_index)
4731     shell_input_line[--shell_input_line_index] = c;
4732   else
4733     eol_ungetc_lookahead = c;
4734 }
4735
4736 #ifdef INCLUDE_UNUSED
4737 /* Back the input pointer up by one, effectively `ungetting' a character. */
4738 static void
4739 shell_ungetchar ()
4740 {
4741   if (shell_input_line && shell_input_line_index)
4742     shell_input_line_index--;
4743 }
4744 #endif
4745
4746 /* Discard input until CHARACTER is seen, then push that character back
4747    onto the input stream. */
4748 static void
4749 discard_until (character)
4750      int character;
4751 {
4752   int c;
4753
4754   while ((c = shell_getc (0)) != EOF && c != character)
4755     ;
4756
4757   if (c != EOF)
4758     shell_ungetc (c);
4759 }
4760
4761 void
4762 execute_variable_command (command, vname)
4763      char *command, *vname;
4764 {
4765   char *last_lastarg;
4766   sh_parser_state_t ps;
4767
4768   save_parser_state (&ps);
4769   last_lastarg = get_string_value ("_");
4770   if (last_lastarg)
4771     last_lastarg = savestring (last_lastarg);
4772
4773   parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
4774
4775   restore_parser_state (&ps);
4776   bind_variable ("_", last_lastarg, 0);
4777   FREE (last_lastarg);
4778
4779   if (token_to_read == '\n')    /* reset_parser was called */
4780     token_to_read = 0;
4781 }
4782
4783 /* Place to remember the token.  We try to keep the buffer
4784    at a reasonable size, but it can grow. */
4785 static char *token = (char *)NULL;
4786
4787 /* Current size of the token buffer. */
4788 static int token_buffer_size;
4789
4790 /* Command to read_token () explaining what we want it to do. */
4791 #define READ 0
4792 #define RESET 1
4793 #define prompt_is_ps1 \
4794       (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
4795
4796 /* Function for yyparse to call.  yylex keeps track of
4797    the last two tokens read, and calls read_token.  */
4798 static int
4799 yylex ()
4800 {
4801   if (interactive && (current_token == 0 || current_token == '\n'))
4802     {
4803       /* Before we print a prompt, we might have to check mailboxes.
4804          We do this only if it is time to do so. Notice that only here
4805          is the mail alarm reset; nothing takes place in check_mail ()
4806          except the checking of mail.  Please don't change this. */
4807       if (prompt_is_ps1 && time_to_check_mail ())
4808         {
4809           check_mail ();
4810           reset_mail_timer ();
4811         }
4812
4813       /* Avoid printing a prompt if we're not going to read anything, e.g.
4814          after resetting the parser with read_token (RESET). */
4815       if (token_to_read == 0 && SHOULD_PROMPT ())
4816         prompt_again ();
4817     }
4818
4819   two_tokens_ago = token_before_that;
4820   token_before_that = last_read_token;
4821   last_read_token = current_token;
4822   current_token = read_token (READ);
4823
4824   if ((parser_state & PST_EOFTOKEN) && current_token == shell_eof_token)
4825     {
4826       current_token = yacc_EOF;
4827       if (bash_input.type == st_string)
4828         rewind_input_string ();
4829     }
4830   parser_state &= ~PST_EOFTOKEN;
4831
4832   return (current_token);
4833 }
4834
4835 /* When non-zero, we have read the required tokens
4836    which allow ESAC to be the next one read. */
4837 static int esacs_needed_count;
4838
4839 void
4840 gather_here_documents ()
4841 {
4842   int r;
4843
4844   r = 0;
4845   while (need_here_doc)
4846     {
4847       parser_state |= PST_HEREDOC;
4848       make_here_document (redir_stack[r++], line_number);
4849       parser_state &= ~PST_HEREDOC;
4850       need_here_doc--;
4851     }
4852 }
4853
4854 /* When non-zero, an open-brace used to create a group is awaiting a close
4855    brace partner. */
4856 static int open_brace_count;
4857
4858 #define command_token_position(token) \
4859   (((token) == ASSIGNMENT_WORD) || (parser_state&PST_REDIRLIST) || \
4860    ((token) != SEMI_SEMI && (token) != SEMI_AND && (token) != SEMI_SEMI_AND && reserved_word_acceptable(token)))
4861
4862 #define assignment_acceptable(token) \
4863   (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
4864
4865 /* Check to see if TOKEN is a reserved word and return the token
4866    value if it is. */
4867 #define CHECK_FOR_RESERVED_WORD(tok) \
4868   do { \
4869     if (!dollar_present && !quoted && \
4870         reserved_word_acceptable (last_read_token)) \
4871       { \
4872         int i; \
4873         for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
4874           if (STREQ (tok, word_token_alist[i].word)) \
4875             { \
4876               if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
4877                 break; \
4878               if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
4879                 break; \
4880               if (word_token_alist[i].token == ESAC) \
4881                 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
4882               else if (word_token_alist[i].token == CASE) \
4883                 parser_state |= PST_CASESTMT; \
4884               else if (word_token_alist[i].token == COND_END) \
4885                 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
4886               else if (word_token_alist[i].token == COND_START) \
4887                 parser_state |= PST_CONDCMD; \
4888               else if (word_token_alist[i].token == '{') \
4889                 open_brace_count++; \
4890               else if (word_token_alist[i].token == '}' && open_brace_count) \
4891                 open_brace_count--; \
4892               return (word_token_alist[i].token); \
4893             } \
4894       } \
4895   } while (0)
4896
4897 #if defined (ALIAS)
4898
4899     /* OK, we have a token.  Let's try to alias expand it, if (and only if)
4900        it's eligible.
4901
4902        It is eligible for expansion if EXPAND_ALIASES is set, and
4903        the token is unquoted and the last token read was a command
4904        separator (or expand_next_token is set), and we are currently
4905        processing an alias (pushed_string_list is non-empty) and this
4906        token is not the same as the current or any previously
4907        processed alias.
4908
4909        Special cases that disqualify:
4910          In a pattern list in a case statement (parser_state & PST_CASEPAT). */
4911
4912 static char *
4913 mk_alexpansion (s)
4914      char *s;
4915 {
4916   int l;
4917   char *r;
4918
4919   l = strlen (s);
4920   r = xmalloc (l + 2);
4921   strcpy (r, s);
4922 #if 0           /* XXX - bash-4.2 */
4923   if (r[l -1] != ' ' && r[l -1] != '\n')
4924 #else
4925   if (r[l -1] != ' ')
4926 #endif
4927     r[l++] = ' ';
4928   r[l] = '\0';
4929   return r;
4930 }
4931
4932 static int
4933 alias_expand_token (tokstr)
4934      char *tokstr;
4935 {
4936   char *expanded;
4937   alias_t *ap;
4938
4939   if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
4940         (parser_state & PST_CASEPAT) == 0)
4941     {
4942       ap = find_alias (tokstr);
4943
4944       /* Currently expanding this token. */
4945       if (ap && (ap->flags & AL_BEINGEXPANDED))
4946         return (NO_EXPANSION);
4947
4948       /* mk_alexpansion puts an extra space on the end of the alias expansion,
4949          so the lookahead by the parser works right.  If this gets changed,
4950          make sure the code in shell_getc that deals with reaching the end of
4951          an expanded alias is changed with it. */
4952       expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
4953
4954       if (expanded)
4955         {
4956           push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
4957           return (RE_READ_TOKEN);
4958         }
4959       else
4960         /* This is an eligible token that does not have an expansion. */
4961         return (NO_EXPANSION);
4962     }
4963   return (NO_EXPANSION);
4964 }
4965 #endif /* ALIAS */
4966
4967 static int
4968 time_command_acceptable ()
4969 {
4970 #if defined (COMMAND_TIMING)
4971   switch (last_read_token)
4972     {
4973     case 0:
4974     case ';':
4975     case '\n':
4976     case AND_AND:
4977     case OR_OR:
4978     case '&':
4979     case DO:
4980     case THEN:
4981     case ELSE:
4982     case '{':           /* } */
4983     case '(':           /* ) */
4984       return 1;
4985     default:
4986       return 0;
4987     }
4988 #else
4989   return 0;
4990 #endif /* COMMAND_TIMING */
4991 }
4992
4993 /* Handle special cases of token recognition:
4994         IN is recognized if the last token was WORD and the token
4995         before that was FOR or CASE or SELECT.
4996
4997         DO is recognized if the last token was WORD and the token
4998         before that was FOR or SELECT.
4999
5000         ESAC is recognized if the last token caused `esacs_needed_count'
5001         to be set
5002
5003         `{' is recognized if the last token as WORD and the token
5004         before that was FUNCTION, or if we just parsed an arithmetic
5005         `for' command.
5006
5007         `}' is recognized if there is an unclosed `{' present.
5008
5009         `-p' is returned as TIMEOPT if the last read token was TIME.
5010
5011         ']]' is returned as COND_END if the parser is currently parsing
5012         a conditional expression ((parser_state & PST_CONDEXPR) != 0)
5013
5014         `time' is returned as TIME if and only if it is immediately
5015         preceded by one of `;', `\n', `||', `&&', or `&'.
5016 */
5017
5018 static int
5019 special_case_tokens (tokstr)
5020      char *tokstr;
5021 {
5022   if ((last_read_token == WORD) &&
5023 #if defined (SELECT_COMMAND)
5024       ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
5025 #else
5026       ((token_before_that == FOR) || (token_before_that == CASE)) &&
5027 #endif
5028       (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
5029     {
5030       if (token_before_that == CASE)
5031         {
5032           parser_state |= PST_CASEPAT;
5033           esacs_needed_count++;
5034         }
5035       return (IN);
5036     }
5037
5038   if (last_read_token == WORD &&
5039 #if defined (SELECT_COMMAND)
5040       (token_before_that == FOR || token_before_that == SELECT) &&
5041 #else
5042       (token_before_that == FOR) &&
5043 #endif
5044       (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
5045     return (DO);
5046
5047   /* Ditto for ESAC in the CASE case.
5048      Specifically, this handles "case word in esac", which is a legal
5049      construct, certainly because someone will pass an empty arg to the
5050      case construct, and we don't want it to barf.  Of course, we should
5051      insist that the case construct has at least one pattern in it, but
5052      the designers disagree. */
5053   if (esacs_needed_count)
5054     {
5055       esacs_needed_count--;
5056       if (STREQ (tokstr, "esac"))
5057         {
5058           parser_state &= ~PST_CASEPAT;
5059           return (ESAC);
5060         }
5061     }
5062
5063   /* The start of a shell function definition. */
5064   if (parser_state & PST_ALLOWOPNBRC)
5065     {
5066       parser_state &= ~PST_ALLOWOPNBRC;
5067       if (tokstr[0] == '{' && tokstr[1] == '\0')                /* } */
5068         {
5069           open_brace_count++;
5070           function_bstart = line_number;
5071           return ('{');                                 /* } */
5072         }
5073     }
5074
5075   /* We allow a `do' after a for ((...)) without an intervening
5076      list_terminator */
5077   if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
5078     return (DO);
5079   if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0')      /* } */
5080     {
5081       open_brace_count++;
5082       return ('{');                     /* } */
5083     }
5084
5085   if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
5086     {
5087       open_brace_count--;               /* { */
5088       return ('}');
5089     }
5090
5091 #if defined (COMMAND_TIMING)
5092   /* Handle -p after `time'. */
5093   if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
5094     return (TIMEOPT);
5095 #endif
5096
5097 #if 0
5098 #if defined (COMMAND_TIMING)
5099   if (STREQ (token, "time") && ((parser_state & PST_CASEPAT) == 0) && time_command_acceptable ())
5100     return (TIME);
5101 #endif /* COMMAND_TIMING */
5102 #endif
5103
5104 #if defined (COND_COMMAND) /* [[ */
5105   if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
5106     return (COND_END);
5107 #endif
5108
5109   return (-1);
5110 }
5111
5112 /* Called from shell.c when Control-C is typed at top level.  Or
5113    by the error rule at top level. */
5114 void
5115 reset_parser ()
5116 {
5117   dstack.delimiter_depth = 0;   /* No delimiters found so far. */
5118   open_brace_count = 0;
5119
5120 #if defined (EXTENDED_GLOB)
5121   /* Reset to global value of extended glob */
5122   if (parser_state & PST_EXTPAT)
5123     extended_glob = global_extglob;
5124 #endif
5125
5126   parser_state = 0;
5127
5128 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
5129   if (pushed_string_list)
5130     free_string_list ();
5131 #endif /* ALIAS || DPAREN_ARITHMETIC */
5132
5133   if (shell_input_line)
5134     {
5135       free (shell_input_line);
5136       shell_input_line = (char *)NULL;
5137       shell_input_line_size = shell_input_line_index = 0;
5138     }
5139
5140   FREE (word_desc_to_read);
5141   word_desc_to_read = (WORD_DESC *)NULL;
5142
5143   current_token = '\n';         /* XXX */
5144   last_read_token = '\n';
5145   token_to_read = '\n';
5146 }
5147
5148 /* Read the next token.  Command can be READ (normal operation) or
5149    RESET (to normalize state). */
5150 static int
5151 read_token (command)
5152      int command;
5153 {
5154   int character;                /* Current character. */
5155   int peek_char;                /* Temporary look-ahead character. */
5156   int result;                   /* The thing to return. */
5157
5158   if (command == RESET)
5159     {
5160       reset_parser ();
5161       return ('\n');
5162     }
5163
5164   if (token_to_read)
5165     {
5166       result = token_to_read;
5167       if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
5168         {
5169           yylval.word = word_desc_to_read;
5170           word_desc_to_read = (WORD_DESC *)NULL;
5171         }
5172       token_to_read = 0;
5173       return (result);
5174     }
5175
5176 #if defined (COND_COMMAND)
5177   if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
5178     {
5179       cond_lineno = line_number;
5180       parser_state |= PST_CONDEXPR;
5181       yylval.command = parse_cond_command ();
5182       if (cond_token != COND_END)
5183         {
5184           cond_error ();
5185           return (-1);
5186         }
5187       token_to_read = COND_END;
5188       parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
5189       return (COND_CMD);
5190     }
5191 #endif
5192
5193 #if defined (ALIAS)
5194   /* This is a place to jump back to once we have successfully expanded a
5195      token with an alias and pushed the string with push_string () */
5196  re_read_token:
5197 #endif /* ALIAS */
5198
5199   /* Read a single word from input.  Start by skipping blanks. */
5200   while ((character = shell_getc (1)) != EOF && shellblank (character))
5201     ;
5202
5203   if (character == EOF)
5204     {
5205       EOF_Reached = 1;
5206       return (yacc_EOF);
5207     }
5208
5209   if MBTEST(character == '#' && (!interactive || interactive_comments))
5210     {
5211       /* A comment.  Discard until EOL or EOF, and then return a newline. */
5212       discard_until ('\n');
5213       shell_getc (0);
5214       character = '\n'; /* this will take the next if statement and return. */
5215     }
5216
5217   if (character == '\n')
5218     {
5219       /* If we're about to return an unquoted newline, we can go and collect
5220          the text of any pending here document. */
5221       if (need_here_doc)
5222         gather_here_documents ();
5223
5224 #if defined (ALIAS)
5225       parser_state &= ~PST_ALEXPNEXT;
5226 #endif /* ALIAS */
5227
5228       parser_state &= ~PST_ASSIGNOK;
5229
5230       return (character);
5231     }
5232
5233   if (parser_state & PST_REGEXP)
5234     goto tokword;
5235
5236   /* Shell meta-characters. */
5237   if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
5238     {
5239 #if defined (ALIAS)
5240       /* Turn off alias tokenization iff this character sequence would
5241          not leave us ready to read a command. */
5242       if (character == '<' || character == '>')
5243         parser_state &= ~PST_ALEXPNEXT;
5244 #endif /* ALIAS */
5245
5246       parser_state &= ~PST_ASSIGNOK;
5247
5248       peek_char = shell_getc (1);
5249       if (character == peek_char)
5250         {
5251           switch (character)
5252             {
5253             case '<':
5254               /* If '<' then we could be at "<<" or at "<<-".  We have to
5255                  look ahead one more character. */
5256               peek_char = shell_getc (1);
5257               if MBTEST(peek_char == '-')
5258                 return (LESS_LESS_MINUS);
5259               else if MBTEST(peek_char == '<')
5260                 return (LESS_LESS_LESS);
5261               else
5262                 {
5263                   shell_ungetc (peek_char);
5264                   return (LESS_LESS);
5265                 }
5266
5267             case '>':
5268               return (GREATER_GREATER);
5269
5270             case ';':
5271               parser_state |= PST_CASEPAT;
5272 #if defined (ALIAS)
5273               parser_state &= ~PST_ALEXPNEXT;
5274 #endif /* ALIAS */
5275
5276               peek_char = shell_getc (1);
5277               if MBTEST(peek_char == '&')
5278                 return (SEMI_SEMI_AND);
5279               else
5280                 {
5281                   shell_ungetc (peek_char);
5282                   return (SEMI_SEMI);
5283                 }
5284
5285             case '&':
5286               return (AND_AND);
5287
5288             case '|':
5289               return (OR_OR);
5290
5291 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
5292             case '(':           /* ) */
5293               result = parse_dparen (character);
5294               if (result == -2)
5295                 break;
5296               else
5297                 return result;
5298 #endif
5299             }
5300         }
5301       else if MBTEST(character == '<' && peek_char == '&')
5302         return (LESS_AND);
5303       else if MBTEST(character == '>' && peek_char == '&')
5304         return (GREATER_AND);
5305       else if MBTEST(character == '<' && peek_char == '>')
5306         return (LESS_GREATER);
5307       else if MBTEST(character == '>' && peek_char == '|')
5308         return (GREATER_BAR);
5309       else if MBTEST(character == '&' && peek_char == '>')
5310         {
5311           peek_char = shell_getc (1);
5312           if MBTEST(peek_char == '>')
5313             return (AND_GREATER_GREATER);
5314           else
5315             {
5316               shell_ungetc (peek_char);
5317               return (AND_GREATER);
5318             }
5319         }
5320       else if MBTEST(character == '|' && peek_char == '&')
5321         return (BAR_AND);
5322       else if MBTEST(character == ';' && peek_char == '&')
5323         {
5324           parser_state |= PST_CASEPAT;
5325 #if defined (ALIAS)
5326           parser_state &= ~PST_ALEXPNEXT;
5327 #endif /* ALIAS */
5328           return (SEMI_AND);
5329         }
5330
5331       shell_ungetc (peek_char);
5332
5333       /* If we look like we are reading the start of a function
5334          definition, then let the reader know about it so that
5335          we will do the right thing with `{'. */
5336       if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
5337         {
5338           parser_state |= PST_ALLOWOPNBRC;
5339 #if defined (ALIAS)
5340           parser_state &= ~PST_ALEXPNEXT;
5341 #endif /* ALIAS */
5342           function_dstart = line_number;
5343         }
5344
5345       /* case pattern lists may be preceded by an optional left paren.  If
5346          we're not trying to parse a case pattern list, the left paren
5347          indicates a subshell. */
5348       if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
5349         parser_state |= PST_SUBSHELL;
5350       /*(*/
5351       else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
5352         parser_state &= ~PST_CASEPAT;
5353       /*(*/
5354       else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
5355         parser_state &= ~PST_SUBSHELL;
5356
5357 #if defined (PROCESS_SUBSTITUTION)
5358       /* Check for the constructs which introduce process substitution.
5359          Shells running in `posix mode' don't do process substitution. */
5360       if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
5361 #endif /* PROCESS_SUBSTITUTION */
5362         return (character);
5363     }
5364
5365   /* Hack <&- (close stdin) case.  Also <&N- (dup and close). */
5366   if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
5367     return (character);
5368
5369 tokword:
5370   /* Okay, if we got this far, we have to read a word.  Read one,
5371      and then check it against the known ones. */
5372   result = read_token_word (character);
5373 #if defined (ALIAS)
5374   if (result == RE_READ_TOKEN)
5375     goto re_read_token;
5376 #endif
5377   return result;
5378 }
5379
5380 /*
5381  * Match a $(...) or other grouping construct.  This has to handle embedded
5382  * quoted strings ('', ``, "") and nested constructs.  It also must handle
5383  * reprompting the user, if necessary, after reading a newline, and returning
5384  * correct error values if it reads EOF.
5385  */
5386 #define P_FIRSTCLOSE    0x01
5387 #define P_ALLOWESC      0x02
5388 #define P_DQUOTE        0x04
5389 #define P_COMMAND       0x08    /* parsing a command, so look for comments */
5390 #define P_BACKQUOTE     0x10    /* parsing a backquoted command substitution */
5391 #define P_ARRAYSUB      0x20    /* parsing a [...] array subscript for assignment */
5392
5393 /* Lexical state while parsing a grouping construct or $(...). */
5394 #define LEX_WASDOL      0x001
5395 #define LEX_CKCOMMENT   0x002
5396 #define LEX_INCOMMENT   0x004
5397 #define LEX_PASSNEXT    0x008
5398 #define LEX_RESWDOK     0x010
5399 #define LEX_CKCASE      0x020
5400 #define LEX_INCASE      0x040
5401 #define LEX_INHEREDOC   0x080
5402 #define LEX_HEREDELIM   0x100           /* reading here-doc delimiter */
5403 #define LEX_STRIPDOC    0x200           /* <<- strip tabs from here doc delim */
5404 #define LEX_INWORD      0x400
5405
5406 #define COMSUB_META(ch)         ((ch) == ';' || (ch) == '&' || (ch) == '|')
5407
5408 #define CHECK_NESTRET_ERROR() \
5409   do { \
5410     if (nestret == &matched_pair_error) \
5411       { \
5412         free (ret); \
5413         return &matched_pair_error; \
5414       } \
5415   } while (0)
5416
5417 #define APPEND_NESTRET() \
5418   do { \
5419     if (nestlen) \
5420       { \
5421         RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64); \
5422         strcpy (ret + retind, nestret); \
5423         retind += nestlen; \
5424       } \
5425   } while (0)
5426
5427 static char matched_pair_error;
5428
5429 static char *
5430 parse_matched_pair (qc, open, close, lenp, flags)
5431      int qc;    /* `"' if this construct is within double quotes */
5432      int open, close;
5433      int *lenp, flags;
5434 {
5435   int count, ch, tflags;
5436   int nestlen, ttranslen, start_lineno;
5437   char *ret, *nestret, *ttrans;
5438   int retind, retsize, rflags;
5439
5440 /*itrace("parse_matched_pair[%d]: open = %c close = %c flags = %d", line_number, open, close, flags);*/
5441   count = 1;
5442   tflags = 0;
5443
5444   if ((flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
5445     tflags |= LEX_CKCOMMENT;
5446
5447   /* RFLAGS is the set of flags we want to pass to recursive calls. */
5448   rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
5449
5450   ret = (char *)xmalloc (retsize = 64);
5451   retind = 0;
5452
5453   start_lineno = line_number;
5454   while (count)
5455     {
5456       ch = shell_getc (qc != '\'' && (tflags & LEX_PASSNEXT) == 0);
5457
5458       if (ch == EOF)
5459         {
5460           free (ret);
5461           parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
5462           EOF_Reached = 1;      /* XXX */
5463           return (&matched_pair_error);
5464         }
5465
5466       /* Possible reprompting. */
5467       if (ch == '\n' && SHOULD_PROMPT ())
5468         prompt_again ();
5469
5470       /* Don't bother counting parens or doing anything else if in a comment
5471          or part of a case statement */
5472       if (tflags & LEX_INCOMMENT)
5473         {
5474           /* Add this character. */
5475           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5476           ret[retind++] = ch;
5477
5478           if (ch == '\n')
5479             tflags &= ~LEX_INCOMMENT;
5480
5481           continue;
5482         }
5483
5484       /* Not exactly right yet, should handle shell metacharacters, too.  If
5485          any changes are made to this test, make analogous changes to subst.c:
5486          extract_delimited_string(). */
5487       else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
5488         tflags |= LEX_INCOMMENT;
5489
5490       if (tflags & LEX_PASSNEXT)                /* last char was backslash */
5491         {
5492           tflags &= ~LEX_PASSNEXT;
5493           if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
5494             {
5495               if (retind > 0)
5496                 retind--;       /* swallow previously-added backslash */
5497               continue;
5498             }
5499
5500           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
5501           if MBTEST(ch == CTLESC || ch == CTLNUL)
5502             ret[retind++] = CTLESC;
5503           ret[retind++] = ch;
5504           continue;
5505         }
5506       /* If we're reparsing the input (e.g., from parse_string_to_word_list),
5507          we've already prepended CTLESC to single-quoted results of $'...'.
5508          We may want to do this for other CTLESC-quoted characters in
5509          reparse, too. */
5510       else if MBTEST((parser_state & PST_REPARSE) && open == '\'' && (ch == CTLESC || ch == CTLNUL))
5511         {
5512           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5513           ret[retind++] = ch;
5514           continue;
5515         }
5516       else if MBTEST(ch == CTLESC || ch == CTLNUL)      /* special shell escapes */
5517         {
5518           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
5519           ret[retind++] = CTLESC;
5520           ret[retind++] = ch;
5521           continue;
5522         }
5523       else if MBTEST(ch == close)               /* ending delimiter */
5524         count--;
5525       /* handle nested ${...} specially. */
5526       else if MBTEST(open != close && (tflags & LEX_WASDOL) && open == '{' && ch == open) /* } */
5527         count++;
5528       else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open)       /* nested begin */
5529         count++;
5530
5531       /* Add this character. */
5532       RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5533       ret[retind++] = ch;
5534
5535       /* If we just read the ending character, don't bother continuing. */
5536       if (count == 0)
5537         break;
5538
5539       if (open == '\'')                 /* '' inside grouping construct */
5540         {
5541           if MBTEST((flags & P_ALLOWESC) && ch == '\\')
5542             tflags |= LEX_PASSNEXT;
5543           continue;
5544         }
5545
5546       if MBTEST(ch == '\\')                     /* backslashes */
5547         tflags |= LEX_PASSNEXT;
5548
5549 #if 0
5550       /* The big hammer.  Single quotes aren't special in double quotes.  The
5551          problem is that Posix says the single quotes are semi-special:
5552          within a double-quoted ${...} construct "an even number of
5553          unescaped double-quotes or single-quotes, if any, shall occur." */
5554       if MBTEST(open == '{' && (flags & P_DQUOTE) && ch == '\'')        /* } */
5555         continue;
5556 #endif
5557
5558       /* Could also check open == '`' if we want to parse grouping constructs
5559          inside old-style command substitution. */
5560       if (open != close)                /* a grouping construct */
5561         {
5562           if MBTEST(shellquote (ch))
5563             {
5564               /* '', ``, or "" inside $(...) or other grouping construct. */
5565               push_delimiter (dstack, ch);
5566               if MBTEST((tflags & LEX_WASDOL) && ch == '\'')    /* $'...' inside group */
5567                 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
5568               else
5569                 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
5570               pop_delimiter (dstack);
5571               CHECK_NESTRET_ERROR ();
5572
5573               if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
5574                 {
5575                   /* Translate $'...' here. */
5576                   ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
5577                   xfree (nestret);
5578
5579                   if ((rflags & P_DQUOTE) == 0)
5580                     {
5581                       nestret = sh_single_quote (ttrans);
5582                       free (ttrans);
5583                       nestlen = strlen (nestret);
5584                     }
5585                   else
5586                     {
5587                       nestret = ttrans;
5588                       nestlen = ttranslen;
5589                     }
5590                   retind -= 2;          /* back up before the $' */
5591                 }
5592               else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
5593                 {
5594                   /* Locale expand $"..." here. */
5595                   ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
5596                   xfree (nestret);
5597
5598                   nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
5599                   free (ttrans);
5600                   nestlen = ttranslen + 2;
5601                   retind -= 2;          /* back up before the $" */
5602                 }
5603
5604               APPEND_NESTRET ();
5605               FREE (nestret);
5606             }
5607           else if ((flags & P_ARRAYSUB) && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))      /* ) } ] */
5608             goto parse_dollar_word;
5609         }
5610       /* Parse an old-style command substitution within double quotes as a
5611          single word. */
5612       /* XXX - sh and ksh93 don't do this - XXX */
5613       else if MBTEST(open == '"' && ch == '`')
5614         {
5615           nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
5616
5617           CHECK_NESTRET_ERROR ();
5618           APPEND_NESTRET ();
5619
5620           FREE (nestret);
5621         }
5622       else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))     /* ) } ] */
5623         /* check for $(), $[], or ${} inside quoted string. */
5624         {
5625 parse_dollar_word:
5626           if (open == ch)       /* undo previous increment */
5627             count--;
5628           if (ch == '(')                /* ) */
5629             nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
5630           else if (ch == '{')           /* } */
5631             nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
5632           else if (ch == '[')           /* ] */
5633             nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
5634
5635           CHECK_NESTRET_ERROR ();
5636           APPEND_NESTRET ();
5637
5638           FREE (nestret);
5639         }
5640       if MBTEST(ch == '$')
5641         tflags |= LEX_WASDOL;
5642       else
5643         tflags &= ~LEX_WASDOL;
5644     }
5645
5646   ret[retind] = '\0';
5647   if (lenp)
5648     *lenp = retind;
5649 /*itrace("parse_matched_pair[%d]: returning %s", line_number, ret);*/
5650   return ret;
5651 }
5652
5653 /* Parse a $(...) command substitution.  This is messier than I'd like, and
5654    reproduces a lot more of the token-reading code than I'd like. */
5655 static char *
5656 parse_comsub (qc, open, close, lenp, flags)
5657      int qc;    /* `"' if this construct is within double quotes */
5658      int open, close;
5659      int *lenp, flags;
5660 {
5661   int count, ch, peekc, tflags, lex_rwlen, lex_wlen, lex_firstind;
5662   int nestlen, ttranslen, start_lineno;
5663   char *ret, *nestret, *ttrans, *heredelim;
5664   int retind, retsize, rflags, hdlen;
5665
5666 /*itrace("parse_comsub: qc = `%c' open = %c close = %c", qc, open, close);*/
5667   count = 1;
5668   tflags = LEX_RESWDOK;
5669
5670   if ((flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
5671     tflags |= LEX_CKCASE;
5672   if ((tflags & LEX_CKCASE) && (interactive == 0 || interactive_comments))
5673     tflags |= LEX_CKCOMMENT;
5674
5675   /* RFLAGS is the set of flags we want to pass to recursive calls. */
5676   rflags = (flags & P_DQUOTE);
5677
5678   ret = (char *)xmalloc (retsize = 64);
5679   retind = 0;
5680
5681   start_lineno = line_number;
5682   lex_rwlen = lex_wlen = 0;
5683
5684   heredelim = 0;
5685   lex_firstind = -1;
5686
5687   while (count)
5688     {
5689 comsub_readchar:
5690       ch = shell_getc (qc != '\'' && (tflags & LEX_PASSNEXT) == 0);
5691
5692       if (ch == EOF)
5693         {
5694 eof_error:
5695           free (ret);
5696           FREE (heredelim);
5697           parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
5698           EOF_Reached = 1;      /* XXX */
5699           return (&matched_pair_error);
5700         }
5701
5702       /* If we hit the end of a line and are reading the contents of a here
5703          document, and it's not the same line that the document starts on,
5704          check for this line being the here doc delimiter.  Otherwise, if
5705          we're in a here document, mark the next character as the beginning
5706          of a line. */
5707       if (ch == '\n')
5708         {
5709           if ((tflags & LEX_HEREDELIM) && heredelim)
5710             {
5711               tflags &= ~LEX_HEREDELIM;
5712               tflags |= LEX_INHEREDOC;
5713               lex_firstind = retind + 1;
5714             }
5715           else if (tflags & LEX_INHEREDOC)
5716             {
5717               int tind;
5718               tind = lex_firstind;
5719               while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
5720                 tind++;
5721               if (STREQN (ret + tind, heredelim, hdlen))
5722                 {
5723                   tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
5724 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
5725                   free (heredelim);
5726                   heredelim = 0;
5727                   lex_firstind = -1;
5728                 }
5729               else
5730                 lex_firstind = retind + 1;
5731             }
5732         }
5733
5734       /* Possible reprompting. */
5735       if (ch == '\n' && SHOULD_PROMPT ())
5736         prompt_again ();
5737
5738       /* XXX -- possibly allow here doc to be delimited by ending right
5739          paren. */
5740       if ((tflags & LEX_INHEREDOC) && ch == close && count == 1)
5741         {
5742           int tind;
5743 /*itrace("parse_comsub: in here doc, ch == close, retind - firstind = %d hdlen = %d retind = %d", retind-lex_firstind, hdlen, retind);*/
5744           tind = lex_firstind;
5745           while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
5746             tind++;
5747           if (retind-tind == hdlen && STREQN (ret + tind, heredelim, hdlen))
5748             {
5749               tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
5750 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
5751               free (heredelim);
5752               heredelim = 0;
5753               lex_firstind = -1;
5754             }
5755         }
5756
5757       /* Don't bother counting parens or doing anything else if in a comment */
5758       if (tflags & (LEX_INCOMMENT|LEX_INHEREDOC))
5759         {
5760           /* Add this character. */
5761           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5762           ret[retind++] = ch;
5763
5764           if ((tflags & LEX_INCOMMENT) && ch == '\n')
5765 {
5766 /*itrace("parse_comsub:%d: lex_incomment -> 0 ch = `%c'", line_number, ch);*/
5767             tflags &= ~LEX_INCOMMENT;
5768 }
5769
5770           continue;
5771         }
5772
5773       if (tflags & LEX_PASSNEXT)                /* last char was backslash */
5774         {
5775 /*itrace("parse_comsub:%d: lex_passnext -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
5776           tflags &= ~LEX_PASSNEXT;
5777           if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
5778             {
5779               if (retind > 0)
5780                 retind--;       /* swallow previously-added backslash */
5781               continue;
5782             }
5783
5784           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
5785           if MBTEST(ch == CTLESC || ch == CTLNUL)
5786             ret[retind++] = CTLESC;
5787           ret[retind++] = ch;
5788           continue;
5789         }
5790
5791       /* If this is a shell break character, we are not in a word.  If not,
5792          we either start or continue a word. */
5793       if MBTEST(shellbreak (ch))
5794         {
5795           tflags &= ~LEX_INWORD;
5796 /*itrace("parse_comsub:%d: lex_inword -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
5797         }
5798       else
5799         {
5800           if (tflags & LEX_INWORD)
5801             {
5802               lex_wlen++;
5803 /*itrace("parse_comsub:%d: lex_inword == 1 ch = `%c' lex_wlen = %d (%d)", line_number, ch, lex_wlen, __LINE__);*/
5804             }
5805           else
5806             {
5807 /*itrace("parse_comsub:%d: lex_inword -> 1 ch = `%c' (%d)", line_number, ch, __LINE__);*/
5808               tflags |= LEX_INWORD;
5809               lex_wlen = 0;
5810             }
5811         }
5812
5813       /* Skip whitespace */
5814       if MBTEST(shellblank (ch) && lex_rwlen == 0)
5815         {
5816           /* Add this character. */
5817           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5818           ret[retind++] = ch;
5819           continue;
5820         }
5821
5822       /* Either we are looking for the start of the here-doc delimiter
5823          (lex_firstind == -1) or we are reading one (lex_firstind >= 0).
5824          If this character is a shell break character and we are reading
5825          the delimiter, save it and note that we are now reading a here
5826          document.  If we've found the start of the delimiter, note it by
5827          setting lex_firstind.  Backslashes can quote shell metacharacters
5828          in here-doc delimiters. */
5829       if (tflags & LEX_HEREDELIM)
5830         {
5831           if (lex_firstind == -1 && shellbreak (ch) == 0)
5832             lex_firstind = retind;
5833 #if 0
5834           else if (heredelim && (tflags & LEX_PASSNEXT) == 0 && ch == '\n')
5835             {
5836               tflags |= LEX_INHEREDOC;
5837               tflags &= ~LEX_HEREDELIM;
5838               lex_firstind = retind + 1;
5839             }
5840 #endif
5841           else if (lex_firstind >= 0 && (tflags & LEX_PASSNEXT) == 0 && shellbreak (ch))
5842             {
5843               if (heredelim == 0)
5844                 {
5845                   nestret = substring (ret, lex_firstind, retind);
5846                   heredelim = string_quote_removal (nestret, 0);
5847                   free (nestret);
5848                   hdlen = STRLEN(heredelim);
5849 /*itrace("parse_comsub:%d: found here doc delimiter `%s' (%d)", line_number, heredelim, hdlen);*/
5850                 }
5851               if (ch == '\n')
5852                 {
5853                   tflags |= LEX_INHEREDOC;
5854                   tflags &= ~LEX_HEREDELIM;
5855                   lex_firstind = retind + 1;
5856                 }
5857               else
5858                 lex_firstind = -1;
5859             }
5860         }
5861
5862       /* Meta-characters that can introduce a reserved word.  Not perfect yet. */
5863       if MBTEST((tflags & LEX_RESWDOK) == 0 && (tflags & LEX_CKCASE) && (tflags & LEX_INCOMMENT) == 0 && (shellmeta(ch) || ch == '\n'))
5864         {
5865           /* Add this character. */
5866           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5867           ret[retind++] = ch;
5868           peekc = shell_getc (1);
5869           if (ch == peekc && (ch == '&' || ch == '|' || ch == ';'))     /* two-character tokens */
5870             {
5871               RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5872               ret[retind++] = peekc;
5873 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
5874               tflags |= LEX_RESWDOK;
5875               lex_rwlen = 0;
5876               continue;
5877             }
5878           else if (ch == '\n' || COMSUB_META(ch))
5879             {
5880               shell_ungetc (peekc);
5881 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
5882               tflags |= LEX_RESWDOK;
5883               lex_rwlen = 0;
5884               continue;
5885             }
5886           else if (ch == EOF)
5887             goto eof_error;
5888           else
5889             {
5890               /* `unget' the character we just added and fall through */
5891               retind--;
5892               shell_ungetc (peekc);
5893             }
5894         }
5895
5896       /* If we can read a reserved word, try to read one. */
5897       if (tflags & LEX_RESWDOK)
5898         {
5899           if MBTEST(islower (ch))
5900             {
5901               /* Add this character. */
5902               RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5903               ret[retind++] = ch;
5904               lex_rwlen++;
5905               continue;
5906             }
5907           else if MBTEST(lex_rwlen == 4 && shellbreak (ch))
5908             {
5909               if (STREQN (ret + retind - 4, "case", 4))
5910 {
5911                 tflags |= LEX_INCASE;
5912 /*itrace("parse_comsub:%d: found `case', lex_incase -> 1 lex_reswdok -> 0", line_number);*/
5913 }
5914               else if (STREQN (ret + retind - 4, "esac", 4))
5915 {
5916                 tflags &= ~LEX_INCASE;
5917 /*itrace("parse_comsub:%d: found `esac', lex_incase -> 0 lex_reswdok -> 0", line_number);*/
5918 }
5919               tflags &= ~LEX_RESWDOK;
5920             }
5921           else if MBTEST((tflags & LEX_CKCOMMENT) && ch == '#' && (lex_rwlen == 0 || ((tflags & LEX_INWORD) && lex_wlen == 0)))
5922             ;   /* don't modify LEX_RESWDOK if we're starting a comment */
5923           else if MBTEST((tflags & LEX_INCASE) && ch != '\n')
5924             /* If we can read a reserved word and we're in case, we're at the
5925                point where we can read a new pattern list or an esac.  We
5926                handle the esac case above.  If we read a newline, we want to
5927                leave LEX_RESWDOK alone.  If we read anything else, we want to
5928                turn off LEX_RESWDOK, since we're going to read a pattern list. */
5929 {
5930             tflags &= ~LEX_RESWDOK;
5931 /*itrace("parse_comsub:%d: lex_incase == 1 found `%c', lex_reswordok -> 0", line_number, ch);*/
5932 }
5933           else if MBTEST(shellbreak (ch) == 0)
5934 {
5935             tflags &= ~LEX_RESWDOK;
5936 /*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
5937 }
5938         }
5939
5940       /* Might be the start of a here-doc delimiter */
5941       if MBTEST((tflags & LEX_INCOMMENT) == 0 && (tflags & LEX_CKCASE) && ch == '<')
5942         {
5943           /* Add this character. */
5944           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5945           ret[retind++] = ch;
5946           peekc = shell_getc (1);
5947           if (peekc == EOF)
5948             goto eof_error;
5949           if (peekc == ch)
5950             {
5951               RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5952               ret[retind++] = peekc;
5953               peekc = shell_getc (1);
5954               if (peekc == EOF)
5955                 goto eof_error;
5956               if (peekc == '-')
5957                 {
5958                   RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
5959                   ret[retind++] = peekc;
5960                   tflags |= LEX_STRIPDOC;
5961                 }
5962               else
5963                 shell_ungetc (peekc);
5964               if (peekc != '<')
5965                 {
5966                   tflags |= LEX_HEREDELIM;
5967                   lex_firstind = -1;
5968                 }
5969               continue;
5970             }
5971           else
5972             ch = peekc;         /* fall through and continue XXX */
5973         }
5974       else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (((tflags & LEX_RESWDOK) && lex_rwlen == 0) || ((tflags & LEX_INWORD) && lex_wlen == 0)))
5975 {
5976 /*itrace("parse_comsub:%d: lex_incomment -> 1 (%d)", line_number, __LINE__);*/
5977         tflags |= LEX_INCOMMENT;
5978 }
5979
5980       if MBTEST(ch == CTLESC || ch == CTLNUL)   /* special shell escapes */
5981         {
5982           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
5983           ret[retind++] = CTLESC;
5984           ret[retind++] = ch;
5985           continue;
5986         }
5987 #if 0
5988       else if MBTEST((tflags & LEX_INCASE) && ch == close && close == ')')
5989         tflags &= ~LEX_INCASE;          /* XXX */
5990 #endif
5991       else if MBTEST(ch == close && (tflags & LEX_INCASE) == 0)         /* ending delimiter */
5992 {
5993         count--;
5994 /*itrace("parse_comsub:%d: found close: count = %d", line_number, count);*/
5995 }
5996       else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && (tflags & LEX_INCASE) == 0 && ch == open) /* nested begin */
5997 {
5998         count++;
5999 /*itrace("parse_comsub:%d: found open: count = %d", line_number, count);*/
6000 }
6001
6002       /* Add this character. */
6003       RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
6004       ret[retind++] = ch;
6005
6006       /* If we just read the ending character, don't bother continuing. */
6007       if (count == 0)
6008         break;
6009
6010       if MBTEST(ch == '\\')                     /* backslashes */
6011         tflags |= LEX_PASSNEXT;
6012
6013       if MBTEST(shellquote (ch))
6014         {
6015           /* '', ``, or "" inside $(...). */
6016           push_delimiter (dstack, ch);
6017           if MBTEST((tflags & LEX_WASDOL) && ch == '\'')        /* $'...' inside group */
6018             nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
6019           else
6020             nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
6021           pop_delimiter (dstack);
6022           CHECK_NESTRET_ERROR ();
6023
6024           if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
6025             {
6026               /* Translate $'...' here. */
6027               ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
6028               xfree (nestret);
6029
6030               if ((rflags & P_DQUOTE) == 0)
6031                 {
6032                   nestret = sh_single_quote (ttrans);
6033                   free (ttrans);
6034                   nestlen = strlen (nestret);
6035                 }
6036               else
6037                 {
6038                   nestret = ttrans;
6039                   nestlen = ttranslen;
6040                 }
6041               retind -= 2;              /* back up before the $' */
6042             }
6043           else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
6044             {
6045               /* Locale expand $"..." here. */
6046               ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
6047               xfree (nestret);
6048
6049               nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
6050               free (ttrans);
6051               nestlen = ttranslen + 2;
6052               retind -= 2;              /* back up before the $" */
6053             }
6054
6055           APPEND_NESTRET ();
6056           FREE (nestret);
6057         }
6058       else if MBTEST((tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '['))    /* ) } ] */
6059         /* check for $(), $[], or ${} inside command substitution. */
6060         {
6061           if ((tflags & LEX_INCASE) == 0 && open == ch) /* undo previous increment */
6062             count--;
6063           if (ch == '(')                /* ) */
6064             nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
6065           else if (ch == '{')           /* } */
6066             nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
6067           else if (ch == '[')           /* ] */
6068             nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
6069
6070           CHECK_NESTRET_ERROR ();
6071           APPEND_NESTRET ();
6072
6073           FREE (nestret);
6074         }
6075       if MBTEST(ch == '$')
6076         tflags |= LEX_WASDOL;
6077       else
6078         tflags &= ~LEX_WASDOL;
6079     }
6080
6081   FREE (heredelim);
6082   ret[retind] = '\0';
6083   if (lenp)
6084     *lenp = retind;
6085 /*itrace("parse_comsub:%d: returning `%s'", line_number, ret);*/
6086   return ret;
6087 }
6088
6089 /* XXX - this needs to handle functionality like subst.c:no_longjmp_on_fatal_error;
6090    maybe extract_command_subst should handle it. */
6091 char *
6092 xparse_dolparen (base, string, indp, flags)
6093      char *base;
6094      char *string;
6095      int *indp;
6096      int flags;
6097 {
6098   sh_parser_state_t ps;
6099   int orig_ind, nc, sflags;
6100   char *ret, *s, *ep, *ostring;
6101
6102   /*yydebug = 1;*/
6103   orig_ind = *indp;
6104   ostring = string;
6105
6106   sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
6107   if (flags & SX_NOLONGJMP)
6108     sflags |= SEVAL_NOLONGJMP;
6109   save_parser_state (&ps);
6110
6111   /*(*/
6112   parser_state |= PST_CMDSUBST|PST_EOFTOKEN;    /* allow instant ')' */ /*(*/
6113   shell_eof_token = ')';
6114   parse_string (string, "command substitution", sflags, &ep);
6115
6116   restore_parser_state (&ps);
6117   reset_parser ();
6118   if (interactive)
6119     token_to_read = 0;
6120
6121   /* Need to find how many characters parse_and_execute consumed, update
6122      *indp, if flags != 0, copy the portion of the string parsed into RET
6123      and return it.  If flags & 1 (EX_NOALLOC) we can return NULL. */
6124
6125   /*(*/
6126   if (ep[-1] != ')')
6127     {
6128 #if DEBUG
6129       if (ep[-1] != '\n')
6130         itrace("xparse_dolparen:%d: ep[-1] != RPAREN (%d), ep = `%s'", line_number, ep[-1], ep);
6131 #endif
6132       while (ep > ostring && ep[-1] == '\n') ep--;
6133     }
6134
6135   nc = ep - ostring;
6136   *indp = ep - base - 1;
6137
6138   /*(*/
6139 #if DEBUG
6140   if (base[*indp] != ')')
6141     itrace("xparse_dolparen:%d: base[%d] != RPAREN (%d), base = `%s'", line_number, *indp, base[*indp], base);
6142 #endif
6143
6144   if (flags & SX_NOALLOC)
6145     return (char *)NULL;
6146
6147   if (nc == 0)
6148     {
6149       ret = xmalloc (1);
6150       ret[0] = '\0';
6151     }
6152   else
6153     ret = substring (ostring, 0, nc - 1);
6154
6155   return ret;
6156 }
6157
6158 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
6159 /* Parse a double-paren construct.  It can be either an arithmetic
6160    command, an arithmetic `for' command, or a nested subshell.  Returns
6161    the parsed token, -1 on error, or -2 if we didn't do anything and
6162    should just go on. */
6163 static int
6164 parse_dparen (c)
6165      int c;
6166 {
6167   int cmdtyp, sline;
6168   char *wval;
6169   WORD_DESC *wd;
6170
6171 #if defined (ARITH_FOR_COMMAND)
6172   if (last_read_token == FOR)
6173     {
6174       arith_for_lineno = line_number;
6175       cmdtyp = parse_arith_cmd (&wval, 0);
6176       if (cmdtyp == 1)
6177         {
6178           wd = alloc_word_desc ();
6179           wd->word = wval;
6180           yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
6181           return (ARITH_FOR_EXPRS);
6182         }
6183       else
6184         return -1;              /* ERROR */
6185     }
6186 #endif
6187
6188 #if defined (DPAREN_ARITHMETIC)
6189   if (reserved_word_acceptable (last_read_token))
6190     {
6191       sline = line_number;
6192
6193       cmdtyp = parse_arith_cmd (&wval, 0);
6194       if (cmdtyp == 1)  /* arithmetic command */
6195         {
6196           wd = alloc_word_desc ();
6197           wd->word = wval;
6198           wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
6199           yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
6200           return (ARITH_CMD);
6201         }
6202       else if (cmdtyp == 0)     /* nested subshell */
6203         {
6204           push_string (wval, 0, (alias_t *)NULL);
6205           if ((parser_state & PST_CASEPAT) == 0)
6206             parser_state |= PST_SUBSHELL;
6207           return (c);
6208         }
6209       else                      /* ERROR */
6210         return -1;
6211     }
6212 #endif
6213
6214   return -2;                    /* XXX */
6215 }
6216
6217 /* We've seen a `(('.  Look for the matching `))'.  If we get it, return 1.
6218    If not, assume it's a nested subshell for backwards compatibility and
6219    return 0.  In any case, put the characters we've consumed into a locally-
6220    allocated buffer and make *ep point to that buffer.  Return -1 on an
6221    error, for example EOF. */
6222 static int
6223 parse_arith_cmd (ep, adddq)
6224      char **ep;
6225      int adddq;
6226 {
6227   int exp_lineno, rval, c;
6228   char *ttok, *tokstr;
6229   int ttoklen;
6230
6231   exp_lineno = line_number;
6232   ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
6233   rval = 1;
6234   if (ttok == &matched_pair_error)
6235     return -1;
6236   /* Check that the next character is the closing right paren.  If
6237      not, this is a syntax error. ( */
6238   c = shell_getc (0);
6239   if MBTEST(c != ')')
6240     rval = 0;
6241
6242   tokstr = (char *)xmalloc (ttoklen + 4);
6243
6244   /* if ADDDQ != 0 then (( ... )) -> "..." */
6245   if (rval == 1 && adddq)       /* arith cmd, add double quotes */
6246     {
6247       tokstr[0] = '"';
6248       strncpy (tokstr + 1, ttok, ttoklen - 1);
6249       tokstr[ttoklen] = '"';
6250       tokstr[ttoklen+1] = '\0';
6251     }
6252   else if (rval == 1)           /* arith cmd, don't add double quotes */
6253     {
6254       strncpy (tokstr, ttok, ttoklen - 1);
6255       tokstr[ttoklen-1] = '\0';
6256     }
6257   else                          /* nested subshell */
6258     {
6259       tokstr[0] = '(';
6260       strncpy (tokstr + 1, ttok, ttoklen - 1);
6261       tokstr[ttoklen] = ')';
6262       tokstr[ttoklen+1] = c;
6263       tokstr[ttoklen+2] = '\0';
6264     }
6265
6266   *ep = tokstr;
6267   FREE (ttok);
6268   return rval;
6269 }
6270 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
6271
6272 #if defined (COND_COMMAND)
6273 static void
6274 cond_error ()
6275 {
6276   char *etext;
6277
6278   if (EOF_Reached && cond_token != COND_ERROR)          /* [[ */
6279     parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
6280   else if (cond_token != COND_ERROR)
6281     {
6282       if (etext = error_token_from_token (cond_token))
6283         {
6284           parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
6285           free (etext);
6286         }
6287       else
6288         parser_error (cond_lineno, _("syntax error in conditional expression"));
6289     }
6290 }
6291
6292 static COND_COM *
6293 cond_expr ()
6294 {
6295   return (cond_or ());
6296 }
6297
6298 static COND_COM *
6299 cond_or ()
6300 {
6301   COND_COM *l, *r;
6302
6303   l = cond_and ();
6304   if (cond_token == OR_OR)
6305     {
6306       r = cond_or ();
6307       l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
6308     }
6309   return l;
6310 }
6311
6312 static COND_COM *
6313 cond_and ()
6314 {
6315   COND_COM *l, *r;
6316
6317   l = cond_term ();
6318   if (cond_token == AND_AND)
6319     {
6320       r = cond_and ();
6321       l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
6322     }
6323   return l;
6324 }
6325
6326 static int
6327 cond_skip_newlines ()
6328 {
6329   while ((cond_token = read_token (READ)) == '\n')
6330     {
6331       if (SHOULD_PROMPT ())
6332         prompt_again ();
6333     }
6334   return (cond_token);
6335 }
6336
6337 #define COND_RETURN_ERROR() \
6338   do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
6339
6340 static COND_COM *
6341 cond_term ()
6342 {
6343   WORD_DESC *op;
6344   COND_COM *term, *tleft, *tright;
6345   int tok, lineno;
6346   char *etext;
6347
6348   /* Read a token.  It can be a left paren, a `!', a unary operator, or a
6349      word that should be the first argument of a binary operator.  Start by
6350      skipping newlines, since this is a compound command. */
6351   tok = cond_skip_newlines ();
6352   lineno = line_number;
6353   if (tok == COND_END)
6354     {
6355       COND_RETURN_ERROR ();
6356     }
6357   else if (tok == '(')
6358     {
6359       term = cond_expr ();
6360       if (cond_token != ')')
6361         {
6362           if (term)
6363             dispose_cond_node (term);           /* ( */
6364           if (etext = error_token_from_token (cond_token))
6365             {
6366               parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
6367               free (etext);
6368             }
6369           else
6370             parser_error (lineno, _("expected `)'"));
6371           COND_RETURN_ERROR ();
6372         }
6373       term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
6374       (void)cond_skip_newlines ();
6375     }
6376   else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
6377     {
6378       if (tok == WORD)
6379         dispose_word (yylval.word);     /* not needed */
6380       term = cond_term ();
6381       if (term)
6382         term->flags |= CMD_INVERT_RETURN;
6383     }
6384   else if (tok == WORD && yylval.word->word[0] == '-' && yylval.word->word[2] == 0 && test_unop (yylval.word->word))
6385     {
6386       op = yylval.word;
6387       tok = read_token (READ);
6388       if (tok == WORD)
6389         {
6390           tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
6391           term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
6392         }
6393       else
6394         {
6395           dispose_word (op);
6396           if (etext = error_token_from_token (tok))
6397             {
6398               parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
6399               free (etext);
6400             }
6401           else
6402             parser_error (line_number, _("unexpected argument to conditional unary operator"));
6403           COND_RETURN_ERROR ();
6404         }
6405
6406       (void)cond_skip_newlines ();
6407     }
6408   else if (tok == WORD)         /* left argument to binary operator */
6409     {
6410       /* lhs */
6411       tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
6412
6413       /* binop */
6414       tok = read_token (READ);
6415       if (tok == WORD && test_binop (yylval.word->word))
6416         {
6417           op = yylval.word;
6418           if (op->word[0] == '=' && (op->word[1] == '\0' || (op->word[1] == '=' && op->word[2] == '\0')))
6419             parser_state |= PST_EXTPAT;
6420           else if (op->word[0] == '!' && op->word[1] == '=' && op->word[2] == '\0')
6421             parser_state |= PST_EXTPAT;
6422         }
6423 #if defined (COND_REGEXP)
6424       else if (tok == WORD && STREQ (yylval.word->word, "=~"))
6425         {
6426           op = yylval.word;
6427           parser_state |= PST_REGEXP;
6428         }
6429 #endif
6430       else if (tok == '<' || tok == '>')
6431         op = make_word_from_token (tok);  /* ( */
6432       /* There should be a check before blindly accepting the `)' that we have
6433          seen the opening `('. */
6434       else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
6435         {
6436           /* Special case.  [[ x ]] is equivalent to [[ -n x ]], just like
6437              the test command.  Similarly for [[ x && expr ]] or
6438              [[ x || expr ]] or [[ (x) ]]. */
6439           op = make_word ("-n");
6440           term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
6441           cond_token = tok;
6442           return (term);
6443         }
6444       else
6445         {
6446           if (etext = error_token_from_token (tok))
6447             {
6448               parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
6449               free (etext);
6450             }
6451           else
6452             parser_error (line_number, _("conditional binary operator expected"));
6453           dispose_cond_node (tleft);
6454           COND_RETURN_ERROR ();
6455         }
6456
6457       /* rhs */
6458       if (parser_state & PST_EXTPAT)
6459         extended_glob = 1;
6460       tok = read_token (READ);
6461       if (parser_state & PST_EXTPAT)
6462         extended_glob = global_extglob;
6463       parser_state &= ~(PST_REGEXP|PST_EXTPAT);
6464
6465       if (tok == WORD)
6466         {
6467           tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
6468           term = make_cond_node (COND_BINARY, op, tleft, tright);
6469         }
6470       else
6471         {
6472           if (etext = error_token_from_token (tok))
6473             {
6474               parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
6475               free (etext);
6476             }
6477           else
6478             parser_error (line_number, _("unexpected argument to conditional binary operator"));
6479           dispose_cond_node (tleft);
6480           dispose_word (op);
6481           COND_RETURN_ERROR ();
6482         }
6483
6484       (void)cond_skip_newlines ();
6485     }
6486   else
6487     {
6488       if (tok < 256)
6489         parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
6490       else if (etext = error_token_from_token (tok))
6491         {
6492           parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
6493           free (etext);
6494         }
6495       else
6496         parser_error (line_number, _("unexpected token %d in conditional command"), tok);
6497       COND_RETURN_ERROR ();
6498     }
6499   return (term);
6500 }
6501
6502 /* This is kind of bogus -- we slip a mini recursive-descent parser in
6503    here to handle the conditional statement syntax. */
6504 static COMMAND *
6505 parse_cond_command ()
6506 {
6507   COND_COM *cexp;
6508
6509   global_extglob = extended_glob;
6510   cexp = cond_expr ();
6511   return (make_cond_command (cexp));
6512 }
6513 #endif
6514
6515 #if defined (ARRAY_VARS)
6516 /* When this is called, it's guaranteed that we don't care about anything
6517    in t beyond i.  We do save and restore the chars, though. */
6518 static int
6519 token_is_assignment (t, i)
6520      char *t;
6521      int i;
6522 {
6523   unsigned char c, c1;
6524   int r;
6525
6526   c = t[i]; c1 = t[i+1];
6527   t[i] = '='; t[i+1] = '\0';
6528   r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
6529   t[i] = c; t[i+1] = c1;
6530   return r;
6531 }
6532
6533 /* XXX - possible changes here for `+=' */
6534 static int
6535 token_is_ident (t, i)
6536      char *t;
6537      int i;
6538 {
6539   unsigned char c;
6540   int r;
6541
6542   c = t[i];
6543   t[i] = '\0';
6544   r = legal_identifier (t);
6545   t[i] = c;
6546   return r;
6547 }
6548 #endif
6549
6550 static int
6551 read_token_word (character)
6552      int character;
6553 {
6554   /* The value for YYLVAL when a WORD is read. */
6555   WORD_DESC *the_word;
6556
6557   /* Index into the token that we are building. */
6558   int token_index;
6559
6560   /* ALL_DIGITS becomes zero when we see a non-digit. */
6561   int all_digit_token;
6562
6563   /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
6564   int dollar_present;
6565
6566   /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
6567      assignment. */
6568   int compound_assignment;
6569
6570   /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
6571   int quoted;
6572
6573   /* Non-zero means to ignore the value of the next character, and just
6574      to add it no matter what. */
6575  int pass_next_character;
6576
6577   /* The current delimiting character. */
6578   int cd;
6579   int result, peek_char;
6580   char *ttok, *ttrans;
6581   int ttoklen, ttranslen;
6582   intmax_t lvalue;
6583
6584   if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
6585     token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
6586
6587   token_index = 0;
6588   all_digit_token = DIGIT (character);
6589   dollar_present = quoted = pass_next_character = compound_assignment = 0;
6590
6591   for (;;)
6592     {
6593       if (character == EOF)
6594         goto got_token;
6595
6596       if (pass_next_character)
6597         {
6598           pass_next_character = 0;
6599           goto got_escaped_character;
6600         }
6601
6602       cd = current_delimiter (dstack);
6603
6604       /* Handle backslashes.  Quote lots of things when not inside of
6605          double-quotes, quote some things inside of double-quotes. */
6606       if MBTEST(character == '\\')
6607         {
6608           peek_char = shell_getc (0);
6609
6610           /* Backslash-newline is ignored in all cases except
6611              when quoted with single quotes. */
6612           if (peek_char == '\n')
6613             {
6614               character = '\n';
6615               goto next_character;
6616             }
6617           else
6618             {
6619               shell_ungetc (peek_char);
6620
6621               /* If the next character is to be quoted, note it now. */
6622               if (cd == 0 || cd == '`' ||
6623                   (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
6624                 pass_next_character++;
6625
6626               quoted = 1;
6627               goto got_character;
6628             }
6629         }
6630
6631       /* Parse a matched pair of quote characters. */
6632       if MBTEST(shellquote (character))
6633         {
6634           push_delimiter (dstack, character);
6635           ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
6636           pop_delimiter (dstack);
6637           if (ttok == &matched_pair_error)
6638             return -1;          /* Bail immediately. */
6639           RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
6640                                   token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
6641           token[token_index++] = character;
6642           strcpy (token + token_index, ttok);
6643           token_index += ttoklen;
6644           all_digit_token = 0;
6645           quoted = 1;
6646           dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
6647           FREE (ttok);
6648           goto next_character;
6649         }
6650
6651 #ifdef COND_REGEXP
6652       /* When parsing a regexp as a single word inside a conditional command,
6653          we need to special-case characters special to both the shell and
6654          regular expressions.  Right now, that is only '(' and '|'. */ /*)*/
6655       if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|'))          /*)*/
6656         {
6657           if (character == '|')
6658             goto got_character;
6659
6660           push_delimiter (dstack, character);
6661           ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
6662           pop_delimiter (dstack);
6663           if (ttok == &matched_pair_error)
6664             return -1;          /* Bail immediately. */
6665           RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
6666                                   token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
6667           token[token_index++] = character;
6668           strcpy (token + token_index, ttok);
6669           token_index += ttoklen;
6670           FREE (ttok);
6671           dollar_present = all_digit_token = 0;
6672           goto next_character;
6673         }
6674 #endif /* COND_REGEXP */
6675
6676 #ifdef EXTENDED_GLOB
6677       /* Parse a ksh-style extended pattern matching specification. */
6678       if MBTEST(extended_glob && PATTERN_CHAR (character))
6679         {
6680           peek_char = shell_getc (1);
6681           if MBTEST(peek_char == '(')           /* ) */
6682             {
6683               push_delimiter (dstack, peek_char);
6684               ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
6685               pop_delimiter (dstack);
6686               if (ttok == &matched_pair_error)
6687                 return -1;              /* Bail immediately. */
6688               RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
6689                                       token_buffer_size,
6690                                       TOKEN_DEFAULT_GROW_SIZE);
6691               token[token_index++] = character;
6692               token[token_index++] = peek_char;
6693               strcpy (token + token_index, ttok);
6694               token_index += ttoklen;
6695               FREE (ttok);
6696               dollar_present = all_digit_token = 0;
6697               goto next_character;
6698             }
6699           else
6700             shell_ungetc (peek_char);
6701         }
6702 #endif /* EXTENDED_GLOB */
6703
6704       /* If the delimiter character is not single quote, parse some of
6705          the shell expansions that must be read as a single word. */
6706       if (shellexp (character))
6707         {
6708           peek_char = shell_getc (1);
6709           /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
6710           if MBTEST(peek_char == '(' || \
6711                 ((peek_char == '{' || peek_char == '[') && character == '$'))   /* ) ] } */
6712             {
6713               if (peek_char == '{')             /* } */
6714                 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE);
6715               else if (peek_char == '(')                /* ) */
6716                 {
6717                   /* XXX - push and pop the `(' as a delimiter for use by
6718                      the command-oriented-history code.  This way newlines
6719                      appearing in the $(...) string get added to the
6720                      history literally rather than causing a possibly-
6721                      incorrect `;' to be added. ) */
6722                   push_delimiter (dstack, peek_char);
6723                   ttok = parse_comsub (cd, '(', ')', &ttoklen, P_COMMAND);
6724                   pop_delimiter (dstack);
6725                 }
6726               else
6727                 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
6728               if (ttok == &matched_pair_error)
6729                 return -1;              /* Bail immediately. */
6730               RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
6731                                       token_buffer_size,
6732                                       TOKEN_DEFAULT_GROW_SIZE);
6733               token[token_index++] = character;
6734               token[token_index++] = peek_char;
6735               strcpy (token + token_index, ttok);
6736               token_index += ttoklen;
6737               FREE (ttok);
6738               dollar_present = 1;
6739               all_digit_token = 0;
6740               goto next_character;
6741             }
6742           /* This handles $'...' and $"..." new-style quoted strings. */
6743           else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
6744             {
6745               int first_line;
6746
6747               first_line = line_number;
6748               push_delimiter (dstack, peek_char);
6749               ttok = parse_matched_pair (peek_char, peek_char, peek_char,
6750                                          &ttoklen,
6751                                          (peek_char == '\'') ? P_ALLOWESC : 0);
6752               pop_delimiter (dstack);
6753               if (ttok == &matched_pair_error)
6754                 return -1;
6755               if (peek_char == '\'')
6756                 {
6757                   ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
6758                   free (ttok);
6759
6760                   /* Insert the single quotes and correctly quote any
6761                      embedded single quotes (allowed because P_ALLOWESC was
6762                      passed to parse_matched_pair). */
6763                   ttok = sh_single_quote (ttrans);
6764                   free (ttrans);
6765                   ttranslen = strlen (ttok);
6766                   ttrans = ttok;
6767                 }
6768               else
6769                 {
6770                   /* Try to locale-expand the converted string. */
6771                   ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
6772                   free (ttok);
6773
6774                   /* Add the double quotes back */
6775                   ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
6776                   free (ttrans);
6777                   ttranslen += 2;
6778                   ttrans = ttok;
6779                 }
6780
6781               RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
6782                                       token_buffer_size,
6783                                       TOKEN_DEFAULT_GROW_SIZE);
6784               strcpy (token + token_index, ttrans);
6785               token_index += ttranslen;
6786               FREE (ttrans);
6787               quoted = 1;
6788               all_digit_token = 0;
6789               goto next_character;
6790             }
6791           /* This could eventually be extended to recognize all of the
6792              shell's single-character parameter expansions, and set flags.*/
6793           else if MBTEST(character == '$' && peek_char == '$')
6794             {
6795               ttok = (char *)xmalloc (3);
6796               ttok[0] = ttok[1] = '$';
6797               ttok[2] = '\0';
6798               RESIZE_MALLOCED_BUFFER (token, token_index, 3,
6799                                       token_buffer_size,
6800                                       TOKEN_DEFAULT_GROW_SIZE);
6801               strcpy (token + token_index, ttok);
6802               token_index += 2;
6803               dollar_present = 1;
6804               all_digit_token = 0;
6805               FREE (ttok);
6806               goto next_character;
6807             }
6808           else
6809             shell_ungetc (peek_char);
6810         }
6811
6812 #if defined (ARRAY_VARS)
6813       /* Identify possible array subscript assignment; match [...].  If
6814          parser_state&PST_COMPASSIGN, we need to parse [sub]=words treating
6815          `sub' as if it were enclosed in double quotes. */
6816       else if MBTEST(character == '[' &&                /* ] */
6817                      ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
6818                       (token_index == 0 && (parser_state&PST_COMPASSIGN))))
6819         {
6820           ttok = parse_matched_pair (cd, '[', ']', &ttoklen, P_ARRAYSUB);
6821           if (ttok == &matched_pair_error)
6822             return -1;          /* Bail immediately. */
6823           RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
6824                                   token_buffer_size,
6825                                   TOKEN_DEFAULT_GROW_SIZE);
6826           token[token_index++] = character;
6827           strcpy (token + token_index, ttok);
6828           token_index += ttoklen;
6829           FREE (ttok);
6830           all_digit_token = 0;
6831           goto next_character;
6832         }
6833       /* Identify possible compound array variable assignment. */
6834       else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
6835         {
6836           peek_char = shell_getc (1);
6837           if MBTEST(peek_char == '(')           /* ) */
6838             {
6839               ttok = parse_compound_assignment (&ttoklen);
6840
6841               RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
6842                                       token_buffer_size,
6843                                       TOKEN_DEFAULT_GROW_SIZE);
6844
6845               token[token_index++] = '=';
6846               token[token_index++] = '(';
6847               if (ttok)
6848                 {
6849                   strcpy (token + token_index, ttok);
6850                   token_index += ttoklen;
6851                 }
6852               token[token_index++] = ')';
6853               FREE (ttok);
6854               all_digit_token = 0;
6855               compound_assignment = 1;
6856 #if 1
6857               goto next_character;
6858 #else
6859               goto got_token;           /* ksh93 seems to do this */
6860 #endif
6861             }
6862           else
6863             shell_ungetc (peek_char);
6864         }
6865 #endif
6866
6867       /* When not parsing a multi-character word construct, shell meta-
6868          characters break words. */
6869       if MBTEST(shellbreak (character))
6870         {
6871           shell_ungetc (character);
6872           goto got_token;
6873         }
6874
6875     got_character:
6876
6877       if (character == CTLESC || character == CTLNUL)
6878         token[token_index++] = CTLESC;
6879
6880     got_escaped_character:
6881
6882       all_digit_token &= DIGIT (character);
6883       dollar_present |= character == '$';
6884
6885       token[token_index++] = character;
6886
6887       RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
6888                               TOKEN_DEFAULT_GROW_SIZE);
6889
6890     next_character:
6891       if (character == '\n' && SHOULD_PROMPT ())
6892         prompt_again ();
6893
6894       /* We want to remove quoted newlines (that is, a \<newline> pair)
6895          unless we are within single quotes or pass_next_character is
6896          set (the shell equivalent of literal-next). */
6897       cd = current_delimiter (dstack);
6898       character = shell_getc (cd != '\'' && pass_next_character == 0);
6899     }   /* end for (;;) */
6900
6901 got_token:
6902
6903   token[token_index] = '\0';
6904
6905   /* Check to see what thing we should return.  If the last_read_token
6906      is a `<', or a `&', or the character which ended this token is
6907      a '>' or '<', then, and ONLY then, is this input token a NUMBER.
6908      Otherwise, it is just a word, and should be returned as such. */
6909   if MBTEST(all_digit_token && (character == '<' || character == '>' || \
6910                     last_read_token == LESS_AND || \
6911                     last_read_token == GREATER_AND))
6912       {
6913         if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
6914           yylval.number = lvalue;
6915         else
6916           yylval.number = -1;
6917         return (NUMBER);
6918       }
6919
6920   /* Check for special case tokens. */
6921   result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
6922   if (result >= 0)
6923     return result;
6924
6925 #if defined (ALIAS)
6926   /* Posix.2 does not allow reserved words to be aliased, so check for all
6927      of them, including special cases, before expanding the current token
6928      as an alias. */
6929   if MBTEST(posixly_correct)
6930     CHECK_FOR_RESERVED_WORD (token);
6931
6932   /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
6933      inhibits alias expansion. */
6934   if (expand_aliases && quoted == 0)
6935     {
6936       result = alias_expand_token (token);
6937       if (result == RE_READ_TOKEN)
6938         return (RE_READ_TOKEN);
6939       else if (result == NO_EXPANSION)
6940         parser_state &= ~PST_ALEXPNEXT;
6941     }
6942
6943   /* If not in Posix.2 mode, check for reserved words after alias
6944      expansion. */
6945   if MBTEST(posixly_correct == 0)
6946 #endif
6947     CHECK_FOR_RESERVED_WORD (token);
6948
6949   the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
6950   the_word->word = (char *)xmalloc (1 + token_index);
6951   the_word->flags = 0;
6952   strcpy (the_word->word, token);
6953   if (dollar_present)
6954     the_word->flags |= W_HASDOLLAR;
6955   if (quoted)
6956     the_word->flags |= W_QUOTED;                /*(*/
6957   if (compound_assignment && token[token_index-1] == ')')
6958     the_word->flags |= W_COMPASSIGN;
6959   /* A word is an assignment if it appears at the beginning of a
6960      simple command, or after another assignment word.  This is
6961      context-dependent, so it cannot be handled in the grammar. */
6962   if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
6963     {
6964       the_word->flags |= W_ASSIGNMENT;
6965       /* Don't perform word splitting on assignment statements. */
6966       if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
6967         the_word->flags |= W_NOSPLIT;
6968     }
6969
6970   if (command_token_position (last_read_token))
6971     {
6972       struct builtin *b;
6973       b = builtin_address_internal (token, 0);
6974       if (b && (b->flags & ASSIGNMENT_BUILTIN))
6975         parser_state |= PST_ASSIGNOK;
6976       else if (STREQ (token, "eval") || STREQ (token, "let"))
6977         parser_state |= PST_ASSIGNOK;
6978     }
6979
6980   yylval.word = the_word;
6981
6982   if (token[0] == '{' && token[token_index-1] == '}' &&
6983       (character == '<' || character == '>'))
6984     {
6985       /* can use token; already copied to the_word */
6986       token[token_index-1] = '\0';
6987       if (legal_identifier (token+1))
6988         {
6989           strcpy (the_word->word, token+1);
6990 /*itrace("read_token_word: returning REDIR_WORD for %s", the_word->word);*/
6991           return (REDIR_WORD);
6992         }
6993     }
6994
6995   result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
6996                 ? ASSIGNMENT_WORD : WORD;
6997
6998   switch (last_read_token)
6999     {
7000     case FUNCTION:
7001       parser_state |= PST_ALLOWOPNBRC;
7002       function_dstart = line_number;
7003       break;
7004     case CASE:
7005     case SELECT:
7006     case FOR:
7007       if (word_top < MAX_CASE_NEST)
7008         word_top++;
7009       word_lineno[word_top] = line_number;
7010       break;
7011     }
7012
7013   return (result);
7014 }
7015
7016 /* Return 1 if TOKSYM is a token that after being read would allow
7017    a reserved word to be seen, else 0. */
7018 static int
7019 reserved_word_acceptable (toksym)
7020      int toksym;
7021 {
7022   switch (toksym)
7023     {
7024     case '\n':
7025     case ';':
7026     case '(':
7027     case ')':
7028     case '|':
7029     case '&':
7030     case '{':
7031     case '}':           /* XXX */
7032     case AND_AND:
7033     case BANG:
7034     case BAR_AND:
7035     case DO:
7036     case DONE:
7037     case ELIF:
7038     case ELSE:
7039     case ESAC:
7040     case FI:
7041     case IF:
7042     case OR_OR:
7043     case SEMI_SEMI:
7044     case SEMI_AND:
7045     case SEMI_SEMI_AND:
7046     case THEN:
7047     case TIME:
7048     case TIMEOPT:
7049     case COPROC:
7050     case UNTIL:
7051     case WHILE:
7052     case 0:
7053       return 1;
7054     default:
7055 #if defined (COPROCESS_SUPPORT)
7056       if (last_read_token == WORD && token_before_that == COPROC)
7057         return 1;
7058 #endif
7059       return 0;
7060     }
7061 }
7062
7063 /* Return the index of TOKEN in the alist of reserved words, or -1 if
7064    TOKEN is not a shell reserved word. */
7065 int
7066 find_reserved_word (tokstr)
7067      char *tokstr;
7068 {
7069   int i;
7070   for (i = 0; word_token_alist[i].word; i++)
7071     if (STREQ (tokstr, word_token_alist[i].word))
7072       return i;
7073   return -1;
7074 }
7075
7076 #if 0
7077 #if defined (READLINE)
7078 /* Called after each time readline is called.  This insures that whatever
7079    the new prompt string is gets propagated to readline's local prompt
7080    variable. */
7081 static void
7082 reset_readline_prompt ()
7083 {
7084   char *temp_prompt;
7085
7086   if (prompt_string_pointer)
7087     {
7088       temp_prompt = (*prompt_string_pointer)
7089                         ? decode_prompt_string (*prompt_string_pointer)
7090                         : (char *)NULL;
7091
7092       if (temp_prompt == 0)
7093         {
7094           temp_prompt = (char *)xmalloc (1);
7095           temp_prompt[0] = '\0';
7096         }
7097
7098       FREE (current_readline_prompt);
7099       current_readline_prompt = temp_prompt;
7100     }
7101 }
7102 #endif /* READLINE */
7103 #endif /* 0 */
7104
7105 #if defined (HISTORY)
7106 /* A list of tokens which can be followed by newlines, but not by
7107    semi-colons.  When concatenating multiple lines of history, the
7108    newline separator for such tokens is replaced with a space. */
7109 static const int no_semi_successors[] = {
7110   '\n', '{', '(', ')', ';', '&', '|',
7111   CASE, DO, ELSE, IF, SEMI_SEMI, SEMI_AND, SEMI_SEMI_AND, THEN, UNTIL,
7112   WHILE, AND_AND, OR_OR, IN,
7113   0
7114 };
7115
7116 /* If we are not within a delimited expression, try to be smart
7117    about which separators can be semi-colons and which must be
7118    newlines.  Returns the string that should be added into the
7119    history entry. */
7120 char *
7121 history_delimiting_chars ()
7122 {
7123   register int i;
7124
7125   if (dstack.delimiter_depth != 0)
7126     return ("\n");
7127
7128   /* We look for current_command_line_count == 2 because we are looking to
7129      add the first line of the body of the here document (the second line
7130      of the command). */
7131   if (parser_state & PST_HEREDOC)
7132     return (current_command_line_count == 2 ? "\n" : "");
7133
7134   /* First, handle some special cases. */
7135   /*(*/
7136   /* If we just read `()', assume it's a function definition, and don't
7137      add a semicolon.  If the token before the `)' was not `(', and we're
7138      not in the midst of parsing a case statement, assume it's a
7139      parenthesized command and add the semicolon. */
7140   /*)(*/
7141   if (token_before_that == ')')
7142     {
7143       if (two_tokens_ago == '(')        /*)*/   /* function def */
7144         return " ";
7145       /* This does not work for subshells inside case statement
7146          command lists.  It's a suboptimal solution. */
7147       else if (parser_state & PST_CASESTMT)     /* case statement pattern */
7148         return " ";
7149       else
7150         return "; ";                            /* (...) subshell */
7151     }
7152   else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
7153     return " ";         /* function def using `function name' without `()' */
7154
7155   else if (token_before_that == WORD && two_tokens_ago == FOR)
7156     {
7157       /* Tricky.  `for i\nin ...' should not have a semicolon, but
7158          `for i\ndo ...' should.  We do what we can. */
7159       for (i = shell_input_line_index; whitespace (shell_input_line[i]); i++)
7160         ;
7161       if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
7162         return " ";
7163       return ";";
7164     }
7165   else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
7166     return " ";
7167
7168   for (i = 0; no_semi_successors[i]; i++)
7169     {
7170       if (token_before_that == no_semi_successors[i])
7171         return (" ");
7172     }
7173
7174   return ("; ");
7175 }
7176 #endif /* HISTORY */
7177
7178 /* Issue a prompt, or prepare to issue a prompt when the next character
7179    is read. */
7180 static void
7181 prompt_again ()
7182 {
7183   char *temp_prompt;
7184
7185   if (interactive == 0 || expanding_alias ())   /* XXX */
7186     return;
7187
7188   ps1_prompt = get_string_value ("PS1");
7189   ps2_prompt = get_string_value ("PS2");
7190
7191   if (!prompt_string_pointer)
7192     prompt_string_pointer = &ps1_prompt;
7193
7194   temp_prompt = *prompt_string_pointer
7195                         ? decode_prompt_string (*prompt_string_pointer)
7196                         : (char *)NULL;
7197
7198   if (temp_prompt == 0)
7199     {
7200       temp_prompt = (char *)xmalloc (1);
7201       temp_prompt[0] = '\0';
7202     }
7203
7204   current_prompt_string = *prompt_string_pointer;
7205   prompt_string_pointer = &ps2_prompt;
7206
7207 #if defined (READLINE)
7208   if (!no_line_editing)
7209     {
7210       FREE (current_readline_prompt);
7211       current_readline_prompt = temp_prompt;
7212     }
7213   else
7214 #endif  /* READLINE */
7215     {
7216       FREE (current_decoded_prompt);
7217       current_decoded_prompt = temp_prompt;
7218     }
7219 }
7220
7221 int
7222 get_current_prompt_level ()
7223 {
7224   return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
7225 }
7226
7227 void
7228 set_current_prompt_level (x)
7229      int x;
7230 {
7231   prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
7232   current_prompt_string = *prompt_string_pointer;
7233 }
7234
7235 static void
7236 print_prompt ()
7237 {
7238   fprintf (stderr, "%s", current_decoded_prompt);
7239   fflush (stderr);
7240 }
7241
7242 /* Return a string which will be printed as a prompt.  The string
7243    may contain special characters which are decoded as follows:
7244
7245         \a      bell (ascii 07)
7246         \d      the date in Day Mon Date format
7247         \e      escape (ascii 033)
7248         \h      the hostname up to the first `.'
7249         \H      the hostname
7250         \j      the number of active jobs
7251         \l      the basename of the shell's tty device name
7252         \n      CRLF
7253         \r      CR
7254         \s      the name of the shell
7255         \t      the time in 24-hour hh:mm:ss format
7256         \T      the time in 12-hour hh:mm:ss format
7257         \@      the time in 12-hour hh:mm am/pm format
7258         \A      the time in 24-hour hh:mm format
7259         \D{fmt} the result of passing FMT to strftime(3)
7260         \u      your username
7261         \v      the version of bash (e.g., 2.00)
7262         \V      the release of bash, version + patchlevel (e.g., 2.00.0)
7263         \w      the current working directory
7264         \W      the last element of $PWD
7265         \!      the history number of this command
7266         \#      the command number of this command
7267         \$      a $ or a # if you are root
7268         \nnn    character code nnn in octal
7269         \\      a backslash
7270         \[      begin a sequence of non-printing chars
7271         \]      end a sequence of non-printing chars
7272 */
7273 #define PROMPT_GROWTH 48
7274 char *
7275 decode_prompt_string (string)
7276      char *string;
7277 {
7278   WORD_LIST *list;
7279   char *result, *t;
7280   struct dstack save_dstack;
7281   int last_exit_value, last_comsub_pid;
7282 #if defined (PROMPT_STRING_DECODE)
7283   int result_size, result_index;
7284   int c, n, i;
7285   char *temp, octal_string[4];
7286   struct tm *tm;
7287   time_t the_time;
7288   char timebuf[128];
7289   char *timefmt;
7290
7291   result = (char *)xmalloc (result_size = PROMPT_GROWTH);
7292   result[result_index = 0] = 0;
7293   temp = (char *)NULL;
7294
7295   while (c = *string++)
7296     {
7297       if (posixly_correct && c == '!')
7298         {
7299           if (*string == '!')
7300             {
7301               temp = savestring ("!");
7302               goto add_string;
7303             }
7304           else
7305             {
7306 #if !defined (HISTORY)
7307                 temp = savestring ("1");
7308 #else /* HISTORY */
7309                 temp = itos (history_number ());
7310 #endif /* HISTORY */
7311                 string--;       /* add_string increments string again. */
7312                 goto add_string;
7313             }
7314         }
7315       if (c == '\\')
7316         {
7317           c = *string;
7318
7319           switch (c)
7320             {
7321             case '0':
7322             case '1':
7323             case '2':
7324             case '3':
7325             case '4':
7326             case '5':
7327             case '6':
7328             case '7':
7329               strncpy (octal_string, string, 3);
7330               octal_string[3] = '\0';
7331
7332               n = read_octal (octal_string);
7333               temp = (char *)xmalloc (3);
7334
7335               if (n == CTLESC || n == CTLNUL)
7336                 {
7337                   temp[0] = CTLESC;
7338                   temp[1] = n;
7339                   temp[2] = '\0';
7340                 }
7341               else if (n == -1)
7342                 {
7343                   temp[0] = '\\';
7344                   temp[1] = '\0';
7345                 }
7346               else
7347                 {
7348                   temp[0] = n;
7349                   temp[1] = '\0';
7350                 }
7351
7352               for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
7353                 string++;
7354
7355               c = 0;            /* tested at add_string: */
7356               goto add_string;
7357
7358             case 'd':
7359             case 't':
7360             case 'T':
7361             case '@':
7362             case 'A':
7363               /* Make the current time/date into a string. */
7364               (void) time (&the_time);
7365               tm = localtime (&the_time);
7366
7367               if (c == 'd')
7368                 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
7369               else if (c == 't')
7370                 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
7371               else if (c == 'T')
7372                 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
7373               else if (c == '@')
7374                 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
7375               else if (c == 'A')
7376                 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
7377
7378               if (n == 0)
7379                 timebuf[0] = '\0';
7380               else
7381                 timebuf[sizeof(timebuf) - 1] = '\0';
7382
7383               temp = savestring (timebuf);
7384               goto add_string;
7385
7386             case 'D':           /* strftime format */
7387               if (string[1] != '{')             /* } */
7388                 goto not_escape;
7389
7390               (void) time (&the_time);
7391               tm = localtime (&the_time);
7392               string += 2;                      /* skip { */
7393               timefmt = xmalloc (strlen (string) + 3);
7394               for (t = timefmt; *string && *string != '}'; )
7395                 *t++ = *string++;
7396               *t = '\0';
7397               c = *string;      /* tested at add_string */
7398               if (timefmt[0] == '\0')
7399                 {
7400                   timefmt[0] = '%';
7401                   timefmt[1] = 'X';     /* locale-specific current time */
7402                   timefmt[2] = '\0';
7403                 }
7404               n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
7405               free (timefmt);
7406
7407               if (n == 0)
7408                 timebuf[0] = '\0';
7409               else
7410                 timebuf[sizeof(timebuf) - 1] = '\0';
7411
7412               if (promptvars || posixly_correct)
7413                 /* Make sure that expand_prompt_string is called with a
7414                    second argument of Q_DOUBLE_QUOTES if we use this
7415                    function here. */
7416                 temp = sh_backslash_quote_for_double_quotes (timebuf);
7417               else
7418                 temp = savestring (timebuf);
7419               goto add_string;
7420
7421             case 'n':
7422               temp = (char *)xmalloc (3);
7423               temp[0] = no_line_editing ? '\n' : '\r';
7424               temp[1] = no_line_editing ? '\0' : '\n';
7425               temp[2] = '\0';
7426               goto add_string;
7427
7428             case 's':
7429               temp = base_pathname (shell_name);
7430               temp = savestring (temp);
7431               goto add_string;
7432
7433             case 'v':
7434             case 'V':
7435               temp = (char *)xmalloc (16);
7436               if (c == 'v')
7437                 strcpy (temp, dist_version);
7438               else
7439                 sprintf (temp, "%s.%d", dist_version, patch_level);
7440               goto add_string;
7441
7442             case 'w':
7443             case 'W':
7444               {
7445                 /* Use the value of PWD because it is much more efficient. */
7446                 char t_string[PATH_MAX];
7447                 int tlen;
7448
7449                 temp = get_string_value ("PWD");
7450
7451                 if (temp == 0)
7452                   {
7453                     if (getcwd (t_string, sizeof(t_string)) == 0)
7454                       {
7455                         t_string[0] = '.';
7456                         tlen = 1;
7457                       }
7458                     else
7459                       tlen = strlen (t_string);
7460                   }
7461                 else
7462                   {
7463                     tlen = sizeof (t_string) - 1;
7464                     strncpy (t_string, temp, tlen);
7465                   }
7466                 t_string[tlen] = '\0';
7467
7468 #if defined (MACOSX)
7469                 /* Convert from "fs" format to "input" format */
7470                 temp = fnx_fromfs (t_string, strlen (t_string));
7471                 if (temp != t_string)
7472                   strcpy (t_string, temp);
7473 #endif
7474
7475 #define ROOT_PATH(x)    ((x)[0] == '/' && (x)[1] == 0)
7476 #define DOUBLE_SLASH_ROOT(x)    ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
7477                 /* Abbreviate \W as ~ if $PWD == $HOME */
7478                 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
7479                   {
7480                     if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
7481                       {
7482                         t = strrchr (t_string, '/');
7483                         if (t)
7484                           strcpy (t_string, t + 1);
7485                       }
7486                   }
7487 #undef ROOT_PATH
7488 #undef DOUBLE_SLASH_ROOT
7489                 else
7490                   /* polite_directory_format is guaranteed to return a string
7491                      no longer than PATH_MAX - 1 characters. */
7492                   strcpy (t_string, polite_directory_format (t_string));
7493
7494                 temp = trim_pathname (t_string, PATH_MAX - 1);
7495                 /* If we're going to be expanding the prompt string later,
7496                    quote the directory name. */
7497                 if (promptvars || posixly_correct)
7498                   /* Make sure that expand_prompt_string is called with a
7499                      second argument of Q_DOUBLE_QUOTES if we use this
7500                      function here. */
7501                   temp = sh_backslash_quote_for_double_quotes (t_string);
7502                 else
7503                   temp = savestring (t_string);
7504
7505                 goto add_string;
7506               }
7507
7508             case 'u':
7509               if (current_user.user_name == 0)
7510                 get_current_user_info ();
7511               temp = savestring (current_user.user_name);
7512               goto add_string;
7513
7514             case 'h':
7515             case 'H':
7516               temp = savestring (current_host_name);
7517               if (c == 'h' && (t = (char *)strchr (temp, '.')))
7518                 *t = '\0';
7519               goto add_string;
7520
7521             case '#':
7522               temp = itos (current_command_number);
7523               goto add_string;
7524
7525             case '!':
7526 #if !defined (HISTORY)
7527               temp = savestring ("1");
7528 #else /* HISTORY */
7529               temp = itos (history_number ());
7530 #endif /* HISTORY */
7531               goto add_string;
7532
7533             case '$':
7534               t = temp = (char *)xmalloc (3);
7535               if ((promptvars || posixly_correct) && (current_user.euid != 0))
7536                 *t++ = '\\';
7537               *t++ = current_user.euid == 0 ? '#' : '$';
7538               *t = '\0';
7539               goto add_string;
7540
7541             case 'j':
7542               temp = itos (count_all_jobs ());
7543               goto add_string;
7544
7545             case 'l':
7546 #if defined (HAVE_TTYNAME)
7547               temp = (char *)ttyname (fileno (stdin));
7548               t = temp ? base_pathname (temp) : "tty";
7549               temp = savestring (t);
7550 #else
7551               temp = savestring ("tty");
7552 #endif /* !HAVE_TTYNAME */
7553               goto add_string;
7554
7555 #if defined (READLINE)
7556             case '[':
7557             case ']':
7558               if (no_line_editing)
7559                 {
7560                   string++;
7561                   break;
7562                 }
7563               temp = (char *)xmalloc (3);
7564               n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
7565               i = 0;
7566               if (n == CTLESC || n == CTLNUL)
7567                 temp[i++] = CTLESC;
7568               temp[i++] = n;
7569               temp[i] = '\0';
7570               goto add_string;
7571 #endif /* READLINE */
7572
7573             case '\\':
7574             case 'a':
7575             case 'e':
7576             case 'r':
7577               temp = (char *)xmalloc (2);
7578               if (c == 'a')
7579                 temp[0] = '\07';
7580               else if (c == 'e')
7581                 temp[0] = '\033';
7582               else if (c == 'r')
7583                 temp[0] = '\r';
7584               else                      /* (c == '\\') */
7585                 temp[0] = c;
7586               temp[1] = '\0';
7587               goto add_string;
7588
7589             default:
7590 not_escape:
7591               temp = (char *)xmalloc (3);
7592               temp[0] = '\\';
7593               temp[1] = c;
7594               temp[2] = '\0';
7595
7596             add_string:
7597               if (c)
7598                 string++;
7599               result =
7600                 sub_append_string (temp, result, &result_index, &result_size);
7601               temp = (char *)NULL; /* Freed in sub_append_string (). */
7602               result[result_index] = '\0';
7603               break;
7604             }
7605         }
7606       else
7607         {
7608           RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
7609           result[result_index++] = c;
7610           result[result_index] = '\0';
7611         }
7612     }
7613 #else /* !PROMPT_STRING_DECODE */
7614   result = savestring (string);
7615 #endif /* !PROMPT_STRING_DECODE */
7616
7617   /* Save the delimiter stack and point `dstack' to temp space so any
7618      command substitutions in the prompt string won't result in screwing
7619      up the parser's quoting state. */
7620   save_dstack = dstack;
7621   dstack = temp_dstack;
7622   dstack.delimiter_depth = 0;
7623
7624   /* Perform variable and parameter expansion and command substitution on
7625      the prompt string. */
7626   if (promptvars || posixly_correct)
7627     {
7628       last_exit_value = last_command_exit_value;
7629       last_comsub_pid = last_command_subst_pid;
7630       list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
7631       free (result);
7632       result = string_list (list);
7633       dispose_words (list);
7634       last_command_exit_value = last_exit_value;
7635       last_command_subst_pid = last_comsub_pid;
7636     }
7637   else
7638     {
7639       t = dequote_string (result);
7640       free (result);
7641       result = t;
7642     }
7643
7644   dstack = save_dstack;
7645
7646   return (result);
7647 }
7648
7649 /************************************************
7650  *                                              *
7651  *              ERROR HANDLING                  *
7652  *                                              *
7653  ************************************************/
7654
7655 /* Report a syntax error, and restart the parser.  Call here for fatal
7656    errors. */
7657 int
7658 yyerror (msg)
7659      const char *msg;
7660 {
7661   report_syntax_error ((char *)NULL);
7662   reset_parser ();
7663   return (0);
7664 }
7665
7666 static char *
7667 error_token_from_token (tok)
7668      int tok;
7669 {
7670   char *t;
7671
7672   if (t = find_token_in_alist (tok, word_token_alist, 0))
7673     return t;
7674
7675   if (t = find_token_in_alist (tok, other_token_alist, 0))
7676     return t;
7677
7678   t = (char *)NULL;
7679   /* This stuff is dicy and needs closer inspection */
7680   switch (current_token)
7681     {
7682     case WORD:
7683     case ASSIGNMENT_WORD:
7684       if (yylval.word)
7685         t = savestring (yylval.word->word);
7686       break;
7687     case NUMBER:
7688       t = itos (yylval.number);
7689       break;
7690     case ARITH_CMD:
7691       if (yylval.word_list)
7692         t = string_list (yylval.word_list);
7693       break;
7694     case ARITH_FOR_EXPRS:
7695       if (yylval.word_list)
7696         t = string_list_internal (yylval.word_list, " ; ");
7697       break;
7698     case COND_CMD:
7699       t = (char *)NULL;         /* punt */
7700       break;
7701     }
7702
7703   return t;
7704 }
7705
7706 static char *
7707 error_token_from_text ()
7708 {
7709   char *msg, *t;
7710   int token_end, i;
7711
7712   t = shell_input_line;
7713   i = shell_input_line_index;
7714   token_end = 0;
7715   msg = (char *)NULL;
7716
7717   if (i && t[i] == '\0')
7718     i--;
7719
7720   while (i && (whitespace (t[i]) || t[i] == '\n'))
7721     i--;
7722
7723   if (i)
7724     token_end = i + 1;
7725
7726   while (i && (member (t[i], " \n\t;|&") == 0))
7727     i--;
7728
7729   while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
7730     i++;
7731
7732   /* Return our idea of the offending token. */
7733   if (token_end || (i == 0 && token_end == 0))
7734     {
7735       if (token_end)
7736         msg = substring (t, i, token_end);
7737       else      /* one-character token */
7738         {
7739           msg = (char *)xmalloc (2);
7740           msg[0] = t[i];
7741           msg[1] = '\0';
7742         }
7743     }
7744
7745   return (msg);
7746 }
7747
7748 static void
7749 print_offending_line ()
7750 {
7751   char *msg;
7752   int token_end;
7753
7754   msg = savestring (shell_input_line);
7755   token_end = strlen (msg);
7756   while (token_end && msg[token_end - 1] == '\n')
7757     msg[--token_end] = '\0';
7758
7759   parser_error (line_number, "`%s'", msg);
7760   free (msg);
7761 }
7762
7763 /* Report a syntax error with line numbers, etc.
7764    Call here for recoverable errors.  If you have a message to print,
7765    then place it in MESSAGE, otherwise pass NULL and this will figure
7766    out an appropriate message for you. */
7767 static void
7768 report_syntax_error (message)
7769      char *message;
7770 {
7771   char *msg;
7772
7773   if (message)
7774     {
7775       parser_error (line_number, "%s", message);
7776       if (interactive && EOF_Reached)
7777         EOF_Reached = 0;
7778       last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
7779       return;
7780     }
7781
7782   /* If the line of input we're reading is not null, try to find the
7783      objectionable token.  First, try to figure out what token the
7784      parser's complaining about by looking at current_token. */
7785   if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
7786     {
7787       parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
7788       free (msg);
7789
7790       if (interactive == 0)
7791         print_offending_line ();
7792
7793       last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
7794       return;
7795     }
7796
7797   /* If looking at the current token doesn't prove fruitful, try to find the
7798      offending token by analyzing the text of the input line near the current
7799      input line index and report what we find. */
7800   if (shell_input_line && *shell_input_line)
7801     {
7802       msg = error_token_from_text ();
7803       if (msg)
7804         {
7805           parser_error (line_number, _("syntax error near `%s'"), msg);
7806           free (msg);
7807         }
7808
7809       /* If not interactive, print the line containing the error. */
7810       if (interactive == 0)
7811         print_offending_line ();
7812     }
7813   else
7814     {
7815       msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
7816       parser_error (line_number, "%s", msg);
7817       /* When the shell is interactive, this file uses EOF_Reached
7818          only for error reporting.  Other mechanisms are used to
7819          decide whether or not to exit. */
7820       if (interactive && EOF_Reached)
7821         EOF_Reached = 0;
7822     }
7823
7824   last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
7825 }
7826
7827 /* ??? Needed function. ??? We have to be able to discard the constructs
7828    created during parsing.  In the case of error, we want to return
7829    allocated objects to the memory pool.  In the case of no error, we want
7830    to throw away the information about where the allocated objects live.
7831    (dispose_command () will actually free the command.) */
7832 static void
7833 discard_parser_constructs (error_p)
7834      int error_p;
7835 {
7836 }
7837
7838 /************************************************
7839  *                                              *
7840  *              EOF HANDLING                    *
7841  *                                              *
7842  ************************************************/
7843
7844 /* Do that silly `type "bye" to exit' stuff.  You know, "ignoreeof". */
7845
7846 /* A flag denoting whether or not ignoreeof is set. */
7847 int ignoreeof = 0;
7848
7849 /* The number of times that we have encountered an EOF character without
7850    another character intervening.  When this gets above the limit, the
7851    shell terminates. */
7852 int eof_encountered = 0;
7853
7854 /* The limit for eof_encountered. */
7855 int eof_encountered_limit = 10;
7856
7857 /* If we have EOF as the only input unit, this user wants to leave
7858    the shell.  If the shell is not interactive, then just leave.
7859    Otherwise, if ignoreeof is set, and we haven't done this the
7860    required number of times in a row, print a message. */
7861 static void
7862 handle_eof_input_unit ()
7863 {
7864   if (interactive)
7865     {
7866       /* shell.c may use this to decide whether or not to write out the
7867          history, among other things.  We use it only for error reporting
7868          in this file. */
7869       if (EOF_Reached)
7870         EOF_Reached = 0;
7871
7872       /* If the user wants to "ignore" eof, then let her do so, kind of. */
7873       if (ignoreeof)
7874         {
7875           if (eof_encountered < eof_encountered_limit)
7876             {
7877               fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
7878                        login_shell ? "logout" : "exit");
7879               eof_encountered++;
7880               /* Reset the parsing state. */
7881               last_read_token = current_token = '\n';
7882               /* Reset the prompt string to be $PS1. */
7883               prompt_string_pointer = (char **)NULL;
7884               prompt_again ();
7885               return;
7886             }
7887         }
7888
7889       /* In this case EOF should exit the shell.  Do it now. */
7890       reset_parser ();
7891       exit_builtin ((WORD_LIST *)NULL);
7892     }
7893   else
7894     {
7895       /* We don't write history files, etc., for non-interactive shells. */
7896       EOF_Reached = 1;
7897     }
7898 }
7899
7900 /************************************************
7901  *                                              *
7902  *      STRING PARSING FUNCTIONS                *
7903  *                                              *
7904  ************************************************/
7905
7906 /* It's very important that these two functions treat the characters
7907    between ( and ) identically. */
7908
7909 static WORD_LIST parse_string_error;
7910
7911 /* Take a string and run it through the shell parser, returning the
7912    resultant word list.  Used by compound array assignment. */
7913 WORD_LIST *
7914 parse_string_to_word_list (s, flags, whom)
7915      char *s;
7916      int flags;
7917      const char *whom;
7918 {
7919   WORD_LIST *wl;
7920   int tok, orig_current_token, orig_line_number, orig_input_terminator;
7921   int orig_line_count;
7922   int old_echo_input, old_expand_aliases;
7923 #if defined (HISTORY)
7924   int old_remember_on_history, old_history_expansion_inhibited;
7925 #endif
7926
7927 #if defined (HISTORY)
7928   old_remember_on_history = remember_on_history;
7929 #  if defined (BANG_HISTORY)
7930   old_history_expansion_inhibited = history_expansion_inhibited;
7931 #  endif
7932   bash_history_disable ();
7933 #endif
7934
7935   orig_line_number = line_number;
7936   orig_line_count = current_command_line_count;
7937   orig_input_terminator = shell_input_line_terminator;
7938   old_echo_input = echo_input_at_read;
7939   old_expand_aliases = expand_aliases;
7940
7941   push_stream (1);
7942   last_read_token = WORD;               /* WORD to allow reserved words here */
7943   current_command_line_count = 0;
7944   echo_input_at_read = expand_aliases = 0;
7945
7946   with_input_from_string (s, whom);
7947   wl = (WORD_LIST *)NULL;
7948
7949   if (flags & 1)
7950     parser_state |= PST_COMPASSIGN|PST_REPARSE;
7951
7952   while ((tok = read_token (READ)) != yacc_EOF)
7953     {
7954       if (tok == '\n' && *bash_input.location.string == '\0')
7955         break;
7956       if (tok == '\n')          /* Allow newlines in compound assignments */
7957         continue;
7958       if (tok != WORD && tok != ASSIGNMENT_WORD)
7959         {
7960           line_number = orig_line_number + line_number - 1;
7961           orig_current_token = current_token;
7962           current_token = tok;
7963           yyerror (NULL);       /* does the right thing */
7964           current_token = orig_current_token;
7965           if (wl)
7966             dispose_words (wl);
7967           wl = &parse_string_error;
7968           break;
7969         }
7970       wl = make_word_list (yylval.word, wl);
7971     }
7972
7973   last_read_token = '\n';
7974   pop_stream ();
7975
7976 #if defined (HISTORY)
7977   remember_on_history = old_remember_on_history;
7978 #  if defined (BANG_HISTORY)
7979   history_expansion_inhibited = old_history_expansion_inhibited;
7980 #  endif /* BANG_HISTORY */
7981 #endif /* HISTORY */
7982
7983   echo_input_at_read = old_echo_input;
7984   expand_aliases = old_expand_aliases;
7985
7986   current_command_line_count = orig_line_count;
7987   shell_input_line_terminator = orig_input_terminator;
7988
7989   if (flags & 1)
7990     parser_state &= ~(PST_COMPASSIGN|PST_REPARSE);
7991
7992   if (wl == &parse_string_error)
7993     {
7994       last_command_exit_value = EXECUTION_FAILURE;
7995       if (interactive_shell == 0 && posixly_correct)
7996         jump_to_top_level (FORCE_EOF);
7997       else
7998         jump_to_top_level (DISCARD);
7999     }
8000
8001   return (REVERSE_LIST (wl, WORD_LIST *));
8002 }
8003
8004 static char *
8005 parse_compound_assignment (retlenp)
8006      int *retlenp;
8007 {
8008   WORD_LIST *wl, *rl;
8009   int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
8010   char *saved_token, *ret;
8011
8012   saved_token = token;
8013   orig_token_size = token_buffer_size;
8014   orig_line_number = line_number;
8015   orig_last_token = last_read_token;
8016
8017   last_read_token = WORD;       /* WORD to allow reserved words here */
8018
8019   token = (char *)NULL;
8020   token_buffer_size = 0;
8021
8022   assignok = parser_state&PST_ASSIGNOK;         /* XXX */
8023
8024   wl = (WORD_LIST *)NULL;       /* ( */
8025   parser_state |= PST_COMPASSIGN;
8026
8027   while ((tok = read_token (READ)) != ')')
8028     {
8029       if (tok == '\n')                  /* Allow newlines in compound assignments */
8030         {
8031           if (SHOULD_PROMPT ())
8032             prompt_again ();
8033           continue;
8034         }
8035       if (tok != WORD && tok != ASSIGNMENT_WORD)
8036         {
8037           current_token = tok;  /* for error reporting */
8038           if (tok == yacc_EOF)  /* ( */
8039             parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
8040           else
8041             yyerror(NULL);      /* does the right thing */
8042           if (wl)
8043             dispose_words (wl);
8044           wl = &parse_string_error;
8045           break;
8046         }
8047       wl = make_word_list (yylval.word, wl);
8048     }
8049
8050   FREE (token);
8051   token = saved_token;
8052   token_buffer_size = orig_token_size;
8053
8054   parser_state &= ~PST_COMPASSIGN;
8055
8056   if (wl == &parse_string_error)
8057     {
8058       last_command_exit_value = EXECUTION_FAILURE;
8059       last_read_token = '\n';   /* XXX */
8060       if (interactive_shell == 0 && posixly_correct)
8061         jump_to_top_level (FORCE_EOF);
8062       else
8063         jump_to_top_level (DISCARD);
8064     }
8065
8066   last_read_token = orig_last_token;            /* XXX - was WORD? */
8067
8068   if (wl)
8069     {
8070       rl = REVERSE_LIST (wl, WORD_LIST *);
8071       ret = string_list (rl);
8072       dispose_words (rl);
8073     }
8074   else
8075     ret = (char *)NULL;
8076
8077   if (retlenp)
8078     *retlenp = (ret && *ret) ? strlen (ret) : 0;
8079
8080   if (assignok)
8081     parser_state |= PST_ASSIGNOK;
8082
8083   return ret;
8084 }
8085
8086 /************************************************
8087  *                                              *
8088  *   SAVING AND RESTORING PARTIAL PARSE STATE   *
8089  *                                              *
8090  ************************************************/
8091
8092 sh_parser_state_t *
8093 save_parser_state (ps)
8094      sh_parser_state_t *ps;
8095 {
8096 #if defined (ARRAY_VARS)
8097   SHELL_VAR *v;
8098 #endif
8099
8100   if (ps == 0)
8101     ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
8102   if (ps == 0)
8103     return ((sh_parser_state_t *)NULL);
8104
8105   ps->parser_state = parser_state;
8106   ps->token_state = save_token_state ();
8107
8108   ps->input_line_terminator = shell_input_line_terminator;
8109   ps->eof_encountered = eof_encountered;
8110
8111   ps->current_command_line_count = current_command_line_count;
8112
8113 #if defined (HISTORY)
8114   ps->remember_on_history = remember_on_history;
8115 #  if defined (BANG_HISTORY)
8116   ps->history_expansion_inhibited = history_expansion_inhibited;
8117 #  endif
8118 #endif
8119
8120   ps->last_command_exit_value = last_command_exit_value;
8121 #if defined (ARRAY_VARS)
8122   v = find_variable ("PIPESTATUS");
8123   if (v && array_p (v) && array_cell (v))
8124     ps->pipestatus = array_copy (array_cell (v));
8125   else
8126     ps->pipestatus = (ARRAY *)NULL;
8127 #endif
8128
8129   ps->last_shell_builtin = last_shell_builtin;
8130   ps->this_shell_builtin = this_shell_builtin;
8131
8132   ps->expand_aliases = expand_aliases;
8133   ps->echo_input_at_read = echo_input_at_read;
8134
8135   return (ps);
8136 }
8137
8138 void
8139 restore_parser_state (ps)
8140      sh_parser_state_t *ps;
8141 {
8142 #if defined (ARRAY_VARS)
8143   SHELL_VAR *v;
8144 #endif
8145
8146   if (ps == 0)
8147     return;
8148
8149   parser_state = ps->parser_state;
8150   if (ps->token_state)
8151     {
8152       restore_token_state (ps->token_state);
8153       free (ps->token_state);
8154     }
8155
8156   shell_input_line_terminator = ps->input_line_terminator;
8157   eof_encountered = ps->eof_encountered;
8158
8159   current_command_line_count = ps->current_command_line_count;
8160
8161 #if defined (HISTORY)
8162   remember_on_history = ps->remember_on_history;
8163 #  if defined (BANG_HISTORY)
8164   history_expansion_inhibited = ps->history_expansion_inhibited;
8165 #  endif
8166 #endif
8167
8168   last_command_exit_value = ps->last_command_exit_value;
8169 #if defined (ARRAY_VARS)
8170   v = find_variable ("PIPESTATUS");
8171   if (v && array_p (v) && array_cell (v))
8172     {
8173       array_dispose (array_cell (v));
8174       var_setarray (v, ps->pipestatus);
8175     }
8176 #endif
8177
8178   last_shell_builtin = ps->last_shell_builtin;
8179   this_shell_builtin = ps->this_shell_builtin;
8180
8181   expand_aliases = ps->expand_aliases;
8182   echo_input_at_read = ps->echo_input_at_read;
8183 }
8184
8185 /************************************************
8186  *                                              *
8187  *      MULTIBYTE CHARACTER HANDLING            *
8188  *                                              *
8189  ************************************************/
8190
8191 #if defined (HANDLE_MULTIBYTE)
8192 static void
8193 set_line_mbstate ()
8194 {
8195   int i, previ, len, c;
8196   mbstate_t mbs, prevs;
8197   size_t mbclen;
8198
8199   if (shell_input_line == NULL)
8200     return;
8201   len = strlen (shell_input_line);      /* XXX - shell_input_line_len ? */
8202   FREE (shell_input_line_property);
8203   shell_input_line_property = (char *)xmalloc (len + 1);
8204
8205   memset (&prevs, '\0', sizeof (mbstate_t));
8206   for (i = previ = 0; i < len; i++)
8207     {
8208       mbs = prevs;
8209
8210       c = shell_input_line[i];
8211       if (c == EOF)
8212         {
8213           int j;
8214           for (j = i; j < len; j++)
8215             shell_input_line_property[j] = 1;
8216           break;
8217         }
8218
8219       mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
8220       if (mbclen == 1 || mbclen == (size_t)-1)
8221         {
8222           mbclen = 1;
8223           previ = i + 1;
8224         }
8225       else if (mbclen == (size_t)-2)
8226         mbclen = 0;
8227       else if (mbclen > 1)
8228         {
8229           mbclen = 0;
8230           previ = i + 1;
8231           prevs = mbs;
8232         }
8233       else
8234         {
8235           /* XXX - what to do if mbrlen returns 0? (null wide character) */
8236           int j;
8237           for (j = i; j < len; j++)
8238             shell_input_line_property[j] = 1;
8239           break;
8240         }
8241
8242       shell_input_line_property[i] = mbclen;
8243     }
8244 }
8245 #endif /* HANDLE_MULTIBYTE */
8246