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