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