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