y.tab.c

   1
   2 /*  A Bison parser, made from /Users/chet/src/bash/src/parse.y
   3     by GNU Bison version 1.28  */
   4
   5 #define YYBISON 1  /* Identify Bison output.  */
   6
   7 #define IF      257
   8 #define THEN    258
   9 #define ELSE    259
  10 #define ELIF    260
  11 #define FI      261
  12 #define CASE    262
  13 #define ESAC    263
  14 #define FOR     264
  15 #define SELECT  265
  16 #define WHILE   266
  17 #define UNTIL   267
  18 #define DO      268
  19 #define DONE    269
  20 #define FUNCTION        270
  21 #define COND_START      271
  22 #define COND_END        272
  23 #define COND_ERROR      273
  24 #define IN      274
  25 #define BANG    275
  26 #define TIME    276
  27 #define TIMEOPT 277
  28 #define WORD    278
  29 #define ASSIGNMENT_WORD 279
  30 #define NUMBER  280
  31 #define ARITH_CMD       281
  32 #define ARITH_FOR_EXPRS 282
  33 #define COND_CMD        283
  34 #define AND_AND 284
  35 #define OR_OR   285
  36 #define GREATER_GREATER 286
  37 #define LESS_LESS       287
  38 #define LESS_AND        288
  39 #define LESS_LESS_LESS  289
  40 #define GREATER_AND     290
  41 #define SEMI_SEMI       291
  42 #define LESS_LESS_MINUS 292
  43 #define AND_GREATER     293
  44 #define LESS_GREATER    294
  45 #define GREATER_BAR     295
  46 #define yacc_EOF        296
  47
  48 #line 21 "/Users/chet/src/bash/src/parse.y"
  49
  50 #include "config.h"
  51
  52 #include "bashtypes.h"
  53 #include "bashansi.h"
  54
  55 #include "filecntl.h"
  56
  57 #if defined (HAVE_UNISTD_H)
  58 #  include <unistd.h>
  59 #endif
  60
  61 #if defined (HAVE_LOCALE_H)
  62 #  include <locale.h>
  63 #endif
  64
  65 #include <stdio.h>
  66 #include "chartypes.h"
  67 #include <signal.h>
  68
  69 #include "memalloc.h"
  70
  71 #include "bashintl.h"
  72
  73 #define NEED_STRFTIME_DECL      /* used in externs.h */
  74
  75 #include "shell.h"
  76 #include "trap.h"
  77 #include "flags.h"
  78 #include "parser.h"
  79 #include "mailcheck.h"
  80 #include "test.h"
  81 #include "builtins.h"
  82 #include "builtins/common.h"
  83 #include "builtins/builtext.h"
  84
  85 #include "shmbutil.h"
  86
  87 #if defined (READLINE)
  88 #  include "bashline.h"
  89 #  include <readline/readline.h>
  90 #endif /* READLINE */
  91
  92 #if defined (HISTORY)
  93 #  include "bashhist.h"
  94 #  include <readline/history.h>
  95 #endif /* HISTORY */
  96
  97 #if defined (JOB_CONTROL)
  98 #  include "jobs.h"
  99 #endif /* JOB_CONTROL */
 100
 101 #if defined (ALIAS)
 102 #  include "alias.h"
 103 #else
 104 typedef void *alias_t;
 105 #endif /* ALIAS */
 106
 107 #if defined (PROMPT_STRING_DECODE)
 108 #  ifndef _MINIX
 109 #    include <sys/param.h>
 110 #  endif
 111 #  include <time.h>
 112 #  if defined (TM_IN_SYS_TIME)
 113 #    include <sys/types.h>
 114 #    include <sys/time.h>
 115 #  endif /* TM_IN_SYS_TIME */
 116 #  include "maxpath.h"
 117 #endif /* PROMPT_STRING_DECODE */
 118
 119 #define RE_READ_TOKEN   -99
 120 #define NO_EXPANSION    -100
 121
 122 #ifdef DEBUG
 123 #  define YYDEBUG 1
 124 #else
 125 #  define YYDEBUG 0
 126 #endif
 127
 128 #if defined (HANDLE_MULTIBYTE)
 129 #  define last_shell_getc_is_singlebyte \
 130         ((shell_input_line_index > 1) \
 131                 ? shell_input_line_property[shell_input_line_index - 1] \
 132                 : 1)
 133 #  define MBTEST(x)     ((x) && last_shell_getc_is_singlebyte)
 134 #else
 135 #  define last_shell_getc_is_singlebyte 1
 136 #  define MBTEST(x)     ((x))
 137 #endif
 138
 139 #if defined (EXTENDED_GLOB)
 140 extern int extended_glob;
 141 #endif
 142
 143 extern int eof_encountered;
 144 extern int no_line_editing, running_under_emacs;
 145 extern int current_command_number;
 146 extern int sourcelevel;
 147 extern int posixly_correct;
 148 extern int last_command_exit_value;
 149 extern char *shell_name, *current_host_name;
 150 extern char *dist_version;
 151 extern int patch_level;
 152 extern int dump_translatable_strings, dump_po_strings;
 153 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
 154 #if defined (BUFFERED_INPUT)
 155 extern int bash_input_fd_changed;
 156 #endif
 157
 158 extern int errno;
 159 /* **************************************************************** */
 160 /*                                                                  */
 161 /*                  "Forward" declarations                          */
 162 /*                                                                  */
 163 /* **************************************************************** */
 164
 165 #ifdef DEBUG
 166 static void debug_parser __P((int));
 167 #endif
 168
 169 static int yy_getc __P((void));
 170 static int yy_ungetc __P((int));
 171
 172 #if defined (READLINE)
 173 static int yy_readline_get __P((void));
 174 static int yy_readline_unget __P((int));
 175 #endif
 176
 177 static int yy_string_get __P((void));
 178 static int yy_string_unget __P((int));
 179 static int yy_stream_get __P((void));
 180 static int yy_stream_unget __P((int));
 181
 182 static int shell_getc __P((int));
 183 static void shell_ungetc __P((int));
 184 static void discard_until __P((int));
 185
 186 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
 187 static void push_string __P((char *, int, alias_t *));
 188 static void pop_string __P((void));
 189 static void free_string_list __P((void));
 190 #endif
 191
 192 static char *read_a_line __P((int));
 193
 194 static int reserved_word_acceptable __P((int));
 195 static int yylex __P((void));
 196 static int alias_expand_token __P((char *));
 197 static int time_command_acceptable __P((void));
 198 static int special_case_tokens __P((char *));
 199 static int read_token __P((int));
 200 static char *parse_matched_pair __P((int, int, int, int *, int));
 201 #if defined (ARRAY_VARS)
 202 static char *parse_compound_assignment __P((int *));
 203 #endif
 204 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
 205 static int parse_dparen __P((int));
 206 static int parse_arith_cmd __P((char **, int));
 207 #endif
 208 #if defined (COND_COMMAND)
 209 static void cond_error __P((void));
 210 static COND_COM *cond_expr __P((void));
 211 static COND_COM *cond_or __P((void));
 212 static COND_COM *cond_and __P((void));
 213 static COND_COM *cond_term __P((void));
 214 static int cond_skip_newlines __P((void));
 215 static COMMAND *parse_cond_command __P((void));
 216 #endif
 217 #if defined (ARRAY_VARS)
 218 static int token_is_assignment __P((char *, int));
 219 static int token_is_ident __P((char *, int));
 220 #endif
 221 static int read_token_word __P((int));
 222 static void discard_parser_constructs __P((int));
 223
 224 static char *error_token_from_token __P((int));
 225 static char *error_token_from_text __P((void));
 226 static void print_offending_line __P((void));
 227 static void report_syntax_error __P((char *));
 228
 229 static void handle_eof_input_unit __P((void));
 230 static void prompt_again __P((void));
 231 #if 0
 232 static void reset_readline_prompt __P((void));
 233 #endif
 234 static void print_prompt __P((void));
 235
 236 #if defined (HANDLE_MULTIBYTE)
 237 static void set_line_mbstate __P((void));
 238 static char *shell_input_line_property = NULL;
 239 #else
 240 #  define set_line_mbstate()
 241 #endif
 242
 243 extern int yyerror __P((const char *));
 244
 245 #ifdef DEBUG
 246 extern int yydebug;
 247 #endif
 248
 249 /* Default prompt strings */
 250 char *primary_prompt = PPROMPT;
 251 char *secondary_prompt = SPROMPT;
 252
 253 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
 254 char *ps1_prompt, *ps2_prompt;
 255
 256 /* Handle on the current prompt string.  Indirectly points through
 257    ps1_ or ps2_prompt. */
 258 char **prompt_string_pointer = (char **)NULL;
 259 char *current_prompt_string;
 260
 261 /* Non-zero means we expand aliases in commands. */
 262 int expand_aliases = 0;
 263
 264 /* If non-zero, the decoded prompt string undergoes parameter and
 265    variable substitution, command substitution, arithmetic substitution,
 266    string expansion, process substitution, and quote removal in
 267    decode_prompt_string. */
 268 int promptvars = 1;
 269
 270 /* If non-zero, $'...' and $"..." are expanded when they appear within
 271    a ${...} expansion, even when the expansion appears within double
 272    quotes. */
 273 int extended_quote = 1;
 274
 275 /* The decoded prompt string.  Used if READLINE is not defined or if
 276    editing is turned off.  Analogous to current_readline_prompt. */
 277 static char *current_decoded_prompt;
 278
 279 /* The number of lines read from input while creating the current command. */
 280 int current_command_line_count;
 281
 282 /* Variables to manage the task of reading here documents, because we need to
 283    defer the reading until after a complete command has been collected. */
 284 static REDIRECT *redir_stack[10];
 285 int need_here_doc;
 286
 287 /* Where shell input comes from.  History expansion is performed on each
 288    line when the shell is interactive. */
 289 static char *shell_input_line = (char *)NULL;
 290 static int shell_input_line_index;
 291 static int shell_input_line_size;       /* Amount allocated for shell_input_line. */
 292 static int shell_input_line_len;        /* strlen (shell_input_line) */
 293
 294 /* Either zero or EOF. */
 295 static int shell_input_line_terminator;
 296
 297 /* The line number in a script on which a function definition starts. */
 298 static int function_dstart;
 299
 300 /* The line number in a script on which a function body starts. */
 301 static int function_bstart;
 302
 303 /* The line number in a script at which an arithmetic for command starts. */
 304 static int arith_for_lineno;
 305
 306 /* The line number in a script where the word in a `case WORD', `select WORD'
 307    or `for WORD' begins.  This is a nested command maximum, since the array
 308    index is decremented after a case, select, or for command is parsed. */
 309 #define MAX_CASE_NEST   128
 310 static int word_lineno[MAX_CASE_NEST];
 311 static int word_top = -1;
 312
 313 /* If non-zero, it is the token that we want read_token to return
 314    regardless of what text is (or isn't) present to be read.  This
 315    is reset by read_token.  If token_to_read == WORD or
 316    ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
 317 static int token_to_read;
 318 static WORD_DESC *word_desc_to_read;
 319
 320 static REDIRECTEE redir;
 321
 322 #line 295 "/Users/chet/src/bash/src/parse.y"
 323 typedef union {
 324   WORD_DESC *word;              /* the word that we read. */
 325   int number;                   /* the number that we read. */
 326   WORD_LIST *word_list;
 327   COMMAND *command;
 328   REDIRECT *redirect;
 329   ELEMENT element;
 330   PATTERN_LIST *pattern;
 331 } YYSTYPE;
 332 #include <stdio.h>
 333
 334 #ifndef __cplusplus
 335 #ifndef __STDC__
 336 #define const
 337 #endif
 338 #endif
 339
 340
 341
 342 #define YYFINAL         302
 343 #define YYFLAG          -32768
 344 #define YYNTBASE        54
 345
 346 #define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 90)
 347
 348 static const char yytranslate[] = {     0,
 349      2,     2,     2,     2,     2,     2,     2,     2,     2,    44,
 350      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 351      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 352      2,     2,     2,     2,     2,     2,     2,    42,     2,    52,
 353     53,     2,     2,     2,    49,     2,     2,     2,     2,     2,
 354      2,     2,     2,     2,     2,     2,     2,     2,    43,    48,
 355      2,    47,     2,     2,     2,     2,     2,     2,     2,     2,
 356      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 357      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 358      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 359      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 360      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 361      2,     2,    50,    46,    51,     2,     2,     2,     2,     2,
 362      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 363      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 364      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 365      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 366      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 367      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 368      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 369      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 370      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 371      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 372      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 373      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 374      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 375      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 376     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
 377     27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
 378     37,    38,    39,    40,    41,    45
 379 };
 380
 381 #if YYDEBUG != 0
 382 static const short yyprhs[] = {     0,
 383      0,     3,     5,     8,    10,    12,    15,    18,    21,    25,
 384     29,    32,    36,    39,    43,    46,    50,    53,    57,    60,
 385     64,    67,    71,    74,    78,    81,    85,    88,    92,    95,
 386     99,   102,   106,   109,   112,   116,   118,   120,   122,   124,
 387    127,   129,   132,   134,   136,   139,   141,   143,   145,   151,
 388    157,   159,   161,   163,   165,   167,   169,   171,   178,   185,
 389    193,   201,   212,   223,   233,   243,   251,   259,   265,   271,
 390    278,   285,   293,   301,   312,   323,   330,   338,   345,   351,
 391    358,   363,   365,   368,   372,   378,   386,   393,   397,   399,
 392    403,   408,   415,   421,   423,   426,   431,   436,   442,   448,
 393    451,   455,   457,   461,   464,   466,   469,   473,   477,   481,
 394    486,   491,   496,   501,   506,   508,   510,   512,   514,   516,
 395    518,   519,   522,   524,   527,   530,   535,   540,   544,   548,
 396    550,   552,   555,   558,   562,   566,   569,   574,   576,   578
 397 };
 398
 399 static const short yyrhs[] = {    85,
 400     82,     0,    44,     0,     1,    44,     0,    45,     0,    24,
 401      0,    55,    24,     0,    47,    24,     0,    48,    24,     0,
 402     26,    47,    24,     0,    26,    48,    24,     0,    32,    24,
 403      0,    26,    32,    24,     0,    33,    24,     0,    26,    33,
 404     24,     0,    35,    24,     0,    26,    35,    24,     0,    34,
 405     26,     0,    26,    34,    26,     0,    36,    26,     0,    26,
 406     36,    26,     0,    34,    24,     0,    26,    34,    24,     0,
 407     36,    24,     0,    26,    36,    24,     0,    38,    24,     0,
 408     26,    38,    24,     0,    36,    49,     0,    26,    36,    49,
 409      0,    34,    49,     0,    26,    34,    49,     0,    39,    24,
 410      0,    26,    40,    24,     0,    40,    24,     0,    41,    24,
 411      0,    26,    41,    24,     0,    24,     0,    25,     0,    56,
 412      0,    56,     0,    58,    56,     0,    57,     0,    59,    57,
 413      0,    59,     0,    61,     0,    61,    58,     0,    66,     0,
 414     62,     0,    65,     0,    12,    79,    14,    79,    15,     0,
 415     13,    79,    14,    79,    15,     0,    64,     0,    69,     0,
 416     68,     0,    70,     0,    71,     0,    72,     0,    63,     0,
 417     10,    24,    84,    14,    79,    15,     0,    10,    24,    84,
 418     50,    79,    51,     0,    10,    24,    43,    84,    14,    79,
 419     15,     0,    10,    24,    43,    84,    50,    79,    51,     0,
 420     10,    24,    84,    20,    55,    83,    84,    14,    79,    15,
 421      0,    10,    24,    84,    20,    55,    83,    84,    50,    79,
 422     51,     0,    10,    24,    84,    20,    83,    84,    14,    79,
 423     15,     0,    10,    24,    84,    20,    83,    84,    50,    79,
 424     51,     0,    10,    28,    83,    84,    14,    79,    15,     0,
 425     10,    28,    83,    84,    50,    79,    51,     0,    10,    28,
 426     14,    79,    15,     0,    10,    28,    50,    79,    51,     0,
 427     11,    24,    84,    14,    78,    15,     0,    11,    24,    84,
 428     50,    78,    51,     0,    11,    24,    43,    84,    14,    78,
 429     15,     0,    11,    24,    43,    84,    50,    78,    51,     0,
 430     11,    24,    84,    20,    55,    83,    84,    14,    78,    15,
 431      0,    11,    24,    84,    20,    55,    83,    84,    50,    78,
 432     51,     0,     8,    24,    84,    20,    84,     9,     0,     8,
 433     24,    84,    20,    76,    84,     9,     0,     8,    24,    84,
 434     20,    74,     9,     0,    24,    52,    53,    84,    67,     0,
 435     16,    24,    52,    53,    84,    67,     0,    16,    24,    84,
 436     67,     0,    61,     0,    61,    58,     0,    52,    79,    53,
 437      0,     3,    79,     4,    79,     7,     0,     3,    79,     4,
 438     79,     5,    79,     7,     0,     3,    79,     4,    79,    73,
 439      7,     0,    50,    79,    51,     0,    27,     0,    17,    29,
 440     18,     0,     6,    79,     4,    79,     0,     6,    79,     4,
 441     79,     5,    79,     0,     6,    79,     4,    79,    73,     0,
 442     75,     0,    76,    75,     0,    84,    77,    53,    79,     0,
 443     84,    77,    53,    84,     0,    84,    52,    77,    53,    79,
 444      0,    84,    52,    77,    53,    84,     0,    75,    37,     0,
 445     76,    75,    37,     0,    24,     0,    77,    46,    24,     0,
 446     84,    80,     0,    78,     0,    84,    81,     0,    81,    44,
 447     84,     0,    81,    42,    84,     0,    81,    43,    84,     0,
 448     81,    30,    84,    81,     0,    81,    31,    84,    81,     0,
 449     81,    42,    84,    81,     0,    81,    43,    84,    81,     0,
 450     81,    44,    84,    81,     0,    87,     0,    44,     0,    45,
 451      0,    44,     0,    43,     0,    45,     0,     0,    84,    44,
 452      0,    86,     0,    86,    42,     0,    86,    43,     0,    86,
 453     30,    84,    86,     0,    86,    31,    84,    86,     0,    86,
 454     42,    86,     0,    86,    43,    86,     0,    87,     0,    88,
 455      0,    21,    88,     0,    89,    88,     0,    89,    21,    88,
 456      0,    21,    89,    88,     0,    89,    83,     0,    88,    46,
 457     84,    88,     0,    60,     0,    22,     0,    22,    23,     0
 458 };
 459
 460 #endif
 461
 462 #if YYDEBUG != 0
 463 static const short yyrline[] = { 0,
 464    346,   355,   362,   377,   387,   389,   393,   398,   403,   408,
 465    413,   418,   423,   429,   435,   440,   445,   450,   455,   460,
 466    465,   470,   475,   480,   485,   492,   499,   504,   509,   514,
 467    519,   524,   529,   534,   539,   546,   548,   550,   554,   558,
 468    569,   571,   575,   577,   579,   595,   599,   601,   603,   605,
 469    607,   609,   611,   613,   615,   617,   619,   623,   628,   633,
 470    638,   643,   648,   653,   658,   665,   670,   675,   680,   687,
 471    692,   697,   702,   707,   712,   719,   724,   729,   736,   739,
 472    742,   747,   749,   780,   787,   789,   791,   796,   800,   804,
 473    808,   810,   812,   816,   817,   821,   823,   825,   827,   831,
 474    832,   836,   838,   847,   855,   856,   862,   863,   870,   874,
 475    876,   878,   885,   887,   889,   893,   894,   897,   899,   901,
 476    905,   906,   915,   921,   930,   938,   940,   942,   949,   952,
 477    956,   958,   964,   970,   976,   982,  1002,  1005,  1009,  1011
 478 };
 479 #endif
 480
 481
 482 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
 483
 484 static const char * const yytname[] = {   "$","error","$undefined.","IF","THEN",
 485 "ELSE","ELIF","FI","CASE","ESAC","FOR","SELECT","WHILE","UNTIL","DO","DONE",
 486 "FUNCTION","COND_START","COND_END","COND_ERROR","IN","BANG","TIME","TIMEOPT",
 487 "WORD","ASSIGNMENT_WORD","NUMBER","ARITH_CMD","ARITH_FOR_EXPRS","COND_CMD","AND_AND",
 488 "OR_OR","GREATER_GREATER","LESS_LESS","LESS_AND","LESS_LESS_LESS","GREATER_AND",
 489 "SEMI_SEMI","LESS_LESS_MINUS","AND_GREATER","LESS_GREATER","GREATER_BAR","'&'",
 490 "';'","'\\n'","yacc_EOF","'|'","'>'","'<'","'-'","'{'","'}'","'('","')'","inputunit",
 491 "word_list","redirection","simple_command_element","redirection_list","simple_command",
 492 "command","shell_command","for_command","arith_for_command","select_command",
 493 "case_command","function_def","function_body","subshell","if_command","group_command",
 494 "arith_command","cond_command","elif_clause","case_clause","pattern_list","case_clause_sequence",
 495 "pattern","list","compound_list","list0","list1","simple_list_terminator","list_terminator",
 496 "newline_list","simple_list","simple_list1","pipeline_command","pipeline","timespec", NULL
 497 };
 498 #endif
 499
 500 static const short yyr1[] = {     0,
 501     54,    54,    54,    54,    55,    55,    56,    56,    56,    56,
 502     56,    56,    56,    56,    56,    56,    56,    56,    56,    56,
 503     56,    56,    56,    56,    56,    56,    56,    56,    56,    56,
 504     56,    56,    56,    56,    56,    57,    57,    57,    58,    58,
 505     59,    59,    60,    60,    60,    60,    61,    61,    61,    61,
 506     61,    61,    61,    61,    61,    61,    61,    62,    62,    62,
 507     62,    62,    62,    62,    62,    63,    63,    63,    63,    64,
 508     64,    64,    64,    64,    64,    65,    65,    65,    66,    66,
 509     66,    67,    67,    68,    69,    69,    69,    70,    71,    72,
 510     73,    73,    73,    74,    74,    75,    75,    75,    75,    76,
 511     76,    77,    77,    78,    79,    79,    80,    80,    80,    81,
 512     81,    81,    81,    81,    81,    82,    82,    83,    83,    83,
 513     84,    84,    85,    85,    85,    86,    86,    86,    86,    86,
 514     87,    87,    87,    87,    87,    87,    88,    88,    89,    89
 515 };
 516
 517 static const short yyr2[] = {     0,
 518      2,     1,     2,     1,     1,     2,     2,     2,     3,     3,
 519      2,     3,     2,     3,     2,     3,     2,     3,     2,     3,
 520      2,     3,     2,     3,     2,     3,     2,     3,     2,     3,
 521      2,     3,     2,     2,     3,     1,     1,     1,     1,     2,
 522      1,     2,     1,     1,     2,     1,     1,     1,     5,     5,
 523      1,     1,     1,     1,     1,     1,     1,     6,     6,     7,
 524      7,    10,    10,     9,     9,     7,     7,     5,     5,     6,
 525      6,     7,     7,    10,    10,     6,     7,     6,     5,     6,
 526      4,     1,     2,     3,     5,     7,     6,     3,     1,     3,
 527      4,     6,     5,     1,     2,     4,     4,     5,     5,     2,
 528      3,     1,     3,     2,     1,     2,     3,     3,     3,     4,
 529      4,     4,     4,     4,     1,     1,     1,     1,     1,     1,
 530      0,     2,     1,     2,     2,     4,     4,     3,     3,     1,
 531      1,     2,     2,     3,     3,     2,     4,     1,     1,     2
 532 };
 533
 534 static const short yydefact[] = {     0,
 535      0,   121,     0,     0,     0,   121,   121,     0,     0,     0,
 536    139,    36,    37,     0,    89,     0,     0,     0,     0,     0,
 537      0,     0,     0,     0,     2,     4,     0,     0,   121,   121,
 538     38,    41,    43,   138,    44,    47,    57,    51,    48,    46,
 539     53,    52,    54,    55,    56,     0,   123,   130,   131,     0,
 540      3,   105,     0,     0,   121,   121,     0,   121,     0,     0,
 541    121,     0,   132,     0,   140,     0,     0,     0,     0,     0,
 542      0,     0,     0,     0,     0,     0,    11,    13,    21,    17,
 543     29,    15,    23,    19,    27,    25,    31,    33,    34,     7,
 544      8,     0,     0,    36,    42,    39,    45,   116,   117,     1,
 545    121,   121,   124,   125,   121,     0,   119,   118,   120,   136,
 546    133,   121,   122,   104,   106,   115,     0,   121,     0,   121,
 547    121,   121,   121,     0,   121,   121,     0,     0,    90,   135,
 548    121,    12,    14,    22,    18,    30,    16,    24,    20,    28,
 549     26,    32,    35,     9,    10,    88,    84,    40,     0,     0,
 550    128,   129,     0,   134,     0,   121,   121,   121,   121,   121,
 551    121,     0,   121,     0,   121,     0,     0,     0,     0,   121,
 552      0,   121,     0,     0,   121,    82,    81,     0,   126,   127,
 553      0,     0,   137,   121,   121,    85,     0,     0,     0,   108,
 554    109,   107,     0,    94,   121,     0,   121,   121,     0,     5,
 555      0,   121,     0,    68,    69,   121,   121,   121,   121,     0,
 556      0,     0,     0,    49,    50,     0,    83,    79,     0,     0,
 557     87,   110,   111,   112,   113,   114,    78,   100,    95,     0,
 558     76,   102,     0,     0,     0,     0,    58,     6,   121,     0,
 559     59,     0,     0,     0,     0,    70,     0,   121,    71,    80,
 560     86,   121,   121,   121,   121,   101,    77,     0,     0,   121,
 561     60,    61,     0,   121,   121,    66,    67,    72,    73,     0,
 562     91,     0,     0,     0,   121,   103,    96,    97,   121,   121,
 563      0,     0,   121,   121,   121,    93,    98,    99,     0,     0,
 564     64,    65,     0,     0,    92,    62,    63,    74,    75,     0,
 565      0,     0
 566 };
 567
 568 static const short yydefgoto[] = {   300,
 569    201,    31,    32,    97,    33,    34,    35,    36,    37,    38,
 570     39,    40,   177,    41,    42,    43,    44,    45,   187,   193,
 571    194,   195,   234,    52,    53,   114,   115,   100,   110,    54,
 572     46,   151,   116,    49,    50
 573 };
 574
 575 static const short yypact[] = {   274,
 576    -23,-32768,     5,    55,    10,-32768,-32768,    21,    31,   446,
 577     32,    19,-32768,   553,-32768,    56,    72,   -12,    89,   -11,
 578     92,   102,   111,   113,-32768,-32768,   117,   124,-32768,-32768,
 579 -32768,-32768,   183,-32768,   202,-32768,-32768,-32768,-32768,-32768,
 580 -32768,-32768,-32768,-32768,-32768,   -13,   134,-32768,    52,   317,
 581 -32768,-32768,   148,   360,-32768,   115,    22,   120,   154,   173,
 582    114,   155,    52,   532,-32768,   140,   180,   181,   101,   182,
 583    112,   186,   188,   189,   190,   205,-32768,-32768,-32768,-32768,
 584 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 585 -32768,   193,   195,-32768,-32768,-32768,   202,-32768,-32768,-32768,
 586 -32768,-32768,   403,   403,-32768,   532,-32768,-32768,-32768,-32768,
 587     52,-32768,-32768,-32768,   221,-32768,    -9,-32768,    42,-32768,
 588 -32768,-32768,-32768,    61,-32768,-32768,   200,    41,-32768,    52,
 589 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
 590 -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   360,   360,
 591    152,   152,   489,    52,   192,-32768,-32768,-32768,-32768,-32768,
 592 -32768,    26,-32768,   127,-32768,   218,   194,    34,    73,-32768,
 593    215,-32768,   242,   245,-32768,   202,-32768,    41,-32768,-32768,
 594    403,   403,    52,-32768,-32768,-32768,   254,   360,   360,   360,
 595    360,   360,   253,   229,-32768,    -2,-32768,-32768,   252,-32768,
 596    151,-32768,   217,-32768,-32768,-32768,-32768,-32768,-32768,   255,
 597    360,   151,   220,-32768,-32768,    41,   202,-32768,   265,   272,
 598 -32768,-32768,-32768,   159,   159,   159,-32768,-32768,   241,    17,
 599 -32768,-32768,   256,    36,   266,   232,-32768,-32768,-32768,    74,
 600 -32768,   273,   238,   277,   243,-32768,   221,-32768,-32768,-32768,
 601 -32768,-32768,-32768,-32768,-32768,-32768,-32768,   116,   269,-32768,
 602 -32768,-32768,    90,-32768,-32768,-32768,-32768,-32768,-32768,    95,
 603    197,   360,   360,   360,-32768,-32768,-32768,   360,-32768,-32768,
 604    282,   251,-32768,-32768,-32768,-32768,-32768,   360,   288,   260,
 605 -32768,-32768,   289,   280,-32768,-32768,-32768,-32768,-32768,   305,
 606    316,-32768
 607 };
 608
 609 static const short yypgoto[] = {-32768,
 610    146,   -33,   290,   156,-32768,-32768,  -119,-32768,-32768,-32768,
 611 -32768,-32768,  -153,-32768,-32768,-32768,-32768,-32768,    64,-32768,
 612    141,-32768,   104,  -162,    -6,-32768,  -172,-32768,   -52,   -28,
 613 -32768,     6,     4,    -7,   329
 614 };
 615
 616
 617 #define YYLAST          601
 618
 619
 620 static const short yytable[] = {    59,
 621     60,    96,    63,    48,   122,    47,   231,   210,   176,   213,
 622    161,    79,    83,    80,    84,   222,   223,   224,   225,   226,
 623     51,   232,    92,    93,   218,   257,   117,   119,    55,   124,
 624     98,    99,   128,    58,   113,   120,    81,    85,   247,   197,
 625    232,   113,   111,     2,    61,   244,   245,   206,     3,   233,
 626      4,     5,     6,     7,    65,   163,   130,     9,   176,    62,
 627    113,   164,   250,   148,   107,   108,   109,    15,   233,   113,
 628     66,   121,   149,   150,   170,   198,   153,   113,    56,    77,
 629    171,   259,    57,   207,   113,   113,   208,   264,   260,   162,
 630     29,   165,    30,   168,   169,    78,   176,   105,   154,   224,
 631    225,   226,   178,   279,   113,   155,    48,    48,   283,   152,
 632    172,   202,    82,   166,   167,    86,   113,   113,   173,   174,
 633    293,   294,   209,   265,   134,    87,   135,   188,   189,   190,
 634    191,   192,   196,   113,    88,   138,    89,   139,   113,   280,
 635     90,   211,    96,   211,   284,   183,   216,    91,   239,   136,
 636    200,   112,    48,    48,   179,   180,   199,   118,   203,   248,
 637    140,   259,   123,   101,   102,   127,   230,   125,   275,   107,
 638    108,   109,   129,   240,   238,   103,   104,   219,   220,   211,
 639    211,   101,   102,   148,    48,    48,   126,   152,   156,   157,
 640    235,   236,   131,   107,   108,   109,   184,   185,   186,   242,
 641    243,   285,   185,   132,   133,   137,    94,    13,    14,   141,
 642    263,   142,   143,   144,    16,    17,    18,    19,    20,   270,
 643     21,    22,    23,    24,   272,   273,   274,    14,   145,    27,
 644     28,   278,   204,    16,    17,    18,    19,    20,   200,    21,
 645     22,    23,    24,   146,   205,   271,   288,   147,    27,    28,
 646    156,   157,   175,   277,   211,   211,   214,   281,   282,   215,
 647    221,   227,   158,   159,   160,   228,   237,   241,   287,   246,
 648    249,   251,   289,   290,     1,   252,     2,   256,   295,   232,
 649    261,     3,   262,     4,     5,     6,     7,   266,   267,     8,
 650      9,   268,   276,   269,    10,    11,   291,    12,    13,    14,
 651     15,   292,   296,   298,   301,    16,    17,    18,    19,    20,
 652    297,    21,    22,    23,    24,   302,   212,    25,    26,     2,
 653     27,    28,    95,    29,     3,    30,     4,     5,     6,     7,
 654    299,   217,     8,     9,   286,   229,   258,   106,    64,     0,
 655     12,    13,    14,    15,     0,     0,     0,     0,    16,    17,
 656     18,    19,    20,     0,    21,    22,    23,    24,     0,   107,
 657    108,   109,     2,    27,    28,     0,    29,     3,    30,     4,
 658      5,     6,     7,     0,     0,     8,     9,     0,     0,     0,
 659     10,    11,     0,    12,    13,    14,    15,     0,     0,     0,
 660      0,    16,    17,    18,    19,    20,     0,    21,    22,    23,
 661     24,     0,     0,   113,     0,     2,    27,    28,     0,    29,
 662      3,    30,     4,     5,     6,     7,     0,     0,     8,     9,
 663      0,     0,     0,    10,    11,     0,    12,    13,    14,    15,
 664      0,     0,     0,     0,    16,    17,    18,    19,    20,     0,
 665     21,    22,    23,    24,     0,     0,     0,     0,     2,    27,
 666     28,     0,    29,     3,    30,     4,     5,     6,     7,     0,
 667      0,     8,     9,     0,     0,     0,     0,    11,     0,    12,
 668     13,    14,    15,     0,     0,     0,     0,    16,    17,    18,
 669     19,    20,     0,    21,    22,    23,    24,     0,     0,     0,
 670      0,     2,    27,    28,     0,    29,     3,    30,     4,     5,
 671      6,     7,     0,     0,     8,     9,     0,     0,     0,     0,
 672      0,     0,    12,    13,    14,    15,     0,     0,     0,     0,
 673     16,    17,    18,    19,    20,     0,    21,    22,    23,    24,
 674      0,     0,   113,     0,     2,    27,    28,     0,    29,     3,
 675     30,     4,     5,     6,     7,     0,     0,     8,     9,     0,
 676      0,     0,     0,     0,     0,    12,    13,    14,    15,     0,
 677      0,     0,     0,    16,    17,    18,    19,    20,     0,    21,
 678     22,    23,    24,     0,     0,     0,     0,     0,    27,    28,
 679      0,    29,     0,    30,    67,    68,    69,    70,    71,     0,
 680     72,     0,    73,    74,     0,     0,     0,     0,     0,    75,
 681     76
 682 };
 683
 684 static const short yycheck[] = {     6,
 685      7,    35,    10,     0,    57,     0,     9,   170,   128,   172,
 686     20,    24,    24,    26,    26,   188,   189,   190,   191,   192,
 687     44,    24,    29,    30,   178,     9,    55,    56,    24,    58,
 688     44,    45,    61,    24,    44,    14,    49,    49,   211,    14,
 689     24,    44,    50,     3,    24,   208,   209,    14,     8,    52,
 690     10,    11,    12,    13,    23,    14,    64,    17,   178,    29,
 691     44,    20,   216,    97,    43,    44,    45,    27,    52,    44,
 692     52,    50,   101,   102,    14,    50,   105,    44,    24,    24,
 693     20,    46,    28,    50,    44,    44,    14,    14,    53,   118,
 694     50,    50,    52,   122,   123,    24,   216,    46,   106,   272,
 695    273,   274,   131,    14,    44,   112,   103,   104,    14,   104,
 696     50,   164,    24,   120,   121,    24,    44,    44,   125,   126,
 697    283,   284,    50,    50,    24,    24,    26,   156,   157,   158,
 698    159,   160,   161,    44,    24,    24,    24,    26,    44,    50,
 699     24,   170,   176,   172,    50,   153,   175,    24,   201,    49,
 700     24,     4,   149,   150,   149,   150,   163,    43,   165,   212,
 701     49,    46,    43,    30,    31,    52,   195,    14,    53,    43,
 702     44,    45,    18,   202,    24,    42,    43,   184,   185,   208,
 703    209,    30,    31,   217,   181,   182,    14,   182,    30,    31,
 704    197,   198,    53,    43,    44,    45,     5,     6,     7,   206,
 705    207,     5,     6,    24,    24,    24,    24,    25,    26,    24,
 706    239,    24,    24,    24,    32,    33,    34,    35,    36,   248,
 707     38,    39,    40,    41,   253,   254,   255,    26,    24,    47,
 708     48,   260,    15,    32,    33,    34,    35,    36,    24,    38,
 709     39,    40,    41,    51,    51,   252,   275,    53,    47,    48,
 710     30,    31,    53,   260,   283,   284,    15,   264,   265,    15,
 711      7,     9,    42,    43,    44,    37,    15,    51,   275,    15,
 712     51,     7,   279,   280,     1,     4,     3,    37,   285,    24,
 713     15,     8,    51,    10,    11,    12,    13,    15,    51,    16,
 714     17,    15,    24,    51,    21,    22,    15,    24,    25,    26,
 715     27,    51,    15,    15,     0,    32,    33,    34,    35,    36,
 716     51,    38,    39,    40,    41,     0,   171,    44,    45,     3,
 717     47,    48,    33,    50,     8,    52,    10,    11,    12,    13,
 718     51,   176,    16,    17,   271,   195,   233,    21,    10,    -1,
 719     24,    25,    26,    27,    -1,    -1,    -1,    -1,    32,    33,
 720     34,    35,    36,    -1,    38,    39,    40,    41,    -1,    43,
 721     44,    45,     3,    47,    48,    -1,    50,     8,    52,    10,
 722     11,    12,    13,    -1,    -1,    16,    17,    -1,    -1,    -1,
 723     21,    22,    -1,    24,    25,    26,    27,    -1,    -1,    -1,
 724     -1,    32,    33,    34,    35,    36,    -1,    38,    39,    40,
 725     41,    -1,    -1,    44,    -1,     3,    47,    48,    -1,    50,
 726      8,    52,    10,    11,    12,    13,    -1,    -1,    16,    17,
 727     -1,    -1,    -1,    21,    22,    -1,    24,    25,    26,    27,
 728     -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,    -1,
 729     38,    39,    40,    41,    -1,    -1,    -1,    -1,     3,    47,
 730     48,    -1,    50,     8,    52,    10,    11,    12,    13,    -1,
 731     -1,    16,    17,    -1,    -1,    -1,    -1,    22,    -1,    24,
 732     25,    26,    27,    -1,    -1,    -1,    -1,    32,    33,    34,
 733     35,    36,    -1,    38,    39,    40,    41,    -1,    -1,    -1,
 734     -1,     3,    47,    48,    -1,    50,     8,    52,    10,    11,
 735     12,    13,    -1,    -1,    16,    17,    -1,    -1,    -1,    -1,
 736     -1,    -1,    24,    25,    26,    27,    -1,    -1,    -1,    -1,
 737     32,    33,    34,    35,    36,    -1,    38,    39,    40,    41,
 738     -1,    -1,    44,    -1,     3,    47,    48,    -1,    50,     8,
 739     52,    10,    11,    12,    13,    -1,    -1,    16,    17,    -1,
 740     -1,    -1,    -1,    -1,    -1,    24,    25,    26,    27,    -1,
 741     -1,    -1,    -1,    32,    33,    34,    35,    36,    -1,    38,
 742     39,    40,    41,    -1,    -1,    -1,    -1,    -1,    47,    48,
 743     -1,    50,    -1,    52,    32,    33,    34,    35,    36,    -1,
 744     38,    -1,    40,    41,    -1,    -1,    -1,    -1,    -1,    47,
 745     48
 746 };
 747 /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 748 #line 3 "/usr/share/bison.simple"
 749 /* This file comes from bison-1.28.  */
 750
 751 /* Skeleton output parser for bison,
 752    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 753
 754    This program is free software; you can redistribute it and/or modify
 755    it under the terms of the GNU General Public License as published by
 756    the Free Software Foundation; either version 2, or (at your option)
 757    any later version.
 758
 759    This program is distributed in the hope that it will be useful,
 760    but WITHOUT ANY WARRANTY; without even the implied warranty of
 761    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 762    GNU General Public License for more details.
 763
 764    You should have received a copy of the GNU General Public License
 765    along with this program; if not, write to the Free Software
 766    Foundation, Inc., 59 Temple Place - Suite 330,
 767    Boston, MA 02111-1307, USA.  */
 768
 769 /* As a special exception, when this file is copied by Bison into a
 770    Bison output file, you may use that output file without restriction.
 771    This special exception was added by the Free Software Foundation
 772    in version 1.24 of Bison.  */
 773
 774 /* This is the parser code that is written into each bison parser
 775   when the %semantic_parser declaration is not specified in the grammar.
 776   It was written by Richard Stallman by simplifying the hairy parser
 777   used when %semantic_parser is specified.  */
 778
 779 #ifndef YYSTACK_USE_ALLOCA
 780 #ifdef alloca
 781 #define YYSTACK_USE_ALLOCA
 782 #else /* alloca not defined */
 783 #ifdef __GNUC__
 784 #define YYSTACK_USE_ALLOCA
 785 #define alloca __builtin_alloca
 786 #else /* not GNU C.  */
 787 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 788 #define YYSTACK_USE_ALLOCA
 789 #include <alloca.h>
 790 #else /* not sparc */
 791 /* We think this test detects Watcom and Microsoft C.  */
 792 /* This used to test MSDOS, but that is a bad idea
 793    since that symbol is in the user namespace.  */
 794 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 795 #if 0 /* No need for malloc.h, which pollutes the namespace;
 796          instead, just don't use alloca.  */
 797 #include <malloc.h>
 798 #endif
 799 #else /* not MSDOS, or __TURBOC__ */
 800 #if defined(_AIX)
 801 /* I don't know what this was needed for, but it pollutes the namespace.
 802    So I turned it off.   rms, 2 May 1997.  */
 803 /* #include <malloc.h>  */
 804  #pragma alloca
 805 #define YYSTACK_USE_ALLOCA
 806 #else /* not MSDOS, or __TURBOC__, or _AIX */
 807 #if 0
 808 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 809                  and on HPUX 10.  Eventually we can turn this on.  */
 810 #define YYSTACK_USE_ALLOCA
 811 #define alloca __builtin_alloca
 812 #endif /* __hpux */
 813 #endif
 814 #endif /* not _AIX */
 815 #endif /* not MSDOS, or __TURBOC__ */
 816 #endif /* not sparc */
 817 #endif /* not GNU C */
 818 #endif /* alloca not defined */
 819 #endif /* YYSTACK_USE_ALLOCA not defined */
 820
 821 #ifdef YYSTACK_USE_ALLOCA
 822 #define YYSTACK_ALLOC alloca
 823 #else
 824 #define YYSTACK_ALLOC malloc
 825 #endif
 826
 827 /* Note: there must be only one dollar sign in this file.
 828    It is replaced by the list of actions, each action
 829    as one case of the switch.  */
 830
 831 #define yyerrok         (yyerrstatus = 0)
 832 #define yyclearin       (yychar = YYEMPTY)
 833 #define YYEMPTY         -2
 834 #define YYEOF           0
 835 #define YYACCEPT        goto yyacceptlab
 836 #define YYABORT         goto yyabortlab
 837 #define YYERROR         goto yyerrlab1
 838 /* Like YYERROR except do call yyerror.
 839    This remains here temporarily to ease the
 840    transition to the new meaning of YYERROR, for GCC.
 841    Once GCC version 2 has supplanted version 1, this can go.  */
 842 #define YYFAIL          goto yyerrlab
 843 #define YYRECOVERING()  (!!yyerrstatus)
 844 #define YYBACKUP(token, value) \
 845 do                                                              \
 846   if (yychar == YYEMPTY && yylen == 1)                          \
 847     { yychar = (token), yylval = (value);                       \
 848       yychar1 = YYTRANSLATE (yychar);                           \
 849       YYPOPSTACK;                                               \
 850       goto yybackup;                                            \
 851     }                                                           \
 852   else                                                          \
 853     { yyerror ("syntax error: cannot back up"); YYERROR; }      \
 854 while (0)
 855
 856 #define YYTERROR        1
 857 #define YYERRCODE       256
 858
 859 #ifndef YYPURE
 860 #define YYLEX           yylex()
 861 #endif
 862
 863 #ifdef YYPURE
 864 #ifdef YYLSP_NEEDED
 865 #ifdef YYLEX_PARAM
 866 #define YYLEX           yylex(&yylval, &yylloc, YYLEX_PARAM)
 867 #else
 868 #define YYLEX           yylex(&yylval, &yylloc)
 869 #endif
 870 #else /* not YYLSP_NEEDED */
 871 #ifdef YYLEX_PARAM
 872 #define YYLEX           yylex(&yylval, YYLEX_PARAM)
 873 #else
 874 #define YYLEX           yylex(&yylval)
 875 #endif
 876 #endif /* not YYLSP_NEEDED */
 877 #endif
 878
 879 /* If nonreentrant, generate the variables here */
 880
 881 #ifndef YYPURE
 882
 883 int     yychar;                 /*  the lookahead symbol                */
 884 YYSTYPE yylval;                 /*  the semantic value of the           */
 885                                 /*  lookahead symbol                    */
 886
 887 #ifdef YYLSP_NEEDED
 888 YYLTYPE yylloc;                 /*  location data for the lookahead     */
 889                                 /*  symbol                              */
 890 #endif
 891
 892 int yynerrs;                    /*  number of parse errors so far       */
 893 #endif  /* not YYPURE */
 894
 895 #if YYDEBUG != 0
 896 int yydebug;                    /*  nonzero means print parse trace     */
 897 /* Since this is uninitialized, it does not stop multiple parsers
 898    from coexisting.  */
 899 #endif
 900
 901 /*  YYINITDEPTH indicates the initial size of the parser's stacks       */
 902
 903 #ifndef YYINITDEPTH
 904 #define YYINITDEPTH 200
 905 #endif
 906
 907 /*  YYMAXDEPTH is the maximum size the stacks can grow to
 908     (effective only if the built-in stack extension method is used).  */
 909
 910 #if YYMAXDEPTH == 0
 911 #undef YYMAXDEPTH
 912 #endif
 913
 914 #ifndef YYMAXDEPTH
 915 #define YYMAXDEPTH 10000
 916 #endif
 917 \f
 918 /* Define __yy_memcpy.  Note that the size argument
 919    should be passed with type unsigned int, because that is what the non-GCC
 920    definitions require.  With GCC, __builtin_memcpy takes an arg
 921    of type size_t, but it can handle unsigned int.  */
 922
 923 #if __GNUC__ > 1                /* GNU C and GNU C++ define this.  */
 924 #define __yy_memcpy(TO,FROM,COUNT)      __builtin_memcpy(TO,FROM,COUNT)
 925 #else                           /* not GNU C or C++ */
 926 #ifndef __cplusplus
 927
 928 /* This is the most reliable way to avoid incompatibilities
 929    in available built-in functions on various systems.  */
 930 static void
 931 __yy_memcpy (to, from, count)
 932      char *to;
 933      char *from;
 934      unsigned int count;
 935 {
 936   register char *f = from;
 937   register char *t = to;
 938   register int i = count;
 939
 940   while (i-- > 0)
 941     *t++ = *f++;
 942 }
 943
 944 #else /* __cplusplus */
 945
 946 /* This is the most reliable way to avoid incompatibilities
 947    in available built-in functions on various systems.  */
 948 static void
 949 __yy_memcpy (char *to, char *from, unsigned int count)
 950 {
 951   register char *t = to;
 952   register char *f = from;
 953   register int i = count;
 954
 955   while (i-- > 0)
 956     *t++ = *f++;
 957 }
 958
 959 #endif
 960 #endif
 961 \f
 962 #line 217 "/usr/share/bison.simple"
 963
 964 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 965    into yyparse.  The argument should have type void *.
 966    It should actually point to an object.
 967    Grammar actions can access the variable by casting it
 968    to the proper pointer type.  */
 969
 970 #ifdef YYPARSE_PARAM
 971 #ifdef __cplusplus
 972 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 973 #define YYPARSE_PARAM_DECL
 974 #else /* not __cplusplus */
 975 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 976 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 977 #endif /* not __cplusplus */
 978 #else /* not YYPARSE_PARAM */
 979 #define YYPARSE_PARAM_ARG
 980 #define YYPARSE_PARAM_DECL
 981 #endif /* not YYPARSE_PARAM */
 982
 983 /* Prevent warning if -Wstrict-prototypes.  */
 984 #ifdef __GNUC__
 985 #ifdef YYPARSE_PARAM
 986 int yyparse (void *);
 987 #else
 988 int yyparse (void);
 989 #endif
 990 #endif
 991
 992 int
 993 yyparse(YYPARSE_PARAM_ARG)
 994      YYPARSE_PARAM_DECL
 995 {
 996   register int yystate;
 997   register int yyn;
 998   register short *yyssp;
 999   register YYSTYPE *yyvsp;
1000   int yyerrstatus;      /*  number of tokens to shift before error messages enabled */
1001   int yychar1 = 0;              /*  lookahead token as an internal (translated) token number */
1002
1003   short yyssa[YYINITDEPTH];     /*  the state stack                     */
1004   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack            */
1005
1006   short *yyss = yyssa;          /*  refer to the stacks thru separate pointers */
1007   YYSTYPE *yyvs = yyvsa;        /*  to allow yyoverflow to reallocate them elsewhere */
1008
1009 #ifdef YYLSP_NEEDED
1010   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack                  */
1011   YYLTYPE *yyls = yylsa;
1012   YYLTYPE *yylsp;
1013
1014 #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
1015 #else
1016 #define YYPOPSTACK   (yyvsp--, yyssp--)
1017 #endif
1018
1019   int yystacksize = YYINITDEPTH;
1020   int yyfree_stacks = 0;
1021
1022 #ifdef YYPURE
1023   int yychar;
1024   YYSTYPE yylval;
1025   int yynerrs;
1026 #ifdef YYLSP_NEEDED
1027   YYLTYPE yylloc;
1028 #endif
1029 #endif
1030
1031   YYSTYPE yyval;                /*  the variable used to return         */
1032                                 /*  semantic values from the action     */
1033                                 /*  routines                            */
1034
1035   int yylen;
1036
1037 #if YYDEBUG != 0
1038   if (yydebug)
1039     fprintf(stderr, "Starting parse\n");
1040 #endif
1041
1042   yystate = 0;
1043   yyerrstatus = 0;
1044   yynerrs = 0;
1045   yychar = YYEMPTY;             /* Cause a token to be read.  */
1046
1047   /* Initialize stack pointers.
1048      Waste one element of value and location stack
1049      so that they stay on the same level as the state stack.
1050      The wasted elements are never initialized.  */
1051
1052   yyssp = yyss - 1;
1053   yyvsp = yyvs;
1054 #ifdef YYLSP_NEEDED
1055   yylsp = yyls;
1056 #endif
1057
1058 /* Push a new state, which is found in  yystate  .  */
1059 /* In all cases, when you get here, the value and location stacks
1060    have just been pushed. so pushing a state here evens the stacks.  */
1061 yynewstate:
1062
1063   *++yyssp = yystate;
1064
1065   if (yyssp >= yyss + yystacksize - 1)
1066     {
1067       /* Give user a chance to reallocate the stack */
1068       /* Use copies of these so that the &'s don't force the real ones into memory. */
1069       YYSTYPE *yyvs1 = yyvs;
1070       short *yyss1 = yyss;
1071 #ifdef YYLSP_NEEDED
1072       YYLTYPE *yyls1 = yyls;
1073 #endif
1074
1075       /* Get the current used size of the three stacks, in elements.  */
1076       int size = yyssp - yyss + 1;
1077
1078 #ifdef yyoverflow
1079       /* Each stack pointer address is followed by the size of
1080          the data in use in that stack, in bytes.  */
1081 #ifdef YYLSP_NEEDED
1082       /* This used to be a conditional around just the two extra args,
1083          but that might be undefined if yyoverflow is a macro.  */
1084       yyoverflow("parser stack overflow",
1085                  &yyss1, size * sizeof (*yyssp),
1086                  &yyvs1, size * sizeof (*yyvsp),
1087                  &yyls1, size * sizeof (*yylsp),
1088                  &yystacksize);
1089 #else
1090       yyoverflow("parser stack overflow",
1091                  &yyss1, size * sizeof (*yyssp),
1092                  &yyvs1, size * sizeof (*yyvsp),
1093                  &yystacksize);
1094 #endif
1095
1096       yyss = yyss1; yyvs = yyvs1;
1097 #ifdef YYLSP_NEEDED
1098       yyls = yyls1;
1099 #endif
1100 #else /* no yyoverflow */
1101       /* Extend the stack our own way.  */
1102       if (yystacksize >= YYMAXDEPTH)
1103         {
1104           yyerror("parser stack overflow");
1105           if (yyfree_stacks)
1106             {
1107               free (yyss);
1108               free (yyvs);
1109 #ifdef YYLSP_NEEDED
1110               free (yyls);
1111 #endif
1112             }
1113           return 2;
1114         }
1115       yystacksize *= 2;
1116       if (yystacksize > YYMAXDEPTH)
1117         yystacksize = YYMAXDEPTH;
1118 #ifndef YYSTACK_USE_ALLOCA
1119       yyfree_stacks = 1;
1120 #endif
1121       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
1122       __yy_memcpy ((char *)yyss, (char *)yyss1,
1123                    size * (unsigned int) sizeof (*yyssp));
1124       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
1125       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
1126                    size * (unsigned int) sizeof (*yyvsp));
1127 #ifdef YYLSP_NEEDED
1128       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
1129       __yy_memcpy ((char *)yyls, (char *)yyls1,
1130                    size * (unsigned int) sizeof (*yylsp));
1131 #endif
1132 #endif /* no yyoverflow */
1133
1134       yyssp = yyss + size - 1;
1135       yyvsp = yyvs + size - 1;
1136 #ifdef YYLSP_NEEDED
1137       yylsp = yyls + size - 1;
1138 #endif
1139
1140 #if YYDEBUG != 0
1141       if (yydebug)
1142         fprintf(stderr, "Stack size increased to %d\n", yystacksize);
1143 #endif
1144
1145       if (yyssp >= yyss + yystacksize - 1)
1146         YYABORT;
1147     }
1148
1149 #if YYDEBUG != 0
1150   if (yydebug)
1151     fprintf(stderr, "Entering state %d\n", yystate);
1152 #endif
1153
1154   goto yybackup;
1155  yybackup:
1156
1157 /* Do appropriate processing given the current state.  */
1158 /* Read a lookahead token if we need one and don't already have one.  */
1159 /* yyresume: */
1160
1161   /* First try to decide what to do without reference to lookahead token.  */
1162
1163   yyn = yypact[yystate];
1164   if (yyn == YYFLAG)
1165     goto yydefault;
1166
1167   /* Not known => get a lookahead token if don't already have one.  */
1168
1169   /* yychar is either YYEMPTY or YYEOF
1170      or a valid token in external form.  */
1171
1172   if (yychar == YYEMPTY)
1173     {
1174 #if YYDEBUG != 0
1175       if (yydebug)
1176         fprintf(stderr, "Reading a token: ");
1177 #endif
1178       yychar = YYLEX;
1179     }
1180
1181   /* Convert token to internal form (in yychar1) for indexing tables with */
1182
1183   if (yychar <= 0)              /* This means end of input. */
1184     {
1185       yychar1 = 0;
1186       yychar = YYEOF;           /* Don't call YYLEX any more */
1187
1188 #if YYDEBUG != 0
1189       if (yydebug)
1190         fprintf(stderr, "Now at end of input.\n");
1191 #endif
1192     }
1193   else
1194     {
1195       yychar1 = YYTRANSLATE(yychar);
1196
1197 #if YYDEBUG != 0
1198       if (yydebug)
1199         {
1200           fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1201           /* Give the individual parser a way to print the precise meaning
1202              of a token, for further debugging info.  */
1203 #ifdef YYPRINT
1204           YYPRINT (stderr, yychar, yylval);
1205 #endif
1206           fprintf (stderr, ")\n");
1207         }
1208 #endif
1209     }
1210
1211   yyn += yychar1;
1212   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
1213     goto yydefault;
1214
1215   yyn = yytable[yyn];
1216
1217   /* yyn is what to do for this token type in this state.
1218      Negative => reduce, -yyn is rule number.
1219      Positive => shift, yyn is new state.
1220        New state is final state => don't bother to shift,
1221        just return success.
1222      0, or most negative number => error.  */
1223
1224   if (yyn < 0)
1225     {
1226       if (yyn == YYFLAG)
1227         goto yyerrlab;
1228       yyn = -yyn;
1229       goto yyreduce;
1230     }
1231   else if (yyn == 0)
1232     goto yyerrlab;
1233
1234   if (yyn == YYFINAL)
1235     YYACCEPT;
1236
1237   /* Shift the lookahead token.  */
1238
1239 #if YYDEBUG != 0
1240   if (yydebug)
1241     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1242 #endif
1243
1244   /* Discard the token being shifted unless it is eof.  */
1245   if (yychar != YYEOF)
1246     yychar = YYEMPTY;
1247
1248   *++yyvsp = yylval;
1249 #ifdef YYLSP_NEEDED
1250   *++yylsp = yylloc;
1251 #endif
1252
1253   /* count tokens shifted since error; after three, turn off error status.  */
1254   if (yyerrstatus) yyerrstatus--;
1255
1256   yystate = yyn;
1257   goto yynewstate;
1258
1259 /* Do the default action for the current state.  */
1260 yydefault:
1261
1262   yyn = yydefact[yystate];
1263   if (yyn == 0)
1264     goto yyerrlab;
1265
1266 /* Do a reduction.  yyn is the number of a rule to reduce with.  */
1267 yyreduce:
1268   yylen = yyr2[yyn];
1269   if (yylen > 0)
1270     yyval = yyvsp[1-yylen]; /* implement default value of the action */
1271
1272 #if YYDEBUG != 0
1273   if (yydebug)
1274     {
1275       int i;
1276
1277       fprintf (stderr, "Reducing via rule %d (line %d), ",
1278                yyn, yyrline[yyn]);
1279
1280       /* Print the symbols being reduced, and their result.  */
1281       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1282         fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1283       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1284     }
1285 #endif
1286
1287
1288   switch (yyn) {
1289
1290 case 1:
1291 #line 347 "/Users/chet/src/bash/src/parse.y"
1292 {
1293                           /* Case of regular command.  Discard the error
1294                              safety net,and return the command just parsed. */
1295                           global_command = yyvsp[-1].command;
1296                           eof_encountered = 0;
1297                           /* discard_parser_constructs (0); */
1298                           YYACCEPT;
1299                         ;
1300     break;}
1301 case 2:
1302 #line 356 "/Users/chet/src/bash/src/parse.y"
1303 {
1304                           /* Case of regular command, but not a very
1305                              interesting one.  Return a NULL command. */
1306                           global_command = (COMMAND *)NULL;
1307                           YYACCEPT;
1308                         ;
1309     break;}
1310 case 3:
1311 #line 363 "/Users/chet/src/bash/src/parse.y"
1312 {
1313                           /* Error during parsing.  Return NULL command. */
1314                           global_command = (COMMAND *)NULL;
1315                           eof_encountered = 0;
1316                           /* discard_parser_constructs (1); */
1317                           if (interactive)
1318                             {
1319                               YYACCEPT;
1320                             }
1321                           else
1322                             {
1323                               YYABORT;
1324                             }
1325                         ;
1326     break;}
1327 case 4:
1328 #line 378 "/Users/chet/src/bash/src/parse.y"
1329 {
1330                           /* Case of EOF seen by itself.  Do ignoreeof or
1331                              not. */
1332                           global_command = (COMMAND *)NULL;
1333                           handle_eof_input_unit ();
1334                           YYACCEPT;
1335                         ;
1336     break;}
1337 case 5:
1338 #line 388 "/Users/chet/src/bash/src/parse.y"
1339 { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
1340     break;}
1341 case 6:
1342 #line 390 "/Users/chet/src/bash/src/parse.y"
1343 { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-1].word_list); ;
1344     break;}
1345 case 7:
1346 #line 394 "/Users/chet/src/bash/src/parse.y"
1347 {
1348                           redir.filename = yyvsp[0].word;
1349                           yyval.redirect = make_redirection (1, r_output_direction, redir);
1350                         ;
1351     break;}
1352 case 8:
1353 #line 399 "/Users/chet/src/bash/src/parse.y"
1354 {
1355                           redir.filename = yyvsp[0].word;
1356                           yyval.redirect = make_redirection (0, r_input_direction, redir);
1357                         ;
1358     break;}
1359 case 9:
1360 #line 404 "/Users/chet/src/bash/src/parse.y"
1361 {
1362                           redir.filename = yyvsp[0].word;
1363                           yyval.redirect = make_redirection (yyvsp[-2].number, r_output_direction, redir);
1364                         ;
1365     break;}
1366 case 10:
1367 #line 409 "/Users/chet/src/bash/src/parse.y"
1368 {
1369                           redir.filename = yyvsp[0].word;
1370                           yyval.redirect = make_redirection (yyvsp[-2].number, r_input_direction, redir);
1371                         ;
1372     break;}
1373 case 11:
1374 #line 414 "/Users/chet/src/bash/src/parse.y"
1375 {
1376                           redir.filename = yyvsp[0].word;
1377                           yyval.redirect = make_redirection (1, r_appending_to, redir);
1378                         ;
1379     break;}
1380 case 12:
1381 #line 419 "/Users/chet/src/bash/src/parse.y"
1382 {
1383                           redir.filename = yyvsp[0].word;
1384                           yyval.redirect = make_redirection (yyvsp[-2].number, r_appending_to, redir);
1385                         ;
1386     break;}
1387 case 13:
1388 #line 424 "/Users/chet/src/bash/src/parse.y"
1389 {
1390                           redir.filename = yyvsp[0].word;
1391                           yyval.redirect = make_redirection (0, r_reading_until, redir);
1392                           redir_stack[need_here_doc++] = yyval.redirect;
1393                         ;
1394     break;}
1395 case 14:
1396 #line 430 "/Users/chet/src/bash/src/parse.y"
1397 {
1398                           redir.filename = yyvsp[0].word;
1399                           yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_until, redir);
1400                           redir_stack[need_here_doc++] = yyval.redirect;
1401                         ;
1402     break;}
1403 case 15:
1404 #line 436 "/Users/chet/src/bash/src/parse.y"
1405 {
1406                           redir.filename = yyvsp[0].word;
1407                           yyval.redirect = make_redirection (0, r_reading_string, redir);
1408                         ;
1409     break;}
1410 case 16:
1411 #line 441 "/Users/chet/src/bash/src/parse.y"
1412 {
1413                           redir.filename = yyvsp[0].word;
1414                           yyval.redirect = make_redirection (yyvsp[-2].number, r_reading_string, redir);
1415                         ;
1416     break;}
1417 case 17:
1418 #line 446 "/Users/chet/src/bash/src/parse.y"
1419 {
1420                           redir.dest = yyvsp[0].number;
1421                           yyval.redirect = make_redirection (0, r_duplicating_input, redir);
1422                         ;
1423     break;}
1424 case 18:
1425 #line 451 "/Users/chet/src/bash/src/parse.y"
1426 {
1427                           redir.dest = yyvsp[0].number;
1428                           yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input, redir);
1429                         ;
1430     break;}
1431 case 19:
1432 #line 456 "/Users/chet/src/bash/src/parse.y"
1433 {
1434                           redir.dest = yyvsp[0].number;
1435                           yyval.redirect = make_redirection (1, r_duplicating_output, redir);
1436                         ;
1437     break;}
1438 case 20:
1439 #line 461 "/Users/chet/src/bash/src/parse.y"
1440 {
1441                           redir.dest = yyvsp[0].number;
1442                           yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output, redir);
1443                         ;
1444     break;}
1445 case 21:
1446 #line 466 "/Users/chet/src/bash/src/parse.y"
1447 {
1448                           redir.filename = yyvsp[0].word;
1449                           yyval.redirect = make_redirection (0, r_duplicating_input_word, redir);
1450                         ;
1451     break;}
1452 case 22:
1453 #line 471 "/Users/chet/src/bash/src/parse.y"
1454 {
1455                           redir.filename = yyvsp[0].word;
1456                           yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_input_word, redir);
1457                         ;
1458     break;}
1459 case 23:
1460 #line 476 "/Users/chet/src/bash/src/parse.y"
1461 {
1462                           redir.filename = yyvsp[0].word;
1463                           yyval.redirect = make_redirection (1, r_duplicating_output_word, redir);
1464                         ;
1465     break;}
1466 case 24:
1467 #line 481 "/Users/chet/src/bash/src/parse.y"
1468 {
1469                           redir.filename = yyvsp[0].word;
1470                           yyval.redirect = make_redirection (yyvsp[-2].number, r_duplicating_output_word, redir);
1471                         ;
1472     break;}
1473 case 25:
1474 #line 486 "/Users/chet/src/bash/src/parse.y"
1475 {
1476                           redir.filename = yyvsp[0].word;
1477                           yyval.redirect = make_redirection
1478                             (0, r_deblank_reading_until, redir);
1479                           redir_stack[need_here_doc++] = yyval.redirect;
1480                         ;
1481     break;}
1482 case 26:
1483 #line 493 "/Users/chet/src/bash/src/parse.y"
1484 {
1485                           redir.filename = yyvsp[0].word;
1486                           yyval.redirect = make_redirection
1487                             (yyvsp[-2].number, r_deblank_reading_until, redir);
1488                           redir_stack[need_here_doc++] = yyval.redirect;
1489                         ;
1490     break;}
1491 case 27:
1492 #line 500 "/Users/chet/src/bash/src/parse.y"
1493 {
1494                           redir.dest = 0;
1495                           yyval.redirect = make_redirection (1, r_close_this, redir);
1496                         ;
1497     break;}
1498 case 28:
1499 #line 505 "/Users/chet/src/bash/src/parse.y"
1500 {
1501                           redir.dest = 0;
1502                           yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, redir);
1503                         ;
1504     break;}
1505 case 29:
1506 #line 510 "/Users/chet/src/bash/src/parse.y"
1507 {
1508                           redir.dest = 0;
1509                           yyval.redirect = make_redirection (0, r_close_this, redir);
1510                         ;
1511     break;}
1512 case 30:
1513 #line 515 "/Users/chet/src/bash/src/parse.y"
1514 {
1515                           redir.dest = 0;
1516                           yyval.redirect = make_redirection (yyvsp[-2].number, r_close_this, redir);
1517                         ;
1518     break;}
1519 case 31:
1520 #line 520 "/Users/chet/src/bash/src/parse.y"
1521 {
1522                           redir.filename = yyvsp[0].word;
1523                           yyval.redirect = make_redirection (1, r_err_and_out, redir);
1524                         ;
1525     break;}
1526 case 32:
1527 #line 525 "/Users/chet/src/bash/src/parse.y"
1528 {
1529                           redir.filename = yyvsp[0].word;
1530                           yyval.redirect = make_redirection (yyvsp[-2].number, r_input_output, redir);
1531                         ;
1532     break;}
1533 case 33:
1534 #line 530 "/Users/chet/src/bash/src/parse.y"
1535 {
1536                           redir.filename = yyvsp[0].word;
1537                           yyval.redirect = make_redirection (0, r_input_output, redir);
1538                         ;
1539     break;}
1540 case 34:
1541 #line 535 "/Users/chet/src/bash/src/parse.y"
1542 {
1543                           redir.filename = yyvsp[0].word;
1544                           yyval.redirect = make_redirection (1, r_output_force, redir);
1545                         ;
1546     break;}
1547 case 35:
1548 #line 540 "/Users/chet/src/bash/src/parse.y"
1549 {
1550                           redir.filename = yyvsp[0].word;
1551                           yyval.redirect = make_redirection (yyvsp[-2].number, r_output_force, redir);
1552                         ;
1553     break;}
1554 case 36:
1555 #line 547 "/Users/chet/src/bash/src/parse.y"
1556 { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
1557     break;}
1558 case 37:
1559 #line 549 "/Users/chet/src/bash/src/parse.y"
1560 { yyval.element.word = yyvsp[0].word; yyval.element.redirect = 0; ;
1561     break;}
1562 case 38:
1563 #line 551 "/Users/chet/src/bash/src/parse.y"
1564 { yyval.element.redirect = yyvsp[0].redirect; yyval.element.word = 0; ;
1565     break;}
1566 case 39:
1567 #line 555 "/Users/chet/src/bash/src/parse.y"
1568 {
1569                           yyval.redirect = yyvsp[0].redirect;
1570                         ;
1571     break;}
1572 case 40:
1573 #line 559 "/Users/chet/src/bash/src/parse.y"
1574 {
1575                           register REDIRECT *t;
1576
1577                           for (t = yyvsp[-1].redirect; t->next; t = t->next)
1578                             ;
1579                           t->next = yyvsp[0].redirect;
1580                           yyval.redirect = yyvsp[-1].redirect;
1581                         ;
1582     break;}
1583 case 41:
1584 #line 570 "/Users/chet/src/bash/src/parse.y"
1585 { yyval.command = make_simple_command (yyvsp[0].element, (COMMAND *)NULL); ;
1586     break;}
1587 case 42:
1588 #line 572 "/Users/chet/src/bash/src/parse.y"
1589 { yyval.command = make_simple_command (yyvsp[0].element, yyvsp[-1].command); ;
1590     break;}
1591 case 43:
1592 #line 576 "/Users/chet/src/bash/src/parse.y"
1593 { yyval.command = clean_simple_command (yyvsp[0].command); ;
1594     break;}
1595 case 44:
1596 #line 578 "/Users/chet/src/bash/src/parse.y"
1597 { yyval.command = yyvsp[0].command; ;
1598     break;}
1599 case 45:
1600 #line 580 "/Users/chet/src/bash/src/parse.y"
1601 {
1602                           COMMAND *tc;
1603
1604                           tc = yyvsp[-1].command;
1605                           if (tc->redirects)
1606                             {
1607                               register REDIRECT *t;
1608                               for (t = tc->redirects; t->next; t = t->next)
1609                                 ;
1610                               t->next = yyvsp[0].redirect;
1611                             }
1612                           else
1613                             tc->redirects = yyvsp[0].redirect;
1614                           yyval.command = yyvsp[-1].command;
1615                         ;
1616     break;}
1617 case 46:
1618 #line 596 "/Users/chet/src/bash/src/parse.y"
1619 { yyval.command = yyvsp[0].command; ;
1620     break;}
1621 case 47:
1622 #line 600 "/Users/chet/src/bash/src/parse.y"
1623 { yyval.command = yyvsp[0].command; ;
1624     break;}
1625 case 48:
1626 #line 602 "/Users/chet/src/bash/src/parse.y"
1627 { yyval.command = yyvsp[0].command; ;
1628     break;}
1629 case 49:
1630 #line 604 "/Users/chet/src/bash/src/parse.y"
1631 { yyval.command = make_while_command (yyvsp[-3].command, yyvsp[-1].command); ;
1632     break;}
1633 case 50:
1634 #line 606 "/Users/chet/src/bash/src/parse.y"
1635 { yyval.command = make_until_command (yyvsp[-3].command, yyvsp[-1].command); ;
1636     break;}
1637 case 51:
1638 #line 608 "/Users/chet/src/bash/src/parse.y"
1639 { yyval.command = yyvsp[0].command; ;
1640     break;}
1641 case 52:
1642 #line 610 "/Users/chet/src/bash/src/parse.y"
1643 { yyval.command = yyvsp[0].command; ;
1644     break;}
1645 case 53:
1646 #line 612 "/Users/chet/src/bash/src/parse.y"
1647 { yyval.command = yyvsp[0].command; ;
1648     break;}
1649 case 54:
1650 #line 614 "/Users/chet/src/bash/src/parse.y"
1651 { yyval.command = yyvsp[0].command; ;
1652     break;}
1653 case 55:
1654 #line 616 "/Users/chet/src/bash/src/parse.y"
1655 { yyval.command = yyvsp[0].command; ;
1656     break;}
1657 case 56:
1658 #line 618 "/Users/chet/src/bash/src/parse.y"
1659 { yyval.command = yyvsp[0].command; ;
1660     break;}
1661 case 57:
1662 #line 620 "/Users/chet/src/bash/src/parse.y"
1663 { yyval.command = yyvsp[0].command; ;
1664     break;}
1665 case 58:
1666 #line 624 "/Users/chet/src/bash/src/parse.y"
1667 {
1668                           yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1669                           if (word_top > 0) word_top--;
1670                         ;
1671     break;}
1672 case 59:
1673 #line 629 "/Users/chet/src/bash/src/parse.y"
1674 {
1675                           yyval.command = make_for_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1676                           if (word_top > 0) word_top--;
1677                         ;
1678     break;}
1679 case 60:
1680 #line 634 "/Users/chet/src/bash/src/parse.y"
1681 {
1682                           yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1683                           if (word_top > 0) word_top--;
1684                         ;
1685     break;}
1686 case 61:
1687 #line 639 "/Users/chet/src/bash/src/parse.y"
1688 {
1689                           yyval.command = make_for_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1690                           if (word_top > 0) word_top--;
1691                         ;
1692     break;}
1693 case 62:
1694 #line 644 "/Users/chet/src/bash/src/parse.y"
1695 {
1696                           yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command, word_lineno[word_top]);
1697                           if (word_top > 0) word_top--;
1698                         ;
1699     break;}
1700 case 63:
1701 #line 649 "/Users/chet/src/bash/src/parse.y"
1702 {
1703                           yyval.command = make_for_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command, word_lineno[word_top]);
1704                           if (word_top > 0) word_top--;
1705                         ;
1706     break;}
1707 case 64:
1708 #line 654 "/Users/chet/src/bash/src/parse.y"
1709 {
1710                           yyval.command = make_for_command (yyvsp[-7].word, (WORD_LIST *)NULL, yyvsp[-1].command, word_lineno[word_top]);
1711                           if (word_top > 0) word_top--;
1712                         ;
1713     break;}
1714 case 65:
1715 #line 659 "/Users/chet/src/bash/src/parse.y"
1716 {
1717                           yyval.command = make_for_command (yyvsp[-7].word, (WORD_LIST *)NULL, yyvsp[-1].command, word_lineno[word_top]);
1718                           if (word_top > 0) word_top--;
1719                         ;
1720     break;}
1721 case 66:
1722 #line 666 "/Users/chet/src/bash/src/parse.y"
1723 {
1724                                   yyval.command = make_arith_for_command (yyvsp[-5].word_list, yyvsp[-1].command, arith_for_lineno);
1725                                   if (word_top > 0) word_top--;
1726                                 ;
1727     break;}
1728 case 67:
1729 #line 671 "/Users/chet/src/bash/src/parse.y"
1730 {
1731                                   yyval.command = make_arith_for_command (yyvsp[-5].word_list, yyvsp[-1].command, arith_for_lineno);
1732                                   if (word_top > 0) word_top--;
1733                                 ;
1734     break;}
1735 case 68:
1736 #line 676 "/Users/chet/src/bash/src/parse.y"
1737 {
1738                                   yyval.command = make_arith_for_command (yyvsp[-3].word_list, yyvsp[-1].command, arith_for_lineno);
1739                                   if (word_top > 0) word_top--;
1740                                 ;
1741     break;}
1742 case 69:
1743 #line 681 "/Users/chet/src/bash/src/parse.y"
1744 {
1745                                   yyval.command = make_arith_for_command (yyvsp[-3].word_list, yyvsp[-1].command, arith_for_lineno);
1746                                   if (word_top > 0) word_top--;
1747                                 ;
1748     break;}
1749 case 70:
1750 #line 688 "/Users/chet/src/bash/src/parse.y"
1751 {
1752                           yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1753                           if (word_top > 0) word_top--;
1754                         ;
1755     break;}
1756 case 71:
1757 #line 693 "/Users/chet/src/bash/src/parse.y"
1758 {
1759                           yyval.command = make_select_command (yyvsp[-4].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1760                           if (word_top > 0) word_top--;
1761                         ;
1762     break;}
1763 case 72:
1764 #line 698 "/Users/chet/src/bash/src/parse.y"
1765 {
1766                           yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1767                           if (word_top > 0) word_top--;
1768                         ;
1769     break;}
1770 case 73:
1771 #line 703 "/Users/chet/src/bash/src/parse.y"
1772 {
1773                           yyval.command = make_select_command (yyvsp[-5].word, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), yyvsp[-1].command, word_lineno[word_top]);
1774                           if (word_top > 0) word_top--;
1775                         ;
1776     break;}
1777 case 74:
1778 #line 708 "/Users/chet/src/bash/src/parse.y"
1779 {
1780                           yyval.command = make_select_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command, word_lineno[word_top]);
1781                           if (word_top > 0) word_top--;
1782                         ;
1783     break;}
1784 case 75:
1785 #line 713 "/Users/chet/src/bash/src/parse.y"
1786 {
1787                           yyval.command = make_select_command (yyvsp[-8].word, REVERSE_LIST (yyvsp[-5].word_list, WORD_LIST *), yyvsp[-1].command, word_lineno[word_top]);
1788                           if (word_top > 0) word_top--;
1789                         ;
1790     break;}
1791 case 76:
1792 #line 720 "/Users/chet/src/bash/src/parse.y"
1793 {
1794                           yyval.command = make_case_command (yyvsp[-4].word, (PATTERN_LIST *)NULL, word_lineno[word_top]);
1795                           if (word_top > 0) word_top--;
1796                         ;
1797     break;}
1798 case 77:
1799 #line 725 "/Users/chet/src/bash/src/parse.y"
1800 {
1801                           yyval.command = make_case_command (yyvsp[-5].word, yyvsp[-2].pattern, word_lineno[word_top]);
1802                           if (word_top > 0) word_top--;
1803                         ;
1804     break;}
1805 case 78:
1806 #line 730 "/Users/chet/src/bash/src/parse.y"
1807 {
1808                           yyval.command = make_case_command (yyvsp[-4].word, yyvsp[-1].pattern, word_lineno[word_top]);
1809                           if (word_top > 0) word_top--;
1810                         ;
1811     break;}
1812 case 79:
1813 #line 737 "/Users/chet/src/bash/src/parse.y"
1814 { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); ;
1815     break;}
1816 case 80:
1817 #line 740 "/Users/chet/src/bash/src/parse.y"
1818 { yyval.command = make_function_def (yyvsp[-4].word, yyvsp[0].command, function_dstart, function_bstart); ;
1819     break;}
1820 case 81:
1821 #line 743 "/Users/chet/src/bash/src/parse.y"
1822 { yyval.command = make_function_def (yyvsp[-2].word, yyvsp[0].command, function_dstart, function_bstart); ;
1823     break;}
1824 case 82:
1825 #line 748 "/Users/chet/src/bash/src/parse.y"
1826 { yyval.command = yyvsp[0].command; ;
1827     break;}
1828 case 83:
1829 #line 750 "/Users/chet/src/bash/src/parse.y"
1830 {
1831                           COMMAND *tc;
1832
1833                           tc = yyvsp[-1].command;
1834                           /* According to Posix.2 3.9.5, redirections
1835                              specified after the body of a function should
1836                              be attached to the function and performed when
1837                              the function is executed, not as part of the
1838                              function definition command. */
1839                           /* XXX - I don't think it matters, but we might
1840                              want to change this in the future to avoid
1841                              problems differentiating between a function
1842                              definition with a redirection and a function
1843                              definition containing a single command with a
1844                              redirection.  The two are semantically equivalent,
1845                              though -- the only difference is in how the
1846                              command printing code displays the redirections. */
1847                           if (tc->redirects)
1848                             {
1849                               register REDIRECT *t;
1850                               for (t = tc->redirects; t->next; t = t->next)
1851                                 ;
1852                               t->next = yyvsp[0].redirect;
1853                             }
1854                           else
1855                             tc->redirects = yyvsp[0].redirect;
1856                           yyval.command = yyvsp[-1].command;
1857                         ;
1858     break;}
1859 case 84:
1860 #line 781 "/Users/chet/src/bash/src/parse.y"
1861 {
1862                           yyval.command = make_subshell_command (yyvsp[-1].command);
1863                           yyval.command->flags |= CMD_WANT_SUBSHELL;
1864                         ;
1865     break;}
1866 case 85:
1867 #line 788 "/Users/chet/src/bash/src/parse.y"
1868 { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, (COMMAND *)NULL); ;
1869     break;}
1870 case 86:
1871 #line 790 "/Users/chet/src/bash/src/parse.y"
1872 { yyval.command = make_if_command (yyvsp[-5].command, yyvsp[-3].command, yyvsp[-1].command); ;
1873     break;}
1874 case 87:
1875 #line 792 "/Users/chet/src/bash/src/parse.y"
1876 { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[-1].command); ;
1877     break;}
1878 case 88:
1879 #line 797 "/Users/chet/src/bash/src/parse.y"
1880 { yyval.command = make_group_command (yyvsp[-1].command); ;
1881     break;}
1882 case 89:
1883 #line 801 "/Users/chet/src/bash/src/parse.y"
1884 { yyval.command = make_arith_command (yyvsp[0].word_list); ;
1885     break;}
1886 case 90:
1887 #line 805 "/Users/chet/src/bash/src/parse.y"
1888 { yyval.command = yyvsp[-1].command; ;
1889     break;}
1890 case 91:
1891 #line 809 "/Users/chet/src/bash/src/parse.y"
1892 { yyval.command = make_if_command (yyvsp[-2].command, yyvsp[0].command, (COMMAND *)NULL); ;
1893     break;}
1894 case 92:
1895 #line 811 "/Users/chet/src/bash/src/parse.y"
1896 { yyval.command = make_if_command (yyvsp[-4].command, yyvsp[-2].command, yyvsp[0].command); ;
1897     break;}
1898 case 93:
1899 #line 813 "/Users/chet/src/bash/src/parse.y"
1900 { yyval.command = make_if_command (yyvsp[-3].command, yyvsp[-1].command, yyvsp[0].command); ;
1901     break;}
1902 case 95:
1903 #line 818 "/Users/chet/src/bash/src/parse.y"
1904 { yyvsp[0].pattern->next = yyvsp[-1].pattern; yyval.pattern = yyvsp[0].pattern; ;
1905     break;}
1906 case 96:
1907 #line 822 "/Users/chet/src/bash/src/parse.y"
1908 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
1909     break;}
1910 case 97:
1911 #line 824 "/Users/chet/src/bash/src/parse.y"
1912 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
1913     break;}
1914 case 98:
1915 #line 826 "/Users/chet/src/bash/src/parse.y"
1916 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, yyvsp[0].command); ;
1917     break;}
1918 case 99:
1919 #line 828 "/Users/chet/src/bash/src/parse.y"
1920 { yyval.pattern = make_pattern_list (yyvsp[-2].word_list, (COMMAND *)NULL); ;
1921     break;}
1922 case 101:
1923 #line 833 "/Users/chet/src/bash/src/parse.y"
1924 { yyvsp[-1].pattern->next = yyvsp[-2].pattern; yyval.pattern = yyvsp[-1].pattern; ;
1925     break;}
1926 case 102:
1927 #line 837 "/Users/chet/src/bash/src/parse.y"
1928 { yyval.word_list = make_word_list (yyvsp[0].word, (WORD_LIST *)NULL); ;
1929     break;}
1930 case 103:
1931 #line 839 "/Users/chet/src/bash/src/parse.y"
1932 { yyval.word_list = make_word_list (yyvsp[0].word, yyvsp[-2].word_list); ;
1933     break;}
1934 case 104:
1935 #line 848 "/Users/chet/src/bash/src/parse.y"
1936 {
1937                           yyval.command = yyvsp[0].command;
1938                           if (need_here_doc)
1939                             gather_here_documents ();
1940                          ;
1941     break;}
1942 case 106:
1943 #line 857 "/Users/chet/src/bash/src/parse.y"
1944 {
1945                           yyval.command = yyvsp[0].command;
1946                         ;
1947     break;}
1948 case 108:
1949 #line 864 "/Users/chet/src/bash/src/parse.y"
1950 {
1951                           if (yyvsp[-2].command->type == cm_connection)
1952                             yyval.command = connect_async_list (yyvsp[-2].command, (COMMAND *)NULL, '&');
1953                           else
1954                             yyval.command = command_connect (yyvsp[-2].command, (COMMAND *)NULL, '&');
1955                         ;
1956     break;}
1957 case 110:
1958 #line 875 "/Users/chet/src/bash/src/parse.y"
1959 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
1960     break;}
1961 case 111:
1962 #line 877 "/Users/chet/src/bash/src/parse.y"
1963 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
1964     break;}
1965 case 112:
1966 #line 879 "/Users/chet/src/bash/src/parse.y"
1967 {
1968                           if (yyvsp[-3].command->type == cm_connection)
1969                             yyval.command = connect_async_list (yyvsp[-3].command, yyvsp[0].command, '&');
1970                           else
1971                             yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '&');
1972                         ;
1973     break;}
1974 case 113:
1975 #line 886 "/Users/chet/src/bash/src/parse.y"
1976 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
1977     break;}
1978 case 114:
1979 #line 888 "/Users/chet/src/bash/src/parse.y"
1980 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, ';'); ;
1981     break;}
1982 case 115:
1983 #line 890 "/Users/chet/src/bash/src/parse.y"
1984 { yyval.command = yyvsp[0].command; ;
1985     break;}
1986 case 118:
1987 #line 898 "/Users/chet/src/bash/src/parse.y"
1988 { yyval.number = '\n'; ;
1989     break;}
1990 case 119:
1991 #line 900 "/Users/chet/src/bash/src/parse.y"
1992 { yyval.number = ';'; ;
1993     break;}
1994 case 120:
1995 #line 902 "/Users/chet/src/bash/src/parse.y"
1996 { yyval.number = yacc_EOF; ;
1997     break;}
1998 case 123:
1999 #line 916 "/Users/chet/src/bash/src/parse.y"
2000 {
2001                           yyval.command = yyvsp[0].command;
2002                           if (need_here_doc)
2003                             gather_here_documents ();
2004                         ;
2005     break;}
2006 case 124:
2007 #line 922 "/Users/chet/src/bash/src/parse.y"
2008 {
2009                           if (yyvsp[-1].command->type == cm_connection)
2010                             yyval.command = connect_async_list (yyvsp[-1].command, (COMMAND *)NULL, '&');
2011                           else
2012                             yyval.command = command_connect (yyvsp[-1].command, (COMMAND *)NULL, '&');
2013                           if (need_here_doc)
2014                             gather_here_documents ();
2015                         ;
2016     break;}
2017 case 125:
2018 #line 931 "/Users/chet/src/bash/src/parse.y"
2019 {
2020                           yyval.command = yyvsp[-1].command;
2021                           if (need_here_doc)
2022                             gather_here_documents ();
2023                         ;
2024     break;}
2025 case 126:
2026 #line 939 "/Users/chet/src/bash/src/parse.y"
2027 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, AND_AND); ;
2028     break;}
2029 case 127:
2030 #line 941 "/Users/chet/src/bash/src/parse.y"
2031 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, OR_OR); ;
2032     break;}
2033 case 128:
2034 #line 943 "/Users/chet/src/bash/src/parse.y"
2035 {
2036                           if (yyvsp[-2].command->type == cm_connection)
2037                             yyval.command = connect_async_list (yyvsp[-2].command, yyvsp[0].command, '&');
2038                           else
2039                             yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, '&');
2040                         ;
2041     break;}
2042 case 129:
2043 #line 950 "/Users/chet/src/bash/src/parse.y"
2044 { yyval.command = command_connect (yyvsp[-2].command, yyvsp[0].command, ';'); ;
2045     break;}
2046 case 130:
2047 #line 953 "/Users/chet/src/bash/src/parse.y"
2048 { yyval.command = yyvsp[0].command; ;
2049     break;}
2050 case 131:
2051 #line 957 "/Users/chet/src/bash/src/parse.y"
2052 { yyval.command = yyvsp[0].command; ;
2053     break;}
2054 case 132:
2055 #line 959 "/Users/chet/src/bash/src/parse.y"
2056 {
2057                           if (yyvsp[0].command)
2058                             yyvsp[0].command->flags |= CMD_INVERT_RETURN;
2059                           yyval.command = yyvsp[0].command;
2060                         ;
2061     break;}
2062 case 133:
2063 #line 965 "/Users/chet/src/bash/src/parse.y"
2064 {
2065                           if (yyvsp[0].command)
2066                             yyvsp[0].command->flags |= yyvsp[-1].number;
2067                           yyval.command = yyvsp[0].command;
2068                         ;
2069     break;}
2070 case 134:
2071 #line 971 "/Users/chet/src/bash/src/parse.y"
2072 {
2073                           if (yyvsp[0].command)
2074                             yyvsp[0].command->flags |= yyvsp[-2].number|CMD_INVERT_RETURN;
2075                           yyval.command = yyvsp[0].command;
2076                         ;
2077     break;}
2078 case 135:
2079 #line 977 "/Users/chet/src/bash/src/parse.y"
2080 {
2081                           if (yyvsp[0].command)
2082                             yyvsp[0].command->flags |= yyvsp[-1].number|CMD_INVERT_RETURN;
2083                           yyval.command = yyvsp[0].command;
2084                         ;
2085     break;}
2086 case 136:
2087 #line 983 "/Users/chet/src/bash/src/parse.y"
2088 {
2089                           ELEMENT x;
2090
2091                           /* Boy, this is unclean.  `time' by itself can
2092                              time a null command.  We cheat and push a
2093                              newline back if the list_terminator was a newline
2094                              to avoid the double-newline problem (one to
2095                              terminate this, one to terminate the command) */
2096                           x.word = 0;
2097                           x.redirect = 0;
2098                           yyval.command = make_simple_command (x, (COMMAND *)NULL);
2099                           yyval.command->flags |= yyvsp[-1].number;
2100                           /* XXX - let's cheat and push a newline back */
2101                           if (yyvsp[0].number == '\n')
2102                             token_to_read = '\n';
2103                         ;
2104     break;}
2105 case 137:
2106 #line 1004 "/Users/chet/src/bash/src/parse.y"
2107 { yyval.command = command_connect (yyvsp[-3].command, yyvsp[0].command, '|'); ;
2108     break;}
2109 case 138:
2110 #line 1006 "/Users/chet/src/bash/src/parse.y"
2111 { yyval.command = yyvsp[0].command; ;
2112     break;}
2113 case 139:
2114 #line 1010 "/Users/chet/src/bash/src/parse.y"
2115 { yyval.number = CMD_TIME_PIPELINE; ;
2116     break;}
2117 case 140:
2118 #line 1012 "/Users/chet/src/bash/src/parse.y"
2119 { yyval.number = CMD_TIME_PIPELINE|CMD_TIME_POSIX; ;
2120     break;}
2121 }
2122    /* the action file gets copied in in place of this dollarsign */
2123 #line 543 "/usr/share/bison.simple"
2124 \f
2125   yyvsp -= yylen;
2126   yyssp -= yylen;
2127 #ifdef YYLSP_NEEDED
2128   yylsp -= yylen;
2129 #endif
2130
2131 #if YYDEBUG != 0
2132   if (yydebug)
2133     {
2134       short *ssp1 = yyss - 1;
2135       fprintf (stderr, "state stack now");
2136       while (ssp1 != yyssp)
2137         fprintf (stderr, " %d", *++ssp1);
2138       fprintf (stderr, "\n");
2139     }
2140 #endif
2141
2142   *++yyvsp = yyval;
2143
2144 #ifdef YYLSP_NEEDED
2145   yylsp++;
2146   if (yylen == 0)
2147     {
2148       yylsp->first_line = yylloc.first_line;
2149       yylsp->first_column = yylloc.first_column;
2150       yylsp->last_line = (yylsp-1)->last_line;
2151       yylsp->last_column = (yylsp-1)->last_column;
2152       yylsp->text = 0;
2153     }
2154   else
2155     {
2156       yylsp->last_line = (yylsp+yylen-1)->last_line;
2157       yylsp->last_column = (yylsp+yylen-1)->last_column;
2158     }
2159 #endif
2160
2161   /* Now "shift" the result of the reduction.
2162      Determine what state that goes to,
2163      based on the state we popped back to
2164      and the rule number reduced by.  */
2165
2166   yyn = yyr1[yyn];
2167
2168   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
2169   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2170     yystate = yytable[yystate];
2171   else
2172     yystate = yydefgoto[yyn - YYNTBASE];
2173
2174   goto yynewstate;
2175
2176 yyerrlab:   /* here on detecting error */
2177
2178   if (! yyerrstatus)
2179     /* If not already recovering from an error, report this error.  */
2180     {
2181       ++yynerrs;
2182
2183 #ifdef YYERROR_VERBOSE
2184       yyn = yypact[yystate];
2185
2186       if (yyn > YYFLAG && yyn < YYLAST)
2187         {
2188           int size = 0;
2189           char *msg;
2190           int x, count;
2191
2192           count = 0;
2193           /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
2194           for (x = (yyn < 0 ? -yyn : 0);
2195                x < (sizeof(yytname) / sizeof(char *)); x++)
2196             if (yycheck[x + yyn] == x)
2197               size += strlen(yytname[x]) + 15, count++;
2198           msg = (char *) malloc(size + 15);
2199           if (msg != 0)
2200             {
2201               strcpy(msg, "parse error");
2202
2203               if (count < 5)
2204                 {
2205                   count = 0;
2206                   for (x = (yyn < 0 ? -yyn : 0);
2207                        x < (sizeof(yytname) / sizeof(char *)); x++)
2208                     if (yycheck[x + yyn] == x)
2209                       {
2210                         strcat(msg, count == 0 ? ", expecting `" : " or `");
2211                         strcat(msg, yytname[x]);
2212                         strcat(msg, "'");
2213                         count++;
2214                       }
2215                 }
2216               yyerror(msg);
2217               free(msg);
2218             }
2219           else
2220             yyerror ("parse error; also virtual memory exceeded");
2221         }
2222       else
2223 #endif /* YYERROR_VERBOSE */
2224         yyerror("parse error");
2225     }
2226
2227   goto yyerrlab1;
2228 yyerrlab1:   /* here on error raised explicitly by an action */
2229
2230   if (yyerrstatus == 3)
2231     {
2232       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
2233
2234       /* return failure if at end of input */
2235       if (yychar == YYEOF)
2236         YYABORT;
2237
2238 #if YYDEBUG != 0
2239       if (yydebug)
2240         fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
2241 #endif
2242
2243       yychar = YYEMPTY;
2244     }
2245
2246   /* Else will try to reuse lookahead token
2247      after shifting the error token.  */
2248
2249   yyerrstatus = 3;              /* Each real token shifted decrements this */
2250
2251   goto yyerrhandle;
2252
2253 yyerrdefault:  /* current state does not do anything special for the error token. */
2254
2255 #if 0
2256   /* This is wrong; only states that explicitly want error tokens
2257      should shift them.  */
2258   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
2259   if (yyn) goto yydefault;
2260 #endif
2261
2262 yyerrpop:   /* pop the current state because it cannot handle the error token */
2263
2264   if (yyssp == yyss) YYABORT;
2265   yyvsp--;
2266   yystate = *--yyssp;
2267 #ifdef YYLSP_NEEDED
2268   yylsp--;
2269 #endif
2270
2271 #if YYDEBUG != 0
2272   if (yydebug)
2273     {
2274       short *ssp1 = yyss - 1;
2275       fprintf (stderr, "Error: state stack now");
2276       while (ssp1 != yyssp)
2277         fprintf (stderr, " %d", *++ssp1);
2278       fprintf (stderr, "\n");
2279     }
2280 #endif
2281
2282 yyerrhandle:
2283
2284   yyn = yypact[yystate];
2285   if (yyn == YYFLAG)
2286     goto yyerrdefault;
2287
2288   yyn += YYTERROR;
2289   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
2290     goto yyerrdefault;
2291
2292   yyn = yytable[yyn];
2293   if (yyn < 0)
2294     {
2295       if (yyn == YYFLAG)
2296         goto yyerrpop;
2297       yyn = -yyn;
2298       goto yyreduce;
2299     }
2300   else if (yyn == 0)
2301     goto yyerrpop;
2302
2303   if (yyn == YYFINAL)
2304     YYACCEPT;
2305
2306 #if YYDEBUG != 0
2307   if (yydebug)
2308     fprintf(stderr, "Shifting error token, ");
2309 #endif
2310
2311   *++yyvsp = yylval;
2312 #ifdef YYLSP_NEEDED
2313   *++yylsp = yylloc;
2314 #endif
2315
2316   yystate = yyn;
2317   goto yynewstate;
2318
2319  yyacceptlab:
2320   /* YYACCEPT comes here.  */
2321   if (yyfree_stacks)
2322     {
2323       free (yyss);
2324       free (yyvs);
2325 #ifdef YYLSP_NEEDED
2326       free (yyls);
2327 #endif
2328     }
2329   return 0;
2330
2331  yyabortlab:
2332   /* YYABORT comes here.  */
2333   if (yyfree_stacks)
2334     {
2335       free (yyss);
2336       free (yyvs);
2337 #ifdef YYLSP_NEEDED
2338       free (yyls);
2339 #endif
2340     }
2341   return 1;
2342 }
2343 #line 1014 "/Users/chet/src/bash/src/parse.y"
2344
2345
2346 /* Possible states for the parser that require it to do special things. */
2347 #define PST_CASEPAT     0x0001          /* in a case pattern list */
2348 #define PST_ALEXPNEXT   0x0002          /* expand next word for aliases */
2349 #define PST_ALLOWOPNBRC 0x0004          /* allow open brace for function def */
2350 #define PST_NEEDCLOSBRC 0x0008          /* need close brace */
2351 #define PST_DBLPAREN    0x0010          /* double-paren parsing */
2352 #define PST_SUBSHELL    0x0020          /* ( ... ) subshell */
2353 #define PST_CMDSUBST    0x0040          /* $( ... ) command substitution */
2354 #define PST_CASESTMT    0x0080          /* parsing a case statement */
2355 #define PST_CONDCMD     0x0100          /* parsing a [[...]] command */
2356 #define PST_CONDEXPR    0x0200          /* parsing the guts of [[...]] */
2357 #define PST_ARITHFOR    0x0400          /* parsing an arithmetic for command */
2358 #define PST_ALEXPAND    0x0800          /* OK to expand aliases - unused */
2359 #define PST_CMDTOKEN    0x1000          /* command token OK - unused */
2360 #define PST_COMPASSIGN  0x2000          /* parsing x=(...) compound assignment */
2361 #define PST_ASSIGNOK    0x4000          /* assignment statement ok in this context */
2362
2363 /* Initial size to allocate for tokens, and the
2364    amount to grow them by. */
2365 #define TOKEN_DEFAULT_INITIAL_SIZE 496
2366 #define TOKEN_DEFAULT_GROW_SIZE 512
2367
2368 /* Should we call prompt_again? */
2369 #define SHOULD_PROMPT() \
2370   (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
2371
2372 #if defined (ALIAS)
2373 #  define expanding_alias() (pushed_string_list && pushed_string_list->expander)
2374 #else
2375 #  define expanding_alias() 0
2376 #endif
2377
2378 /* The token currently being read. */
2379 static int current_token;
2380
2381 /* The last read token, or NULL.  read_token () uses this for context
2382    checking. */
2383 static int last_read_token;
2384
2385 /* The token read prior to last_read_token. */
2386 static int token_before_that;
2387
2388 /* The token read prior to token_before_that. */
2389 static int two_tokens_ago;
2390
2391 /* The current parser state. */
2392 static int parser_state;
2393
2394 /* Global var is non-zero when end of file has been reached. */
2395 int EOF_Reached = 0;
2396
2397 #ifdef DEBUG
2398 static void
2399 debug_parser (i)
2400      int i;
2401 {
2402 #if YYDEBUG != 0
2403   yydebug = i;
2404 #endif
2405 }
2406 #endif
2407
2408 /* yy_getc () returns the next available character from input or EOF.
2409    yy_ungetc (c) makes `c' the next character to read.
2410    init_yy_io (get, unget, type, location) makes the function GET the
2411    installed function for getting the next character, makes UNGET the
2412    installed function for un-getting a character, sets the type of stream
2413    (either string or file) from TYPE, and makes LOCATION point to where
2414    the input is coming from. */
2415
2416 /* Unconditionally returns end-of-file. */
2417 int
2418 return_EOF ()
2419 {
2420   return (EOF);
2421 }
2422
2423 /* Variable containing the current get and unget functions.
2424    See ./input.h for a clearer description. */
2425 BASH_INPUT bash_input;
2426
2427 /* Set all of the fields in BASH_INPUT to NULL.  Free bash_input.name if it
2428    is non-null, avoiding a memory leak. */
2429 void
2430 initialize_bash_input ()
2431 {
2432   bash_input.type = st_none;
2433   FREE (bash_input.name);
2434   bash_input.name = (char *)NULL;
2435   bash_input.location.file = (FILE *)NULL;
2436   bash_input.location.string = (char *)NULL;
2437   bash_input.getter = (sh_cget_func_t *)NULL;
2438   bash_input.ungetter = (sh_cunget_func_t *)NULL;
2439 }
2440
2441 /* Set the contents of the current bash input stream from
2442    GET, UNGET, TYPE, NAME, and LOCATION. */
2443 void
2444 init_yy_io (get, unget, type, name, location)
2445      sh_cget_func_t *get;
2446      sh_cunget_func_t *unget;
2447      enum stream_type type;
2448      const char *name;
2449      INPUT_STREAM location;
2450 {
2451   bash_input.type = type;
2452   FREE (bash_input.name);
2453   bash_input.name = name ? savestring (name) : (char *)NULL;
2454
2455   /* XXX */
2456 #if defined (CRAY)
2457   memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
2458 #else
2459   bash_input.location = location;
2460 #endif
2461   bash_input.getter = get;
2462   bash_input.ungetter = unget;
2463 }
2464
2465 char *
2466 yy_input_name ()
2467 {
2468   return (bash_input.name ? bash_input.name : "stdin");
2469 }
2470
2471 /* Call this to get the next character of input. */
2472 static int
2473 yy_getc ()
2474 {
2475   return (*(bash_input.getter)) ();
2476 }
2477
2478 /* Call this to unget C.  That is, to make C the next character
2479    to be read. */
2480 static int
2481 yy_ungetc (c)
2482      int c;
2483 {
2484   return (*(bash_input.ungetter)) (c);
2485 }
2486
2487 #if defined (BUFFERED_INPUT)
2488 #ifdef INCLUDE_UNUSED
2489 int
2490 input_file_descriptor ()
2491 {
2492   switch (bash_input.type)
2493     {
2494     case st_stream:
2495       return (fileno (bash_input.location.file));
2496     case st_bstream:
2497       return (bash_input.location.buffered_fd);
2498     case st_stdin:
2499     default:
2500       return (fileno (stdin));
2501     }
2502 }
2503 #endif
2504 #endif /* BUFFERED_INPUT */
2505
2506 /* **************************************************************** */
2507 /*                                                                  */
2508 /*                Let input be read from readline ().               */
2509 /*                                                                  */
2510 /* **************************************************************** */
2511
2512 #if defined (READLINE)
2513 char *current_readline_prompt = (char *)NULL;
2514 char *current_readline_line = (char *)NULL;
2515 int current_readline_line_index = 0;
2516
2517 static int
2518 yy_readline_get ()
2519 {
2520   SigHandler *old_sigint;
2521   int line_len;
2522   unsigned char c;
2523
2524   if (!current_readline_line)
2525     {
2526       if (!bash_readline_initialized)
2527         initialize_readline ();
2528
2529 #if defined (JOB_CONTROL)
2530       if (job_control)
2531         give_terminal_to (shell_pgrp, 0);
2532 #endif /* JOB_CONTROL */
2533
2534       old_sigint = (SigHandler *)NULL;
2535       if (signal_is_ignored (SIGINT) == 0)
2536         {
2537           old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
2538           interrupt_immediately++;
2539         }
2540       terminate_immediately = 1;
2541
2542       current_readline_line = readline (current_readline_prompt ?
2543                                           current_readline_prompt : "");
2544
2545       terminate_immediately = 0;
2546       if (signal_is_ignored (SIGINT) == 0 && old_sigint)
2547         {
2548           interrupt_immediately--;
2549           set_signal_handler (SIGINT, old_sigint);
2550         }
2551
2552 #if 0
2553       /* Reset the prompt to the decoded value of prompt_string_pointer. */
2554       reset_readline_prompt ();
2555 #endif
2556
2557       if (current_readline_line == 0)
2558         return (EOF);
2559
2560       current_readline_line_index = 0;
2561       line_len = strlen (current_readline_line);
2562
2563       current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
2564       current_readline_line[line_len++] = '\n';
2565       current_readline_line[line_len] = '\0';
2566     }
2567
2568   if (current_readline_line[current_readline_line_index] == 0)
2569     {
2570       free (current_readline_line);
2571       current_readline_line = (char *)NULL;
2572       return (yy_readline_get ());
2573     }
2574   else
2575     {
2576       c = current_readline_line[current_readline_line_index++];
2577       return (c);
2578     }
2579 }
2580
2581 static int
2582 yy_readline_unget (c)
2583      int c;
2584 {
2585   if (current_readline_line_index && current_readline_line)
2586     current_readline_line[--current_readline_line_index] = c;
2587   return (c);
2588 }
2589
2590 void
2591 with_input_from_stdin ()
2592 {
2593   INPUT_STREAM location;
2594
2595   if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
2596     {
2597       location.string = current_readline_line;
2598       init_yy_io (yy_readline_get, yy_readline_unget,
2599                   st_stdin, "readline stdin", location);
2600     }
2601 }
2602
2603 #else  /* !READLINE */
2604
2605 void
2606 with_input_from_stdin ()
2607 {
2608   with_input_from_stream (stdin, "stdin");
2609 }
2610 #endif  /* !READLINE */
2611
2612 /* **************************************************************** */
2613 /*                                                                  */
2614 /*   Let input come from STRING.  STRING is zero terminated.        */
2615 /*                                                                  */
2616 /* **************************************************************** */
2617
2618 static int
2619 yy_string_get ()
2620 {
2621   register char *string;
2622   register unsigned char c;
2623
2624   string = bash_input.location.string;
2625
2626   /* If the string doesn't exist, or is empty, EOF found. */
2627   if (string && *string)
2628     {
2629       c = *string++;
2630       bash_input.location.string = string;
2631       return (c);
2632     }
2633   else
2634     return (EOF);
2635 }
2636
2637 static int
2638 yy_string_unget (c)
2639      int c;
2640 {
2641   *(--bash_input.location.string) = c;
2642   return (c);
2643 }
2644
2645 void
2646 with_input_from_string (string, name)
2647      char *string;
2648      const char *name;
2649 {
2650   INPUT_STREAM location;
2651
2652   location.string = string;
2653   init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
2654 }
2655
2656 /* **************************************************************** */
2657 /*                                                                  */
2658 /*                   Let input come from STREAM.                    */
2659 /*                                                                  */
2660 /* **************************************************************** */
2661
2662 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
2663    define, and just use getc/ungetc if it was defined, but since bash
2664    installs its signal handlers without the SA_RESTART flag, some signals
2665    (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
2666    the read to be restarted.  We need to restart it ourselves. */
2667
2668 static int
2669 yy_stream_get ()
2670 {
2671   int result;
2672
2673   result = EOF;
2674   if (bash_input.location.file)
2675     {
2676       if (interactive)
2677         {
2678           interrupt_immediately++;
2679           terminate_immediately++;
2680         }
2681       result = getc_with_restart (bash_input.location.file);
2682       if (interactive)
2683         {
2684           interrupt_immediately--;
2685           terminate_immediately--;
2686         }
2687     }
2688   return (result);
2689 }
2690
2691 static int
2692 yy_stream_unget (c)
2693      int c;
2694 {
2695   return (ungetc_with_restart (c, bash_input.location.file));
2696 }
2697
2698 void
2699 with_input_from_stream (stream, name)
2700      FILE *stream;
2701      const char *name;
2702 {
2703   INPUT_STREAM location;
2704
2705   location.file = stream;
2706   init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
2707 }
2708
2709 typedef struct stream_saver {
2710   struct stream_saver *next;
2711   BASH_INPUT bash_input;
2712   int line;
2713 #if defined (BUFFERED_INPUT)
2714   BUFFERED_STREAM *bstream;
2715 #endif /* BUFFERED_INPUT */
2716 } STREAM_SAVER;
2717
2718 /* The globally known line number. */
2719 int line_number = 0;
2720
2721 #if defined (COND_COMMAND)
2722 static int cond_lineno;
2723 static int cond_token;
2724 #endif
2725
2726 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
2727
2728 void
2729 push_stream (reset_lineno)
2730      int reset_lineno;
2731 {
2732   STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
2733
2734   xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
2735
2736 #if defined (BUFFERED_INPUT)
2737   saver->bstream = (BUFFERED_STREAM *)NULL;
2738   /* If we have a buffered stream, clear out buffers[fd]. */
2739   if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
2740     saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
2741                                           (BUFFERED_STREAM *)NULL);
2742 #endif /* BUFFERED_INPUT */
2743
2744   saver->line = line_number;
2745   bash_input.name = (char *)NULL;
2746   saver->next = stream_list;
2747   stream_list = saver;
2748   EOF_Reached = 0;
2749   if (reset_lineno)
2750     line_number = 0;
2751 }
2752
2753 void
2754 pop_stream ()
2755 {
2756   if (!stream_list)
2757     EOF_Reached = 1;
2758   else
2759     {
2760       STREAM_SAVER *saver = stream_list;
2761
2762       EOF_Reached = 0;
2763       stream_list = stream_list->next;
2764
2765       init_yy_io (saver->bash_input.getter,
2766                   saver->bash_input.ungetter,
2767                   saver->bash_input.type,
2768                   saver->bash_input.name,
2769                   saver->bash_input.location);
2770
2771 #if defined (BUFFERED_INPUT)
2772       /* If we have a buffered stream, restore buffers[fd]. */
2773       /* If the input file descriptor was changed while this was on the
2774          save stack, update the buffered fd to the new file descriptor and
2775          re-establish the buffer <-> bash_input fd correspondence. */
2776       if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
2777         {
2778           if (bash_input_fd_changed)
2779             {
2780               bash_input_fd_changed = 0;
2781               if (default_buffered_input >= 0)
2782                 {
2783                   bash_input.location.buffered_fd = default_buffered_input;
2784                   saver->bstream->b_fd = default_buffered_input;
2785                   SET_CLOSE_ON_EXEC (default_buffered_input);
2786                 }
2787             }
2788           /* XXX could free buffered stream returned as result here. */
2789           set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
2790         }
2791 #endif /* BUFFERED_INPUT */
2792
2793       line_number = saver->line;
2794
2795       FREE (saver->bash_input.name);
2796       free (saver);
2797     }
2798 }
2799
2800 /* Return 1 if a stream of type TYPE is saved on the stack. */
2801 int
2802 stream_on_stack (type)
2803      enum stream_type type;
2804 {
2805   register STREAM_SAVER *s;
2806
2807   for (s = stream_list; s; s = s->next)
2808     if (s->bash_input.type == type)
2809       return 1;
2810   return 0;
2811 }
2812
2813 /* Save the current token state and return it in a malloced array. */
2814 int *
2815 save_token_state ()
2816 {
2817   int *ret;
2818
2819   ret = (int *)xmalloc (3 * sizeof (int));
2820   ret[0] = last_read_token;
2821   ret[1] = token_before_that;
2822   ret[2] = two_tokens_ago;
2823   return ret;
2824 }
2825
2826 void
2827 restore_token_state (ts)
2828      int *ts;
2829 {
2830   if (ts == 0)
2831     return;
2832   last_read_token = ts[0];
2833   token_before_that = ts[1];
2834   two_tokens_ago = ts[2];
2835 }
2836
2837 /*
2838  * This is used to inhibit alias expansion and reserved word recognition
2839  * inside case statement pattern lists.  A `case statement pattern list' is:
2840  *
2841  *      everything between the `in' in a `case word in' and the next ')'
2842  *      or `esac'
2843  *      everything between a `;;' and the next `)' or `esac'
2844  */
2845
2846 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2847
2848 #define END_OF_ALIAS 0
2849
2850 /*
2851  * Pseudo-global variables used in implementing token-wise alias expansion.
2852  */
2853
2854 /*
2855  * Pushing and popping strings.  This works together with shell_getc to
2856  * implement alias expansion on a per-token basis.
2857  */
2858
2859 typedef struct string_saver {
2860   struct string_saver *next;
2861   int expand_alias;  /* Value to set expand_alias to when string is popped. */
2862   char *saved_line;
2863 #if defined (ALIAS)
2864   alias_t *expander;   /* alias that caused this line to be pushed. */
2865 #endif
2866   int saved_line_size, saved_line_index, saved_line_terminator;
2867 } STRING_SAVER;
2868
2869 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
2870
2871 /*
2872  * Push the current shell_input_line onto a stack of such lines and make S
2873  * the current input.  Used when expanding aliases.  EXPAND is used to set
2874  * the value of expand_next_token when the string is popped, so that the
2875  * word after the alias in the original line is handled correctly when the
2876  * alias expands to multiple words.  TOKEN is the token that was expanded
2877  * into S; it is saved and used to prevent infinite recursive expansion.
2878  */
2879 static void
2880 push_string (s, expand, ap)
2881      char *s;
2882      int expand;
2883      alias_t *ap;
2884 {
2885   STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
2886
2887   temp->expand_alias = expand;
2888   temp->saved_line = shell_input_line;
2889   temp->saved_line_size = shell_input_line_size;
2890   temp->saved_line_index = shell_input_line_index;
2891   temp->saved_line_terminator = shell_input_line_terminator;
2892 #if defined (ALIAS)
2893   temp->expander = ap;
2894 #endif
2895   temp->next = pushed_string_list;
2896   pushed_string_list = temp;
2897
2898 #if defined (ALIAS)
2899   if (ap)
2900     ap->flags |= AL_BEINGEXPANDED;
2901 #endif
2902
2903   shell_input_line = s;
2904   shell_input_line_size = strlen (s);
2905   shell_input_line_index = 0;
2906   shell_input_line_terminator = '\0';
2907 #if 0
2908   parser_state &= ~PST_ALEXPNEXT;       /* XXX */
2909 #endif
2910
2911   set_line_mbstate ();
2912 }
2913
2914 /*
2915  * Make the top of the pushed_string stack be the current shell input.
2916  * Only called when there is something on the stack.  Called from shell_getc
2917  * when it thinks it has consumed the string generated by an alias expansion
2918  * and needs to return to the original input line.
2919  */
2920 static void
2921 pop_string ()
2922 {
2923   STRING_SAVER *t;
2924
2925   FREE (shell_input_line);
2926   shell_input_line = pushed_string_list->saved_line;
2927   shell_input_line_index = pushed_string_list->saved_line_index;
2928   shell_input_line_size = pushed_string_list->saved_line_size;
2929   shell_input_line_terminator = pushed_string_list->saved_line_terminator;
2930
2931   if (pushed_string_list->expand_alias)
2932     parser_state |= PST_ALEXPNEXT;
2933   else
2934     parser_state &= ~PST_ALEXPNEXT;
2935
2936   t = pushed_string_list;
2937   pushed_string_list = pushed_string_list->next;
2938
2939 #if defined (ALIAS)
2940   if (t->expander)
2941     t->expander->flags &= ~AL_BEINGEXPANDED;
2942 #endif
2943
2944   free ((char *)t);
2945
2946   set_line_mbstate ();
2947 }
2948
2949 static void
2950 free_string_list ()
2951 {
2952   register STRING_SAVER *t, *t1;
2953
2954   for (t = pushed_string_list; t; )
2955     {
2956       t1 = t->next;
2957       FREE (t->saved_line);
2958 #if defined (ALIAS)
2959       if (t->expander)
2960         t->expander->flags &= ~AL_BEINGEXPANDED;
2961 #endif
2962       free ((char *)t);
2963       t = t1;
2964     }
2965   pushed_string_list = (STRING_SAVER *)NULL;
2966 }
2967
2968 #endif /* ALIAS || DPAREN_ARITHMETIC */
2969
2970 void
2971 free_pushed_string_input ()
2972 {
2973 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2974   free_string_list ();
2975 #endif
2976 }
2977
2978 /* Return a line of text, taken from wherever yylex () reads input.
2979    If there is no more input, then we return NULL.  If REMOVE_QUOTED_NEWLINE
2980    is non-zero, we remove unquoted \<newline> pairs.  This is used by
2981    read_secondary_line to read here documents. */
2982 static char *
2983 read_a_line (remove_quoted_newline)
2984      int remove_quoted_newline;
2985 {
2986   static char *line_buffer = (char *)NULL;
2987   static int buffer_size = 0;
2988   int indx = 0, c, peekc, pass_next;
2989
2990 #if defined (READLINE)
2991   if (no_line_editing && SHOULD_PROMPT ())
2992 #else
2993   if (SHOULD_PROMPT ())
2994 #endif
2995     print_prompt ();
2996
2997   pass_next = 0;
2998   while (1)
2999     {
3000       /* Allow immediate exit if interrupted during input. */
3001       QUIT;
3002
3003       c = yy_getc ();
3004
3005       /* Ignore null bytes in input. */
3006       if (c == 0)
3007         {
3008 #if 0
3009           internal_warning ("read_a_line: ignored null byte in input");
3010 #endif
3011           continue;
3012         }
3013
3014       /* If there is no more input, then we return NULL. */
3015       if (c == EOF)
3016         {
3017           if (interactive && bash_input.type == st_stream)
3018             clearerr (stdin);
3019           if (indx == 0)
3020             return ((char *)NULL);
3021           c = '\n';
3022         }
3023
3024       /* `+2' in case the final character in the buffer is a newline. */
3025       RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
3026
3027       /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
3028          here document with an unquoted delimiter.  In this case,
3029          the line will be expanded as if it were in double quotes.
3030          We allow a backslash to escape the next character, but we
3031          need to treat the backslash specially only if a backslash
3032          quoting a backslash-newline pair appears in the line. */
3033       if (pass_next)
3034         {
3035           line_buffer[indx++] = c;
3036           pass_next = 0;
3037         }
3038       else if (c == '\\' && remove_quoted_newline)
3039         {
3040           peekc = yy_getc ();
3041           if (peekc == '\n')
3042             {
3043               line_number++;
3044               continue; /* Make the unquoted \<newline> pair disappear. */
3045             }
3046           else
3047             {
3048               yy_ungetc (peekc);
3049               pass_next = 1;
3050               line_buffer[indx++] = c;          /* Preserve the backslash. */
3051             }
3052         }
3053       else
3054         line_buffer[indx++] = c;
3055
3056       if (c == '\n')
3057         {
3058           line_buffer[indx] = '\0';
3059           return (line_buffer);
3060         }
3061     }
3062 }
3063
3064 /* Return a line as in read_a_line (), but insure that the prompt is
3065    the secondary prompt.  This is used to read the lines of a here
3066    document.  REMOVE_QUOTED_NEWLINE is non-zero if we should remove
3067    newlines quoted with backslashes while reading the line.  It is
3068    non-zero unless the delimiter of the here document was quoted. */
3069 char *
3070 read_secondary_line (remove_quoted_newline)
3071      int remove_quoted_newline;
3072 {
3073   prompt_string_pointer = &ps2_prompt;
3074   if (SHOULD_PROMPT())
3075     prompt_again ();
3076   return (read_a_line (remove_quoted_newline));
3077 }
3078
3079 /* **************************************************************** */
3080 /*                                                                  */
3081 /*                              YYLEX ()                            */
3082 /*                                                                  */
3083 /* **************************************************************** */
3084
3085 /* Reserved words.  These are only recognized as the first word of a
3086    command. */
3087 STRING_INT_ALIST word_token_alist[] = {
3088   { "if", IF },
3089   { "then", THEN },
3090   { "else", ELSE },
3091   { "elif", ELIF },
3092   { "fi", FI },
3093   { "case", CASE },
3094   { "esac", ESAC },
3095   { "for", FOR },
3096 #if defined (SELECT_COMMAND)
3097   { "select", SELECT },
3098 #endif
3099   { "while", WHILE },
3100   { "until", UNTIL },
3101   { "do", DO },
3102   { "done", DONE },
3103   { "in", IN },
3104   { "function", FUNCTION },
3105 #if defined (COMMAND_TIMING)
3106   { "time", TIME },
3107 #endif
3108   { "{", '{' },
3109   { "}", '}' },
3110   { "!", BANG },
3111 #if defined (COND_COMMAND)
3112   { "[[", COND_START },
3113   { "]]", COND_END },
3114 #endif
3115   { (char *)NULL, 0}
3116 };
3117
3118 /* other tokens that can be returned by read_token() */
3119 STRING_INT_ALIST other_token_alist[] = {
3120   /* Multiple-character tokens with special values */
3121   { "-p", TIMEOPT },
3122   { "&&", AND_AND },
3123   { "||", OR_OR },
3124   { ">>", GREATER_GREATER },
3125   { "<<", LESS_LESS },
3126   { "<&", LESS_AND },
3127   { ">&", GREATER_AND },
3128   { ";;", SEMI_SEMI },
3129   { "<<-", LESS_LESS_MINUS },
3130   { "<<<", LESS_LESS_LESS },
3131   { "&>", AND_GREATER },
3132   { "<>", LESS_GREATER },
3133   { ">|", GREATER_BAR },
3134   { "EOF", yacc_EOF },
3135   /* Tokens whose value is the character itself */
3136   { ">", '>' },
3137   { "<", '<' },
3138   { "-", '-' },
3139   { "{", '{' },
3140   { "}", '}' },
3141   { ";", ';' },
3142   { "(", '(' },
3143   { ")", ')' },
3144   { "|", '|' },
3145   { "&", '&' },
3146   { "newline", '\n' },
3147   { (char *)NULL, 0}
3148 };
3149
3150 /* others not listed here:
3151         WORD                    look at yylval.word
3152         ASSIGNMENT_WORD         look at yylval.word
3153         NUMBER                  look at yylval.number
3154         ARITH_CMD               look at yylval.word_list
3155         ARITH_FOR_EXPRS         look at yylval.word_list
3156         COND_CMD                look at yylval.command
3157 */
3158
3159 /* These are used by read_token_word, but appear up here so that shell_getc
3160    can use them to decide when to add otherwise blank lines to the history. */
3161
3162 /* The primary delimiter stack. */
3163 struct dstack dstack = {  (char *)NULL, 0, 0 };
3164
3165 /* A temporary delimiter stack to be used when decoding prompt strings.
3166    This is needed because command substitutions in prompt strings (e.g., PS2)
3167    can screw up the parser's quoting state. */
3168 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
3169
3170 /* Macro for accessing the top delimiter on the stack.  Returns the
3171    delimiter or zero if none. */
3172 #define current_delimiter(ds) \
3173   (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
3174
3175 #define push_delimiter(ds, character) \
3176   do \
3177     { \
3178       if (ds.delimiter_depth + 2 > ds.delimiter_space) \
3179         ds.delimiters = (char *)xrealloc \
3180           (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
3181       ds.delimiters[ds.delimiter_depth] = character; \
3182       ds.delimiter_depth++; \
3183     } \
3184   while (0)
3185
3186 #define pop_delimiter(ds)       ds.delimiter_depth--
3187
3188 /* Return the next shell input character.  This always reads characters
3189    from shell_input_line; when that line is exhausted, it is time to
3190    read the next line.  This is called by read_token when the shell is
3191    processing normal command input. */
3192
3193 /* This implements one-character lookahead/lookbehind across physical input
3194    lines, to avoid something being lost because it's pushed back with
3195    shell_ungetc when we're at the start of a line. */
3196 static int eol_ungetc_lookahead = 0;
3197
3198 static int
3199 shell_getc (remove_quoted_newline)
3200      int remove_quoted_newline;
3201 {
3202   register int i;
3203   int c;
3204   unsigned char uc;
3205
3206   QUIT;
3207
3208   if (sigwinch_received)
3209     {
3210       sigwinch_received = 0;
3211       get_new_window_size (0, (int *)0, (int *)0);
3212     }
3213
3214   if (eol_ungetc_lookahead)
3215     {
3216       c = eol_ungetc_lookahead;
3217       eol_ungetc_lookahead = 0;
3218       return (c);
3219     }
3220
3221 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
3222   /* If shell_input_line[shell_input_line_index] == 0, but there is
3223      something on the pushed list of strings, then we don't want to go
3224      off and get another line.  We let the code down below handle it. */
3225
3226   if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
3227                             (pushed_string_list == (STRING_SAVER *)NULL)))
3228 #else /* !ALIAS && !DPAREN_ARITHMETIC */
3229   if (!shell_input_line || !shell_input_line[shell_input_line_index])
3230 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
3231     {
3232       line_number++;
3233
3234     restart_read:
3235
3236       /* Allow immediate exit if interrupted during input. */
3237       QUIT;
3238
3239       i = 0;
3240       shell_input_line_terminator = 0;
3241
3242       /* If the shell is interatctive, but not currently printing a prompt
3243          (interactive_shell && interactive == 0), we don't want to print
3244          notifies or cleanup the jobs -- we want to defer it until we do
3245          print the next prompt. */
3246       if (interactive_shell == 0 || SHOULD_PROMPT())
3247         {
3248 #if defined (JOB_CONTROL)
3249       /* This can cause a problem when reading a command as the result
3250          of a trap, when the trap is called from flush_child.  This call
3251          had better not cause jobs to disappear from the job table in
3252          that case, or we will have big trouble. */
3253           notify_and_cleanup ();
3254 #else /* !JOB_CONTROL */
3255           cleanup_dead_jobs ();
3256 #endif /* !JOB_CONTROL */
3257         }
3258
3259 #if defined (READLINE)
3260       if (no_line_editing && SHOULD_PROMPT())
3261 #else
3262       if (SHOULD_PROMPT())
3263 #endif
3264         print_prompt ();
3265
3266       if (bash_input.type == st_stream)
3267         clearerr (stdin);
3268
3269       while (1)
3270         {
3271           c = yy_getc ();
3272
3273           /* Allow immediate exit if interrupted during input. */
3274           QUIT;
3275
3276           if (c == '\0')
3277             {
3278 #if 0
3279               internal_warning ("shell_getc: ignored null byte in input");
3280 #endif
3281               continue;
3282             }
3283
3284           RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
3285
3286           if (c == EOF)
3287             {
3288               if (bash_input.type == st_stream)
3289                 clearerr (stdin);
3290
3291               if (i == 0)
3292                 shell_input_line_terminator = EOF;
3293
3294               shell_input_line[i] = '\0';
3295               break;
3296             }
3297
3298           shell_input_line[i++] = c;
3299
3300           if (c == '\n')
3301             {
3302               shell_input_line[--i] = '\0';
3303               current_command_line_count++;
3304               break;
3305             }
3306         }
3307
3308       shell_input_line_index = 0;
3309       shell_input_line_len = i;         /* == strlen (shell_input_line) */
3310
3311       set_line_mbstate ();
3312
3313 #if defined (HISTORY)
3314       if (remember_on_history && shell_input_line && shell_input_line[0])
3315         {
3316           char *expansions;
3317 #  if defined (BANG_HISTORY)
3318           int old_hist;
3319
3320           /* If the current delimiter is a single quote, we should not be
3321              performing history expansion, even if we're on a different
3322              line from the original single quote. */
3323           old_hist = history_expansion_inhibited;
3324           if (current_delimiter (dstack) == '\'')
3325             history_expansion_inhibited = 1;
3326 #  endif
3327           expansions = pre_process_line (shell_input_line, 1, 1);
3328 #  if defined (BANG_HISTORY)
3329           history_expansion_inhibited = old_hist;
3330 #  endif
3331           if (expansions != shell_input_line)
3332             {
3333               free (shell_input_line);
3334               shell_input_line = expansions;
3335               shell_input_line_len = shell_input_line ?
3336                                         strlen (shell_input_line) : 0;
3337               if (!shell_input_line_len)
3338                 current_command_line_count--;
3339
3340               /* We have to force the xrealloc below because we don't know
3341                  the true allocated size of shell_input_line anymore. */
3342               shell_input_line_size = shell_input_line_len;
3343
3344               set_line_mbstate ();
3345             }
3346         }
3347       /* Try to do something intelligent with blank lines encountered while
3348          entering multi-line commands.  XXX - this is grotesque */
3349       else if (remember_on_history && shell_input_line &&
3350                shell_input_line[0] == '\0' &&
3351                current_command_line_count > 1)
3352         {
3353           if (current_delimiter (dstack))
3354             /* We know shell_input_line[0] == 0 and we're reading some sort of
3355                quoted string.  This means we've got a line consisting of only
3356                a newline in a quoted string.  We want to make sure this line
3357                gets added to the history. */
3358             maybe_add_history (shell_input_line);
3359           else
3360             {
3361               char *hdcs;
3362               hdcs = history_delimiting_chars ();
3363               if (hdcs && hdcs[0] == ';')
3364                 maybe_add_history (shell_input_line);
3365             }
3366         }
3367
3368 #endif /* HISTORY */
3369
3370       if (shell_input_line)
3371         {
3372           /* Lines that signify the end of the shell's input should not be
3373              echoed. */
3374           if (echo_input_at_read && (shell_input_line[0] ||
3375                                      shell_input_line_terminator != EOF))
3376             fprintf (stderr, "%s\n", shell_input_line);
3377         }
3378       else
3379         {
3380           shell_input_line_size = 0;
3381           prompt_string_pointer = &current_prompt_string;
3382           if (SHOULD_PROMPT ())
3383             prompt_again ();
3384           goto restart_read;
3385         }
3386
3387       /* Add the newline to the end of this string, iff the string does
3388          not already end in an EOF character.  */
3389       if (shell_input_line_terminator != EOF)
3390         {
3391           if (shell_input_line_len + 3 > shell_input_line_size)
3392             shell_input_line = (char *)xrealloc (shell_input_line,
3393                                         1 + (shell_input_line_size += 2));
3394
3395           shell_input_line[shell_input_line_len] = '\n';
3396           shell_input_line[shell_input_line_len + 1] = '\0';
3397
3398           set_line_mbstate ();
3399         }
3400     }
3401
3402   uc = shell_input_line[shell_input_line_index];
3403
3404   if (uc)
3405     shell_input_line_index++;
3406
3407 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
3408   /* If UC is NULL, we have reached the end of the current input string.  If
3409      pushed_string_list is non-empty, it's time to pop to the previous string
3410      because we have fully consumed the result of the last alias expansion.
3411      Do it transparently; just return the next character of the string popped
3412      to. */
3413   if (!uc && (pushed_string_list != (STRING_SAVER *)NULL))
3414     {
3415       pop_string ();
3416       uc = shell_input_line[shell_input_line_index];
3417       if (uc)
3418         shell_input_line_index++;
3419     }
3420 #endif /* ALIAS || DPAREN_ARITHMETIC */
3421
3422   if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
3423     {
3424         if (SHOULD_PROMPT ())
3425           prompt_again ();
3426         line_number++;
3427         goto restart_read;
3428     }
3429
3430   if (!uc && shell_input_line_terminator == EOF)
3431     return ((shell_input_line_index != 0) ? '\n' : EOF);
3432
3433   return (uc);
3434 }
3435
3436 /* Put C back into the input for the shell.  This might need changes for
3437    HANDLE_MULTIBYTE around EOLs.  Since we (currently) never push back a
3438    character different than we read, shell_input_line_property doesn't need
3439    to change when manipulating shell_input_line.  The define for
3440    last_shell_getc_is_singlebyte should take care of it, though. */
3441 static void
3442 shell_ungetc (c)
3443      int c;
3444 {
3445   if (shell_input_line && shell_input_line_index)
3446     shell_input_line[--shell_input_line_index] = c;
3447   else
3448     eol_ungetc_lookahead = c;
3449 }
3450
3451 #ifdef INCLUDE_UNUSED
3452 /* Back the input pointer up by one, effectively `ungetting' a character. */
3453 static void
3454 shell_ungetchar ()
3455 {
3456   if (shell_input_line && shell_input_line_index)
3457     shell_input_line_index--;
3458 }
3459 #endif
3460
3461 /* Discard input until CHARACTER is seen, then push that character back
3462    onto the input stream. */
3463 static void
3464 discard_until (character)
3465      int character;
3466 {
3467   int c;
3468
3469   while ((c = shell_getc (0)) != EOF && c != character)
3470     ;
3471
3472   if (c != EOF)
3473     shell_ungetc (c);
3474 }
3475
3476 void
3477 execute_variable_command (command, vname)
3478      char *command, *vname;
3479 {
3480   char *last_lastarg;
3481   sh_parser_state_t ps;
3482
3483   save_parser_state (&ps);
3484   last_lastarg = get_string_value ("_");
3485   if (last_lastarg)
3486     last_lastarg = savestring (last_lastarg);
3487
3488   parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
3489
3490   restore_parser_state (&ps);
3491   bind_variable ("_", last_lastarg, 0);
3492   FREE (last_lastarg);
3493
3494   if (token_to_read == '\n')    /* reset_parser was called */
3495     token_to_read = 0;
3496 }
3497
3498 /* Place to remember the token.  We try to keep the buffer
3499    at a reasonable size, but it can grow. */
3500 static char *token = (char *)NULL;
3501
3502 /* Current size of the token buffer. */
3503 static int token_buffer_size;
3504
3505 /* Command to read_token () explaining what we want it to do. */
3506 #define READ 0
3507 #define RESET 1
3508 #define prompt_is_ps1 \
3509       (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
3510
3511 /* Function for yyparse to call.  yylex keeps track of
3512    the last two tokens read, and calls read_token.  */
3513 static int
3514 yylex ()
3515 {
3516   if (interactive && (current_token == 0 || current_token == '\n'))
3517     {
3518       /* Before we print a prompt, we might have to check mailboxes.
3519          We do this only if it is time to do so. Notice that only here
3520          is the mail alarm reset; nothing takes place in check_mail ()
3521          except the checking of mail.  Please don't change this. */
3522       if (prompt_is_ps1 && time_to_check_mail ())
3523         {
3524           check_mail ();
3525           reset_mail_timer ();
3526         }
3527
3528       /* Avoid printing a prompt if we're not going to read anything, e.g.
3529          after resetting the parser with read_token (RESET). */
3530       if (token_to_read == 0 && SHOULD_PROMPT ())
3531         prompt_again ();
3532     }
3533
3534   two_tokens_ago = token_before_that;
3535   token_before_that = last_read_token;
3536   last_read_token = current_token;
3537   current_token = read_token (READ);
3538   return (current_token);
3539 }
3540
3541 /* When non-zero, we have read the required tokens
3542    which allow ESAC to be the next one read. */
3543 static int esacs_needed_count;
3544
3545 void
3546 gather_here_documents ()
3547 {
3548   int r = 0;
3549   while (need_here_doc)
3550     {
3551       make_here_document (redir_stack[r++]);
3552       need_here_doc--;
3553     }
3554 }
3555
3556 /* When non-zero, an open-brace used to create a group is awaiting a close
3557    brace partner. */
3558 static int open_brace_count;
3559
3560 #define command_token_position(token) \
3561   (((token) == ASSIGNMENT_WORD) || \
3562    ((token) != SEMI_SEMI && reserved_word_acceptable(token)))
3563
3564 #define assignment_acceptable(token) \
3565   (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
3566
3567 /* Check to see if TOKEN is a reserved word and return the token
3568    value if it is. */
3569 #define CHECK_FOR_RESERVED_WORD(tok) \
3570   do { \
3571     if (!dollar_present && !quoted && \
3572         reserved_word_acceptable (last_read_token)) \
3573       { \
3574         int i; \
3575         for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
3576           if (STREQ (tok, word_token_alist[i].word)) \
3577             { \
3578               if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
3579                 break; \
3580               if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
3581                 break; \
3582               if (word_token_alist[i].token == ESAC) \
3583                 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
3584               else if (word_token_alist[i].token == CASE) \
3585                 parser_state |= PST_CASESTMT; \
3586               else if (word_token_alist[i].token == COND_END) \
3587                 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
3588               else if (word_token_alist[i].token == COND_START) \
3589                 parser_state |= PST_CONDCMD; \
3590               else if (word_token_alist[i].token == '{') \
3591                 open_brace_count++; \
3592               else if (word_token_alist[i].token == '}' && open_brace_count) \
3593                 open_brace_count--; \
3594               return (word_token_alist[i].token); \
3595             } \
3596       } \
3597   } while (0)
3598
3599 #if defined (ALIAS)
3600
3601     /* OK, we have a token.  Let's try to alias expand it, if (and only if)
3602        it's eligible.
3603
3604        It is eligible for expansion if EXPAND_ALIASES is set, and
3605        the token is unquoted and the last token read was a command
3606        separator (or expand_next_token is set), and we are currently
3607        processing an alias (pushed_string_list is non-empty) and this
3608        token is not the same as the current or any previously
3609        processed alias.
3610
3611        Special cases that disqualify:
3612          In a pattern list in a case statement (parser_state & PST_CASEPAT). */
3613
3614 static char *
3615 mk_alexpansion (s)
3616      char *s;
3617 {
3618   int l;
3619   char *r;
3620
3621   l = strlen (s);
3622   r = xmalloc (l + 2);
3623   strcpy (r, s);
3624   if (r[l -1] != ' ')
3625     r[l++] = ' ';
3626   r[l] = '\0';
3627   return r;
3628 }
3629
3630 static int
3631 alias_expand_token (tokstr)
3632      char *tokstr;
3633 {
3634   char *expanded;
3635   alias_t *ap;
3636
3637   if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
3638         (parser_state & PST_CASEPAT) == 0)
3639     {
3640       ap = find_alias (tokstr);
3641
3642       /* Currently expanding this token. */
3643       if (ap && (ap->flags & AL_BEINGEXPANDED))
3644         return (NO_EXPANSION);
3645
3646       /* mk_alexpansion puts an extra space on the end of the alias expansion,
3647          so the lookahead by the parser works right.  If this gets changed,
3648          make sure the code in shell_getc that deals with reaching the end of
3649          an expanded alias is changed with it. */
3650       expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
3651
3652       if (expanded)
3653         {
3654           push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
3655           return (RE_READ_TOKEN);
3656         }
3657       else
3658         /* This is an eligible token that does not have an expansion. */
3659         return (NO_EXPANSION);
3660     }
3661   return (NO_EXPANSION);
3662 }
3663 #endif /* ALIAS */
3664
3665 static int
3666 time_command_acceptable ()
3667 {
3668 #if defined (COMMAND_TIMING)
3669   switch (last_read_token)
3670     {
3671     case 0:
3672     case ';':
3673     case '\n':
3674     case AND_AND:
3675     case OR_OR:
3676     case '&':
3677     case DO:
3678     case THEN:
3679     case ELSE:
3680     case '{':           /* } */
3681     case '(':           /* ) */
3682       return 1;
3683     default:
3684       return 0;
3685     }
3686 #else
3687   return 0;
3688 #endif /* COMMAND_TIMING */
3689 }
3690
3691 /* Handle special cases of token recognition:
3692         IN is recognized if the last token was WORD and the token
3693         before that was FOR or CASE or SELECT.
3694
3695         DO is recognized if the last token was WORD and the token
3696         before that was FOR or SELECT.
3697
3698         ESAC is recognized if the last token caused `esacs_needed_count'
3699         to be set
3700
3701         `{' is recognized if the last token as WORD and the token
3702         before that was FUNCTION, or if we just parsed an arithmetic
3703         `for' command.
3704
3705         `}' is recognized if there is an unclosed `{' present.
3706
3707         `-p' is returned as TIMEOPT if the last read token was TIME.
3708
3709         ']]' is returned as COND_END if the parser is currently parsing
3710         a conditional expression ((parser_state & PST_CONDEXPR) != 0)
3711
3712         `time' is returned as TIME if and only if it is immediately
3713         preceded by one of `;', `\n', `||', `&&', or `&'.
3714 */
3715
3716 static int
3717 special_case_tokens (tokstr)
3718      char *tokstr;
3719 {
3720   if ((last_read_token == WORD) &&
3721 #if defined (SELECT_COMMAND)
3722       ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
3723 #else
3724       ((token_before_that == FOR) || (token_before_that == CASE)) &&
3725 #endif
3726       (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
3727     {
3728       if (token_before_that == CASE)
3729         {
3730           parser_state |= PST_CASEPAT;
3731           esacs_needed_count++;
3732         }
3733       return (IN);
3734     }
3735
3736   if (last_read_token == WORD &&
3737 #if defined (SELECT_COMMAND)
3738       (token_before_that == FOR || token_before_that == SELECT) &&
3739 #else
3740       (token_before_that == FOR) &&
3741 #endif
3742       (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
3743     return (DO);
3744
3745   /* Ditto for ESAC in the CASE case.
3746      Specifically, this handles "case word in esac", which is a legal
3747      construct, certainly because someone will pass an empty arg to the
3748      case construct, and we don't want it to barf.  Of course, we should
3749      insist that the case construct has at least one pattern in it, but
3750      the designers disagree. */
3751   if (esacs_needed_count)
3752     {
3753       esacs_needed_count--;
3754       if (STREQ (tokstr, "esac"))
3755         {
3756           parser_state &= ~PST_CASEPAT;
3757           return (ESAC);
3758         }
3759     }
3760
3761   /* The start of a shell function definition. */
3762   if (parser_state & PST_ALLOWOPNBRC)
3763     {
3764       parser_state &= ~PST_ALLOWOPNBRC;
3765       if (tokstr[0] == '{' && tokstr[1] == '\0')                /* } */
3766         {
3767           open_brace_count++;
3768           function_bstart = line_number;
3769           return ('{');                                 /* } */
3770         }
3771     }
3772
3773   /* We allow a `do' after a for ((...)) without an intervening
3774      list_terminator */
3775   if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
3776     return (DO);
3777   if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0')      /* } */
3778     {
3779       open_brace_count++;
3780       return ('{');                     /* } */
3781     }
3782
3783   if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
3784     {
3785       open_brace_count--;               /* { */
3786       return ('}');
3787     }
3788
3789 #if defined (COMMAND_TIMING)
3790   /* Handle -p after `time'. */
3791   if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
3792     return (TIMEOPT);
3793 #endif
3794
3795 #if 0
3796 #if defined (COMMAND_TIMING)
3797   if (STREQ (token, "time") && ((parser_state & PST_CASEPAT) == 0) && time_command_acceptable ())
3798     return (TIME);
3799 #endif /* COMMAND_TIMING */
3800 #endif
3801
3802 #if defined (COND_COMMAND) /* [[ */
3803   if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
3804     return (COND_END);
3805 #endif
3806
3807   return (-1);
3808 }
3809
3810 /* Called from shell.c when Control-C is typed at top level.  Or
3811    by the error rule at top level. */
3812 void
3813 reset_parser ()
3814 {
3815   dstack.delimiter_depth = 0;   /* No delimiters found so far. */
3816   open_brace_count = 0;
3817
3818   parser_state = 0;
3819
3820 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
3821   if (pushed_string_list)
3822     free_string_list ();
3823 #endif /* ALIAS || DPAREN_ARITHMETIC */
3824
3825   if (shell_input_line)
3826     {
3827       free (shell_input_line);
3828       shell_input_line = (char *)NULL;
3829       shell_input_line_size = shell_input_line_index = 0;
3830     }
3831
3832   FREE (word_desc_to_read);
3833   word_desc_to_read = (WORD_DESC *)NULL;
3834
3835   last_read_token = '\n';
3836   token_to_read = '\n';
3837 }
3838
3839 /* Read the next token.  Command can be READ (normal operation) or
3840    RESET (to normalize state). */
3841 static int
3842 read_token (command)
3843      int command;
3844 {
3845   int character;                /* Current character. */
3846   int peek_char;                /* Temporary look-ahead character. */
3847   int result;                   /* The thing to return. */
3848
3849   if (command == RESET)
3850     {
3851       reset_parser ();
3852       return ('\n');
3853     }
3854
3855   if (token_to_read)
3856     {
3857       result = token_to_read;
3858       if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
3859         {
3860           yylval.word = word_desc_to_read;
3861           word_desc_to_read = (WORD_DESC *)NULL;
3862         }
3863       token_to_read = 0;
3864       return (result);
3865     }
3866
3867 #if defined (COND_COMMAND)
3868   if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
3869     {
3870       cond_lineno = line_number;
3871       parser_state |= PST_CONDEXPR;
3872       yylval.command = parse_cond_command ();
3873       if (cond_token != COND_END)
3874         {
3875           cond_error ();
3876           return (-1);
3877         }
3878       token_to_read = COND_END;
3879       parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
3880       return (COND_CMD);
3881     }
3882 #endif
3883
3884 #if defined (ALIAS)
3885   /* This is a place to jump back to once we have successfully expanded a
3886      token with an alias and pushed the string with push_string () */
3887  re_read_token:
3888 #endif /* ALIAS */
3889
3890   /* Read a single word from input.  Start by skipping blanks. */
3891   while ((character = shell_getc (1)) != EOF && shellblank (character))
3892     ;
3893
3894   if (character == EOF)
3895     {
3896       EOF_Reached = 1;
3897       return (yacc_EOF);
3898     }
3899
3900   if MBTEST(character == '#' && (!interactive || interactive_comments))
3901     {
3902       /* A comment.  Discard until EOL or EOF, and then return a newline. */
3903       discard_until ('\n');
3904       shell_getc (0);
3905       character = '\n'; /* this will take the next if statement and return. */
3906     }
3907
3908   if (character == '\n')
3909     {
3910       /* If we're about to return an unquoted newline, we can go and collect
3911          the text of any pending here document. */
3912       if (need_here_doc)
3913         gather_here_documents ();
3914
3915 #if defined (ALIAS)
3916       parser_state &= ~PST_ALEXPNEXT;
3917 #endif /* ALIAS */
3918
3919       parser_state &= ~PST_ASSIGNOK;
3920
3921       return (character);
3922     }
3923
3924   /* Shell meta-characters. */
3925   if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
3926     {
3927 #if defined (ALIAS)
3928       /* Turn off alias tokenization iff this character sequence would
3929          not leave us ready to read a command. */
3930       if (character == '<' || character == '>')
3931         parser_state &= ~PST_ALEXPNEXT;
3932 #endif /* ALIAS */
3933
3934       parser_state &= ~PST_ASSIGNOK;
3935
3936       peek_char = shell_getc (1);
3937       if (character == peek_char)
3938         {
3939           switch (character)
3940             {
3941             case '<':
3942               /* If '<' then we could be at "<<" or at "<<-".  We have to
3943                  look ahead one more character. */
3944               peek_char = shell_getc (1);
3945               if (peek_char == '-')
3946                 return (LESS_LESS_MINUS);
3947               else if (peek_char == '<')
3948                 return (LESS_LESS_LESS);
3949               else
3950                 {
3951                   shell_ungetc (peek_char);
3952                   return (LESS_LESS);
3953                 }
3954
3955             case '>':
3956               return (GREATER_GREATER);
3957
3958             case ';':
3959               parser_state |= PST_CASEPAT;
3960 #if defined (ALIAS)
3961               parser_state &= ~PST_ALEXPNEXT;
3962 #endif /* ALIAS */
3963
3964               return (SEMI_SEMI);
3965
3966             case '&':
3967               return (AND_AND);
3968
3969             case '|':
3970               return (OR_OR);
3971
3972 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
3973             case '(':           /* ) */
3974               result = parse_dparen (character);
3975               if (result == -2)
3976                 break;
3977               else
3978                 return result;
3979 #endif
3980             }
3981         }
3982       else if MBTEST(character == '<' && peek_char == '&')
3983         return (LESS_AND);
3984       else if MBTEST(character == '>' && peek_char == '&')
3985         return (GREATER_AND);
3986       else if MBTEST(character == '<' && peek_char == '>')
3987         return (LESS_GREATER);
3988       else if MBTEST(character == '>' && peek_char == '|')
3989         return (GREATER_BAR);
3990       else if MBTEST(peek_char == '>' && character == '&')
3991         return (AND_GREATER);
3992
3993       shell_ungetc (peek_char);
3994
3995       /* If we look like we are reading the start of a function
3996          definition, then let the reader know about it so that
3997          we will do the right thing with `{'. */
3998       if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
3999         {
4000           parser_state |= PST_ALLOWOPNBRC;
4001 #if defined (ALIAS)
4002           parser_state &= ~PST_ALEXPNEXT;
4003 #endif /* ALIAS */
4004           function_dstart = line_number;
4005         }
4006
4007       /* case pattern lists may be preceded by an optional left paren.  If
4008          we're not trying to parse a case pattern list, the left paren
4009          indicates a subshell. */
4010       if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
4011         parser_state |= PST_SUBSHELL;
4012       /*(*/
4013       else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
4014         parser_state &= ~PST_CASEPAT;
4015       /*(*/
4016       else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
4017         parser_state &= ~PST_SUBSHELL;
4018
4019 #if defined (PROCESS_SUBSTITUTION)
4020       /* Check for the constructs which introduce process substitution.
4021          Shells running in `posix mode' don't do process substitution. */
4022       if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
4023 #endif /* PROCESS_SUBSTITUTION */
4024         return (character);
4025     }
4026
4027   /* Hack <&- (close stdin) case.  Also <&N- (dup and close). */
4028   if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
4029     return (character);
4030
4031   /* Okay, if we got this far, we have to read a word.  Read one,
4032      and then check it against the known ones. */
4033   result = read_token_word (character);
4034 #if defined (ALIAS)
4035   if (result == RE_READ_TOKEN)
4036     goto re_read_token;
4037 #endif
4038   return result;
4039 }
4040
4041 /*
4042  * Match a $(...) or other grouping construct.  This has to handle embedded
4043  * quoted strings ('', ``, "") and nested constructs.  It also must handle
4044  * reprompting the user, if necessary, after reading a newline, and returning
4045  * correct error values if it reads EOF.
4046  */
4047 #define P_FIRSTCLOSE    0x01
4048 #define P_ALLOWESC      0x02
4049 #define P_DQUOTE        0x04
4050 #define P_COMMAND       0x08    /* parsing a command, so look for comments */
4051 #define P_BACKQUOTE     0x10    /* parsing a backquoted command substitution */
4052
4053 static char matched_pair_error;
4054 static char *
4055 parse_matched_pair (qc, open, close, lenp, flags)
4056      int qc;    /* `"' if this construct is within double quotes */
4057      int open, close;
4058      int *lenp, flags;
4059 {
4060   int count, ch, was_dollar, in_comment, check_comment;
4061   int pass_next_character, backq_backslash, nestlen, ttranslen, start_lineno;
4062   char *ret, *nestret, *ttrans;
4063   int retind, retsize, rflags;
4064
4065 /* itrace("parse_matched_pair: open = %c close = %c", open, close); */
4066   count = 1;
4067   pass_next_character = backq_backslash = was_dollar = in_comment = 0;
4068   check_comment = (flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0;
4069
4070   /* RFLAGS is the set of flags we want to pass to recursive calls. */
4071   rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
4072
4073   ret = (char *)xmalloc (retsize = 64);
4074   retind = 0;
4075
4076   start_lineno = line_number;
4077   while (count)
4078     {
4079       ch = shell_getc (qc != '\'' && pass_next_character == 0 && backq_backslash == 0);
4080
4081       if (ch == EOF)
4082         {
4083           free (ret);
4084           parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
4085           EOF_Reached = 1;      /* XXX */
4086           return (&matched_pair_error);
4087         }
4088
4089       /* Possible reprompting. */
4090       if (ch == '\n' && SHOULD_PROMPT ())
4091         prompt_again ();
4092
4093       if (in_comment)
4094         {
4095           /* Add this character. */
4096           RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
4097           ret[retind++] = ch;
4098
4099           if (ch == '\n')
4100             in_comment = 0;
4101
4102           continue;
4103         }
4104       /* Not exactly right yet, should handle shell metacharacters, too.  If
4105          any changes are made to this test, make analogous changes to subst.c:
4106          extract_delimited_string(). */
4107       else if MBTEST(check_comment && in_comment == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || whitespace (ret[retind - 1])))
4108         in_comment = 1;
4109
4110       /* last char was backslash inside backquoted command substitution */
4111       if (backq_backslash)
4112         {
4113           backq_backslash = 0;
4114           /* Placeholder for adding special characters */
4115         }
4116
4117       if (pass_next_character)          /* last char was backslash */
4118         {
4119           pass_next_character = 0;
4120           if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
4121             {
4122               if (retind > 0) retind--; /* swallow previously-added backslash */
4123               continue;
4124             }
4125
4126           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
4127           if MBTEST(ch == CTLESC || ch == CTLNUL)
4128             ret[retind++] = CTLESC;
4129           ret[retind++] = ch;
4130           continue;
4131         }
4132       else if MBTEST(ch == CTLESC || ch == CTLNUL)      /* special shell escapes */
4133         {
4134           RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
4135           ret[retind++] = CTLESC;
4136           ret[retind++] = ch;
4137           continue;
4138         }
4139       else if MBTEST(ch == close)               /* ending delimiter */
4140         count--;
4141       /* handle nested ${...} specially. */
4142       else if MBTEST(open != close && was_dollar && open == '{' && ch == open) /* } */
4143         count++;
4144       else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open)       /* nested begin */
4145         count++;
4146
4147       /* Add this character. */
4148       RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
4149       ret[retind++] = ch;
4150
4151       if (open == '\'')                 /* '' inside grouping construct */
4152         {
4153           if MBTEST((flags & P_ALLOWESC) && ch == '\\')
4154             pass_next_character++;
4155 #if 0
4156           else if MBTEST((flags & P_BACKQUOTE) && ch == '\\')
4157             backq_backslash++;
4158 #endif
4159           continue;
4160         }
4161
4162       if MBTEST(ch == '\\')                     /* backslashes */
4163         pass_next_character++;
4164
4165       if (open != close)                /* a grouping construct */
4166         {
4167           if MBTEST(shellquote (ch))
4168             {
4169               /* '', ``, or "" inside $(...) or other grouping construct. */
4170               push_delimiter (dstack, ch);
4171               if MBTEST(was_dollar && ch == '\'')       /* $'...' inside group */
4172                 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
4173               else
4174                 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
4175               pop_delimiter (dstack);
4176               if (nestret == &matched_pair_error)
4177                 {
4178                   free (ret);
4179                   return &matched_pair_error;
4180                 }
4181               if MBTEST(was_dollar && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
4182                 {
4183                   /* Translate $'...' here. */
4184                   ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
4185                   xfree (nestret);
4186
4187                   if ((rflags & P_DQUOTE) == 0)
4188                     {
4189                       nestret = sh_single_quote (ttrans);
4190                       free (ttrans);
4191                       nestlen = strlen (nestret);
4192                     }
4193                   else
4194                     {
4195                       nestret = ttrans;
4196                       nestlen = ttranslen;
4197                     }
4198                   retind -= 2;          /* back up before the $' */
4199                 }
4200               else if MBTEST(was_dollar && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
4201                 {
4202                   /* Locale expand $"..." here. */
4203                   ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
4204                   xfree (nestret);
4205
4206                   nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
4207                   free (ttrans);
4208                   nestlen = ttranslen + 2;
4209                   retind -= 2;          /* back up before the $" */
4210                 }
4211
4212               if (nestlen)
4213                 {
4214                   RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
4215                   strcpy (ret + retind, nestret);
4216                   retind += nestlen;
4217                 }
4218               FREE (nestret);
4219             }
4220         }
4221       /* Parse an old-style command substitution within double quotes as a
4222          single word. */
4223       /* XXX - sh and ksh93 don't do this - XXX */
4224       else if MBTEST(open == '"' && ch == '`')
4225         {
4226           nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
4227 add_nestret:
4228           if (nestret == &matched_pair_error)
4229             {
4230               free (ret);
4231               return &matched_pair_error;
4232             }
4233           if (nestlen)
4234             {
4235               RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64);
4236               strcpy (ret + retind, nestret);
4237               retind += nestlen;
4238             }
4239           FREE (nestret);
4240         }
4241 #if 0
4242       else if MBTEST(qc == '`' && (ch == '"' || ch == '\'') && in_comment == 0)
4243         {
4244           /* Add P_BACKQUOTE so backslash quotes the next character and
4245              shell_getc does the right thing with \<newline>.  We do this for
4246              a measure  of backwards compatibility -- it's not strictly the
4247              right POSIX thing. */
4248           nestret = parse_matched_pair (0, ch, ch, &nestlen, rflags|P_BACKQUOTE);
4249           goto add_nestret;
4250         }
4251 #endif
4252       else if MBTEST(open != '`' && was_dollar && (ch == '(' || ch == '{' || ch == '['))        /* ) } ] */
4253         /* check for $(), $[], or ${} inside quoted string. */
4254         {
4255           if (open == ch)       /* undo previous increment */
4256             count--;
4257           if (ch == '(')                /* ) */
4258             nestret = parse_matched_pair (0, '(', ')', &nestlen, rflags & ~P_DQUOTE);
4259           else if (ch == '{')           /* } */
4260             nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
4261           else if (ch == '[')           /* ] */
4262             nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
4263
4264           goto add_nestret;
4265         }
4266       was_dollar = MBTEST(ch == '$');
4267     }
4268
4269   ret[retind] = '\0';
4270   if (lenp)
4271     *lenp = retind;
4272   return ret;
4273 }
4274
4275 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
4276 /* Parse a double-paren construct.  It can be either an arithmetic
4277    command, an arithmetic `for' command, or a nested subshell.  Returns
4278    the parsed token, -1 on error, or -2 if we didn't do anything and
4279    should just go on. */
4280 static int
4281 parse_dparen (c)
4282      int c;
4283 {
4284   int cmdtyp, sline;
4285   char *wval;
4286   WORD_DESC *wd;
4287
4288 #if defined (ARITH_FOR_COMMAND)
4289   if (last_read_token == FOR)
4290     {
4291       arith_for_lineno = line_number;
4292       cmdtyp = parse_arith_cmd (&wval, 0);
4293       if (cmdtyp == 1)
4294         {
4295           wd = alloc_word_desc ();
4296           wd->word = wval;
4297           yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
4298           return (ARITH_FOR_EXPRS);
4299         }
4300       else
4301         return -1;              /* ERROR */
4302     }
4303 #endif
4304
4305 #if defined (DPAREN_ARITHMETIC)
4306   if (reserved_word_acceptable (last_read_token))
4307     {
4308       sline = line_number;
4309
4310       cmdtyp = parse_arith_cmd (&wval, 0);
4311       if (cmdtyp == 1)  /* arithmetic command */
4312         {
4313           wd = alloc_word_desc ();
4314           wd->word = wval;
4315           wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
4316           yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
4317           return (ARITH_CMD);
4318         }
4319       else if (cmdtyp == 0)     /* nested subshell */
4320         {
4321           push_string (wval, 0, (alias_t *)NULL);
4322           if ((parser_state & PST_CASEPAT) == 0)
4323             parser_state |= PST_SUBSHELL;
4324           return (c);
4325         }
4326       else                      /* ERROR */
4327         return -1;
4328     }
4329 #endif
4330
4331   return -2;                    /* XXX */
4332 }
4333
4334 /* We've seen a `(('.  Look for the matching `))'.  If we get it, return 1.
4335    If not, assume it's a nested subshell for backwards compatibility and
4336    return 0.  In any case, put the characters we've consumed into a locally-
4337    allocated buffer and make *ep point to that buffer.  Return -1 on an
4338    error, for example EOF. */
4339 static int
4340 parse_arith_cmd (ep, adddq)
4341      char **ep;
4342      int adddq;
4343 {
4344   int exp_lineno, rval, c;
4345   char *ttok, *tokstr;
4346   int ttoklen;
4347
4348   exp_lineno = line_number;
4349   ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
4350   rval = 1;
4351   if (ttok == &matched_pair_error)
4352     return -1;
4353   /* Check that the next character is the closing right paren.  If
4354      not, this is a syntax error. ( */
4355   c = shell_getc (0);
4356   if MBTEST(c != ')')
4357     rval = 0;
4358
4359   tokstr = (char *)xmalloc (ttoklen + 4);
4360
4361   /* if ADDDQ != 0 then (( ... )) -> "..." */
4362   if (rval == 1 && adddq)       /* arith cmd, add double quotes */
4363     {
4364       tokstr[0] = '"';
4365       strncpy (tokstr + 1, ttok, ttoklen - 1);
4366       tokstr[ttoklen] = '"';
4367       tokstr[ttoklen+1] = '\0';
4368     }
4369   else if (rval == 1)           /* arith cmd, don't add double quotes */
4370     {
4371       strncpy (tokstr, ttok, ttoklen - 1);
4372       tokstr[ttoklen-1] = '\0';
4373     }
4374   else                          /* nested subshell */
4375     {
4376       tokstr[0] = '(';
4377       strncpy (tokstr + 1, ttok, ttoklen - 1);
4378       tokstr[ttoklen] = ')';
4379       tokstr[ttoklen+1] = c;
4380       tokstr[ttoklen+2] = '\0';
4381     }
4382
4383   *ep = tokstr;
4384   FREE (ttok);
4385   return rval;
4386 }
4387 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
4388
4389 #if defined (COND_COMMAND)
4390 static void
4391 cond_error ()
4392 {
4393   char *etext;
4394
4395   if (EOF_Reached && cond_token != COND_ERROR)          /* [[ */
4396     parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
4397   else if (cond_token != COND_ERROR)
4398     {
4399       if (etext = error_token_from_token (cond_token))
4400         {
4401           parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
4402           free (etext);
4403         }
4404       else
4405         parser_error (cond_lineno, _("syntax error in conditional expression"));
4406     }
4407 }
4408
4409 static COND_COM *
4410 cond_expr ()
4411 {
4412   return (cond_or ());
4413 }
4414
4415 static COND_COM *
4416 cond_or ()
4417 {
4418   COND_COM *l, *r;
4419
4420   l = cond_and ();
4421   if (cond_token == OR_OR)
4422     {
4423       r = cond_or ();
4424       l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
4425     }
4426   return l;
4427 }
4428
4429 static COND_COM *
4430 cond_and ()
4431 {
4432   COND_COM *l, *r;
4433
4434   l = cond_term ();
4435   if (cond_token == AND_AND)
4436     {
4437       r = cond_and ();
4438       l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
4439     }
4440   return l;
4441 }
4442
4443 static int
4444 cond_skip_newlines ()
4445 {
4446   while ((cond_token = read_token (READ)) == '\n')
4447     {
4448       if (SHOULD_PROMPT ())
4449         prompt_again ();
4450     }
4451   return (cond_token);
4452 }
4453
4454 #define COND_RETURN_ERROR() \
4455   do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
4456
4457 static COND_COM *
4458 cond_term ()
4459 {
4460   WORD_DESC *op;
4461   COND_COM *term, *tleft, *tright;
4462   int tok, lineno;
4463   char *etext;
4464
4465   /* Read a token.  It can be a left paren, a `!', a unary operator, or a
4466      word that should be the first argument of a binary operator.  Start by
4467      skipping newlines, since this is a compound command. */
4468   tok = cond_skip_newlines ();
4469   lineno = line_number;
4470   if (tok == COND_END)
4471     {
4472       COND_RETURN_ERROR ();
4473     }
4474   else if (tok == '(')
4475     {
4476       term = cond_expr ();
4477       if (cond_token != ')')
4478         {
4479           if (term)
4480             dispose_cond_node (term);           /* ( */
4481           if (etext = error_token_from_token (cond_token))
4482             {
4483               parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
4484               free (etext);
4485             }
4486           else
4487             parser_error (lineno, _("expected `)'"));
4488           COND_RETURN_ERROR ();
4489         }
4490       term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
4491       (void)cond_skip_newlines ();
4492     }
4493   else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
4494     {
4495       if (tok == WORD)
4496         dispose_word (yylval.word);     /* not needed */
4497       term = cond_term ();
4498       if (term)
4499         term->flags |= CMD_INVERT_RETURN;
4500     }
4501   else if (tok == WORD && test_unop (yylval.word->word))
4502     {
4503       op = yylval.word;
4504       tok = read_token (READ);
4505       if (tok == WORD)
4506         {
4507           tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4508           term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4509         }
4510       else
4511         {
4512           dispose_word (op);
4513           if (etext = error_token_from_token (tok))
4514             {
4515               parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
4516               free (etext);
4517             }
4518           else
4519             parser_error (line_number, _("unexpected argument to conditional unary operator"));
4520           COND_RETURN_ERROR ();
4521         }
4522
4523       (void)cond_skip_newlines ();
4524     }
4525   else if (tok == WORD)         /* left argument to binary operator */
4526     {
4527       /* lhs */
4528       tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4529
4530       /* binop */
4531       tok = read_token (READ);
4532       if (tok == WORD && test_binop (yylval.word->word))
4533         op = yylval.word;
4534 #if defined (COND_REGEXP)
4535       else if (tok == WORD && STREQ (yylval.word->word,"=~"))
4536         op = yylval.word;
4537 #endif
4538       else if (tok == '<' || tok == '>')
4539         op = make_word_from_token (tok);  /* ( */
4540       /* There should be a check before blindly accepting the `)' that we have
4541          seen the opening `('. */
4542       else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
4543         {
4544           /* Special case.  [[ x ]] is equivalent to [[ -n x ]], just like
4545              the test command.  Similarly for [[ x && expr ]] or
4546              [[ x || expr ]] or [[ (x) ]]. */
4547           op = make_word ("-n");
4548           term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4549           cond_token = tok;
4550           return (term);
4551         }
4552       else
4553         {
4554           if (etext = error_token_from_token (tok))
4555             {
4556               parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
4557               free (etext);
4558             }
4559           else
4560             parser_error (line_number, _("conditional binary operator expected"));
4561           dispose_cond_node (tleft);
4562           COND_RETURN_ERROR ();
4563         }
4564
4565       /* rhs */
4566       tok = read_token (READ);
4567       if (tok == WORD)
4568         {
4569           tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4570           term = make_cond_node (COND_BINARY, op, tleft, tright);
4571         }
4572       else
4573         {
4574           if (etext = error_token_from_token (tok))
4575             {
4576               parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
4577               free (etext);
4578             }
4579           else
4580             parser_error (line_number, _("unexpected argument to conditional binary operator"));
4581           dispose_cond_node (tleft);
4582           dispose_word (op);
4583           COND_RETURN_ERROR ();
4584         }
4585
4586       (void)cond_skip_newlines ();
4587     }
4588   else
4589     {
4590       if (tok < 256)
4591         parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
4592       else if (etext = error_token_from_token (tok))
4593         {
4594           parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
4595           free (etext);
4596         }
4597       else
4598         parser_error (line_number, _("unexpected token %d in conditional command"), tok);
4599       COND_RETURN_ERROR ();
4600     }
4601   return (term);
4602 }
4603
4604 /* This is kind of bogus -- we slip a mini recursive-descent parser in
4605    here to handle the conditional statement syntax. */
4606 static COMMAND *
4607 parse_cond_command ()
4608 {
4609   COND_COM *cexp;
4610
4611   cexp = cond_expr ();
4612   return (make_cond_command (cexp));
4613 }
4614 #endif
4615
4616 #if defined (ARRAY_VARS)
4617 /* When this is called, it's guaranteed that we don't care about anything
4618    in t beyond i.  We do save and restore the chars, though. */
4619 static int
4620 token_is_assignment (t, i)
4621      char *t;
4622      int i;
4623 {
4624   unsigned char c, c1;
4625   int r;
4626
4627   c = t[i]; c1 = t[i+1];
4628   t[i] = '='; t[i+1] = '\0';
4629   r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
4630   t[i] = c; t[i+1] = c1;
4631   return r;
4632 }
4633
4634 /* XXX - possible changes here for `+=' */
4635 static int
4636 token_is_ident (t, i)
4637      char *t;
4638      int i;
4639 {
4640   unsigned char c;
4641   int r;
4642
4643   c = t[i];
4644   t[i] = '\0';
4645   r = legal_identifier (t);
4646   t[i] = c;
4647   return r;
4648 }
4649 #endif
4650
4651 static int
4652 read_token_word (character)
4653      int character;
4654 {
4655   /* The value for YYLVAL when a WORD is read. */
4656   WORD_DESC *the_word;
4657
4658   /* Index into the token that we are building. */
4659   int token_index;
4660
4661   /* ALL_DIGITS becomes zero when we see a non-digit. */
4662   int all_digit_token;
4663
4664   /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
4665   int dollar_present;
4666
4667   /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
4668      assignment. */
4669   int compound_assignment;
4670
4671   /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
4672   int quoted;
4673
4674   /* Non-zero means to ignore the value of the next character, and just
4675      to add it no matter what. */
4676  int pass_next_character;
4677
4678   /* The current delimiting character. */
4679   int cd;
4680   int result, peek_char;
4681   char *ttok, *ttrans;
4682   int ttoklen, ttranslen;
4683   intmax_t lvalue;
4684
4685   if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
4686     token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
4687
4688   token_index = 0;
4689   all_digit_token = DIGIT (character);
4690   dollar_present = quoted = pass_next_character = compound_assignment = 0;
4691
4692   for (;;)
4693     {
4694       if (character == EOF)
4695         goto got_token;
4696
4697       if (pass_next_character)
4698         {
4699           pass_next_character = 0;
4700           goto got_character;
4701         }
4702
4703       cd = current_delimiter (dstack);
4704
4705       /* Handle backslashes.  Quote lots of things when not inside of
4706          double-quotes, quote some things inside of double-quotes. */
4707       if MBTEST(character == '\\')
4708         {
4709           peek_char = shell_getc (0);
4710
4711           /* Backslash-newline is ignored in all cases except
4712              when quoted with single quotes. */
4713           if (peek_char == '\n')
4714             {
4715               character = '\n';
4716               goto next_character;
4717             }
4718           else
4719             {
4720               shell_ungetc (peek_char);
4721
4722               /* If the next character is to be quoted, note it now. */
4723               if (cd == 0 || cd == '`' ||
4724                   (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
4725                 pass_next_character++;
4726
4727               quoted = 1;
4728               goto got_character;
4729             }
4730         }
4731
4732       /* Parse a matched pair of quote characters. */
4733       if MBTEST(shellquote (character))
4734         {
4735           push_delimiter (dstack, character);
4736           ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
4737           pop_delimiter (dstack);
4738           if (ttok == &matched_pair_error)
4739             return -1;          /* Bail immediately. */
4740           RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4741                                   token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4742           token[token_index++] = character;
4743           strcpy (token + token_index, ttok);
4744           token_index += ttoklen;
4745           all_digit_token = 0;
4746           quoted = 1;
4747           dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
4748           FREE (ttok);
4749           goto next_character;
4750         }
4751
4752 #ifdef EXTENDED_GLOB
4753       /* Parse a ksh-style extended pattern matching specification. */
4754       if (extended_glob && PATTERN_CHAR (character))
4755         {
4756           peek_char = shell_getc (1);
4757           if MBTEST(peek_char == '(')           /* ) */
4758             {
4759               push_delimiter (dstack, peek_char);
4760               ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4761               pop_delimiter (dstack);
4762               if (ttok == &matched_pair_error)
4763                 return -1;              /* Bail immediately. */
4764               RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4765                                       token_buffer_size,
4766                                       TOKEN_DEFAULT_GROW_SIZE);
4767               token[token_index++] = character;
4768               token[token_index++] = peek_char;
4769               strcpy (token + token_index, ttok);
4770               token_index += ttoklen;
4771               FREE (ttok);
4772               dollar_present = all_digit_token = 0;
4773               goto next_character;
4774             }
4775           else
4776             shell_ungetc (peek_char);
4777         }
4778 #endif /* EXTENDED_GLOB */
4779
4780       /* If the delimiter character is not single quote, parse some of
4781          the shell expansions that must be read as a single word. */
4782       if (shellexp (character))
4783         {
4784           peek_char = shell_getc (1);
4785           /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
4786           if MBTEST(peek_char == '(' || \
4787                 ((peek_char == '{' || peek_char == '[') && character == '$'))   /* ) ] } */
4788             {
4789               if (peek_char == '{')             /* } */
4790                 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE);
4791               else if (peek_char == '(')                /* ) */
4792                 {
4793                   /* XXX - push and pop the `(' as a delimiter for use by
4794                      the command-oriented-history code.  This way newlines
4795                      appearing in the $(...) string get added to the
4796                      history literally rather than causing a possibly-
4797                      incorrect `;' to be added. ) */
4798                   push_delimiter (dstack, peek_char);
4799                   ttok = parse_matched_pair (cd, '(', ')', &ttoklen, P_COMMAND);
4800                   pop_delimiter (dstack);
4801                 }
4802               else
4803                 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4804               if (ttok == &matched_pair_error)
4805                 return -1;              /* Bail immediately. */
4806               RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4807                                       token_buffer_size,
4808                                       TOKEN_DEFAULT_GROW_SIZE);
4809               token[token_index++] = character;
4810               token[token_index++] = peek_char;
4811               strcpy (token + token_index, ttok);
4812               token_index += ttoklen;
4813               FREE (ttok);
4814               dollar_present = 1;
4815               all_digit_token = 0;
4816               goto next_character;
4817             }
4818           /* This handles $'...' and $"..." new-style quoted strings. */
4819           else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
4820             {
4821               int first_line;
4822
4823               first_line = line_number;
4824               push_delimiter (dstack, peek_char);
4825               ttok = parse_matched_pair (peek_char, peek_char, peek_char,
4826                                          &ttoklen,
4827                                          (peek_char == '\'') ? P_ALLOWESC : 0);
4828               pop_delimiter (dstack);
4829               if (ttok == &matched_pair_error)
4830                 return -1;
4831               if (peek_char == '\'')
4832                 {
4833                   ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
4834                   free (ttok);
4835
4836                   /* Insert the single quotes and correctly quote any
4837                      embedded single quotes (allowed because P_ALLOWESC was
4838                      passed to parse_matched_pair). */
4839                   ttok = sh_single_quote (ttrans);
4840                   free (ttrans);
4841                   ttranslen = strlen (ttok);
4842                   ttrans = ttok;
4843                 }
4844               else
4845                 {
4846                   /* Try to locale-expand the converted string. */
4847                   ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
4848                   free (ttok);
4849
4850                   /* Add the double quotes back */
4851                   ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
4852                   free (ttrans);
4853                   ttranslen += 2;
4854                   ttrans = ttok;
4855                 }
4856
4857               RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
4858                                       token_buffer_size,
4859                                       TOKEN_DEFAULT_GROW_SIZE);
4860               strcpy (token + token_index, ttrans);
4861               token_index += ttranslen;
4862               FREE (ttrans);
4863               quoted = 1;
4864               all_digit_token = 0;
4865               goto next_character;
4866             }
4867           /* This could eventually be extended to recognize all of the
4868              shell's single-character parameter expansions, and set flags.*/
4869           else if MBTEST(character == '$' && peek_char == '$')
4870             {
4871               ttok = (char *)xmalloc (3);
4872               ttok[0] = ttok[1] = '$';
4873               ttok[2] = '\0';
4874               RESIZE_MALLOCED_BUFFER (token, token_index, 3,
4875                                       token_buffer_size,
4876                                       TOKEN_DEFAULT_GROW_SIZE);
4877               strcpy (token + token_index, ttok);
4878               token_index += 2;
4879               dollar_present = 1;
4880               all_digit_token = 0;
4881               FREE (ttok);
4882               goto next_character;
4883             }
4884           else
4885             shell_ungetc (peek_char);
4886         }
4887
4888 #if defined (ARRAY_VARS)
4889       /* Identify possible array subscript assignment; match [...] */
4890       else if MBTEST(character == '[' && token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index))     /* ] */
4891         {
4892           ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4893           if (ttok == &matched_pair_error)
4894             return -1;          /* Bail immediately. */
4895           RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4896                                   token_buffer_size,
4897                                   TOKEN_DEFAULT_GROW_SIZE);
4898           token[token_index++] = character;
4899           strcpy (token + token_index, ttok);
4900           token_index += ttoklen;
4901           FREE (ttok);
4902           all_digit_token = 0;
4903           goto next_character;
4904         }
4905       /* Identify possible compound array variable assignment. */
4906       else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
4907         {
4908           peek_char = shell_getc (1);
4909           if MBTEST(peek_char == '(')           /* ) */
4910             {
4911               ttok = parse_compound_assignment (&ttoklen);
4912
4913               RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
4914                                       token_buffer_size,
4915                                       TOKEN_DEFAULT_GROW_SIZE);
4916
4917               token[token_index++] = '=';
4918               token[token_index++] = '(';
4919               if (ttok)
4920                 {
4921                   strcpy (token + token_index, ttok);
4922                   token_index += ttoklen;
4923                 }
4924               token[token_index++] = ')';
4925               FREE (ttok);
4926               all_digit_token = 0;
4927               compound_assignment = 1;
4928 #if 1
4929               goto next_character;
4930 #else
4931               goto got_token;           /* ksh93 seems to do this */
4932 #endif
4933             }
4934           else
4935             shell_ungetc (peek_char);
4936         }
4937 #endif
4938
4939       /* When not parsing a multi-character word construct, shell meta-
4940          characters break words. */
4941       if MBTEST(shellbreak (character))
4942         {
4943           shell_ungetc (character);
4944           goto got_token;
4945         }
4946
4947     got_character:
4948
4949       all_digit_token &= DIGIT (character);
4950       dollar_present |= character == '$';
4951
4952       if (character == CTLESC || character == CTLNUL)
4953         token[token_index++] = CTLESC;
4954
4955       token[token_index++] = character;
4956
4957       RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
4958                               TOKEN_DEFAULT_GROW_SIZE);
4959
4960     next_character:
4961       if (character == '\n' && SHOULD_PROMPT ())
4962         prompt_again ();
4963
4964       /* We want to remove quoted newlines (that is, a \<newline> pair)
4965          unless we are within single quotes or pass_next_character is
4966          set (the shell equivalent of literal-next). */
4967       cd = current_delimiter (dstack);
4968       character = shell_getc (cd != '\'' && pass_next_character == 0);
4969     }   /* end for (;;) */
4970
4971 got_token:
4972
4973   token[token_index] = '\0';
4974
4975   /* Check to see what thing we should return.  If the last_read_token
4976      is a `<', or a `&', or the character which ended this token is
4977      a '>' or '<', then, and ONLY then, is this input token a NUMBER.
4978      Otherwise, it is just a word, and should be returned as such. */
4979   if MBTEST(all_digit_token && (character == '<' || character == '>' || \
4980                     last_read_token == LESS_AND || \
4981                     last_read_token == GREATER_AND))
4982       {
4983         if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
4984           yylval.number = lvalue;
4985         else
4986           yylval.number = -1;
4987         return (NUMBER);
4988       }
4989
4990   /* Check for special case tokens. */
4991   result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
4992   if (result >= 0)
4993     return result;
4994
4995 #if defined (ALIAS)
4996   /* Posix.2 does not allow reserved words to be aliased, so check for all
4997      of them, including special cases, before expanding the current token
4998      as an alias. */
4999   if MBTEST(posixly_correct)
5000     CHECK_FOR_RESERVED_WORD (token);
5001
5002   /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
5003      inhibits alias expansion. */
5004   if (expand_aliases && quoted == 0)
5005     {
5006       result = alias_expand_token (token);
5007       if (result == RE_READ_TOKEN)
5008         return (RE_READ_TOKEN);
5009       else if (result == NO_EXPANSION)
5010         parser_state &= ~PST_ALEXPNEXT;
5011     }
5012
5013   /* If not in Posix.2 mode, check for reserved words after alias
5014      expansion. */
5015   if MBTEST(posixly_correct == 0)
5016 #endif
5017     CHECK_FOR_RESERVED_WORD (token);
5018
5019   the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
5020   the_word->word = (char *)xmalloc (1 + token_index);
5021   the_word->flags = 0;
5022   strcpy (the_word->word, token);
5023   if (dollar_present)
5024     the_word->flags |= W_HASDOLLAR;
5025   if (quoted)
5026     the_word->flags |= W_QUOTED;                /*(*/
5027   if (compound_assignment && token[token_index-1] == ')')
5028     the_word->flags |= W_COMPASSIGN;
5029   /* A word is an assignment if it appears at the beginning of a
5030      simple command, or after another assignment word.  This is
5031      context-dependent, so it cannot be handled in the grammar. */
5032   if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
5033     {
5034       the_word->flags |= W_ASSIGNMENT;
5035       /* Don't perform word splitting on assignment statements. */
5036       if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
5037         the_word->flags |= W_NOSPLIT;
5038     }
5039
5040   if (command_token_position (last_read_token))
5041     {
5042       struct builtin *b;
5043       b = builtin_address_internal (token, 0);
5044       if (b && (b->flags & ASSIGNMENT_BUILTIN))
5045         parser_state |= PST_ASSIGNOK;
5046       else if (STREQ (token, "eval") || STREQ (token, "let"))
5047         parser_state |= PST_ASSIGNOK;
5048     }
5049
5050   yylval.word = the_word;
5051
5052   result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
5053                 ? ASSIGNMENT_WORD : WORD;
5054
5055   switch (last_read_token)
5056     {
5057     case FUNCTION:
5058       parser_state |= PST_ALLOWOPNBRC;
5059       function_dstart = line_number;
5060       break;
5061     case CASE:
5062     case SELECT:
5063     case FOR:
5064       if (word_top < MAX_CASE_NEST)
5065         word_top++;
5066       word_lineno[word_top] = line_number;
5067       break;
5068     }
5069
5070   return (result);
5071 }
5072
5073 /* Return 1 if TOKSYM is a token that after being read would allow
5074    a reserved word to be seen, else 0. */
5075 static int
5076 reserved_word_acceptable (toksym)
5077      int toksym;
5078 {
5079   switch (toksym)
5080     {
5081     case '\n':
5082     case ';':
5083     case '(':
5084     case ')':
5085     case '|':
5086     case '&':
5087     case '{':
5088     case '}':           /* XXX */
5089     case AND_AND:
5090     case BANG:
5091     case DO:
5092     case DONE:
5093     case ELIF:
5094     case ELSE:
5095     case ESAC:
5096     case FI:
5097     case IF:
5098     case OR_OR:
5099     case SEMI_SEMI:
5100     case THEN:
5101     case TIME:
5102     case TIMEOPT:
5103     case UNTIL:
5104     case WHILE:
5105     case 0:
5106       return 1;
5107     default:
5108       return 0;
5109     }
5110 }
5111
5112 /* Return the index of TOKEN in the alist of reserved words, or -1 if
5113    TOKEN is not a shell reserved word. */
5114 int
5115 find_reserved_word (tokstr)
5116      char *tokstr;
5117 {
5118   int i;
5119   for (i = 0; word_token_alist[i].word; i++)
5120     if (STREQ (tokstr, word_token_alist[i].word))
5121       return i;
5122   return -1;
5123 }
5124
5125 #if 0
5126 #if defined (READLINE)
5127 /* Called after each time readline is called.  This insures that whatever
5128    the new prompt string is gets propagated to readline's local prompt
5129    variable. */
5130 static void
5131 reset_readline_prompt ()
5132 {
5133   char *temp_prompt;
5134
5135   if (prompt_string_pointer)
5136     {
5137       temp_prompt = (*prompt_string_pointer)
5138                         ? decode_prompt_string (*prompt_string_pointer)
5139                         : (char *)NULL;
5140
5141       if (temp_prompt == 0)
5142         {
5143           temp_prompt = (char *)xmalloc (1);
5144           temp_prompt[0] = '\0';
5145         }
5146
5147       FREE (current_readline_prompt);
5148       current_readline_prompt = temp_prompt;
5149     }
5150 }
5151 #endif /* READLINE */
5152 #endif /* 0 */
5153
5154 #if defined (HISTORY)
5155 /* A list of tokens which can be followed by newlines, but not by
5156    semi-colons.  When concatenating multiple lines of history, the
5157    newline separator for such tokens is replaced with a space. */
5158 static int no_semi_successors[] = {
5159   '\n', '{', '(', ')', ';', '&', '|',
5160   CASE, DO, ELSE, IF, SEMI_SEMI, THEN, UNTIL, WHILE, AND_AND, OR_OR, IN,
5161   0
5162 };
5163
5164 /* If we are not within a delimited expression, try to be smart
5165    about which separators can be semi-colons and which must be
5166    newlines.  Returns the string that should be added into the
5167    history entry. */
5168 char *
5169 history_delimiting_chars ()
5170 {
5171   register int i;
5172
5173   if (dstack.delimiter_depth != 0)
5174     return ("\n");
5175
5176   /* First, handle some special cases. */
5177   /*(*/
5178   /* If we just read `()', assume it's a function definition, and don't
5179      add a semicolon.  If the token before the `)' was not `(', and we're
5180      not in the midst of parsing a case statement, assume it's a
5181      parenthesized command and add the semicolon. */
5182   /*)(*/
5183   if (token_before_that == ')')
5184     {
5185       if (two_tokens_ago == '(')        /*)*/   /* function def */
5186         return " ";
5187       /* This does not work for subshells inside case statement
5188          command lists.  It's a suboptimal solution. */
5189       else if (parser_state & PST_CASESTMT)     /* case statement pattern */
5190         return " ";
5191       else
5192         return "; ";                            /* (...) subshell */
5193     }
5194   else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
5195     return " ";         /* function def using `function name' without `()' */
5196
5197   else if (token_before_that == WORD && two_tokens_ago == FOR)
5198     {
5199       /* Tricky.  `for i\nin ...' should not have a semicolon, but
5200          `for i\ndo ...' should.  We do what we can. */
5201       for (i = shell_input_line_index; whitespace(shell_input_line[i]); i++)
5202         ;
5203       if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
5204         return " ";
5205       return ";";
5206     }
5207   else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
5208     return " ";
5209
5210   for (i = 0; no_semi_successors[i]; i++)
5211     {
5212       if (token_before_that == no_semi_successors[i])
5213         return (" ");
5214     }
5215
5216   return ("; ");
5217 }
5218 #endif /* HISTORY */
5219
5220 /* Issue a prompt, or prepare to issue a prompt when the next character
5221    is read. */
5222 static void
5223 prompt_again ()
5224 {
5225   char *temp_prompt;
5226
5227   if (interactive == 0 || expanding_alias())    /* XXX */
5228     return;
5229
5230   ps1_prompt = get_string_value ("PS1");
5231   ps2_prompt = get_string_value ("PS2");
5232
5233   if (!prompt_string_pointer)
5234     prompt_string_pointer = &ps1_prompt;
5235
5236   temp_prompt = *prompt_string_pointer
5237                         ? decode_prompt_string (*prompt_string_pointer)
5238                         : (char *)NULL;
5239
5240   if (temp_prompt == 0)
5241     {
5242       temp_prompt = (char *)xmalloc (1);
5243       temp_prompt[0] = '\0';
5244     }
5245
5246   current_prompt_string = *prompt_string_pointer;
5247   prompt_string_pointer = &ps2_prompt;
5248
5249 #if defined (READLINE)
5250   if (!no_line_editing)
5251     {
5252       FREE (current_readline_prompt);
5253       current_readline_prompt = temp_prompt;
5254     }
5255   else
5256 #endif  /* READLINE */
5257     {
5258       FREE (current_decoded_prompt);
5259       current_decoded_prompt = temp_prompt;
5260     }
5261 }
5262
5263 int
5264 get_current_prompt_level ()
5265 {
5266   return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
5267 }
5268
5269 void
5270 set_current_prompt_level (x)
5271      int x;
5272 {
5273   prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
5274   current_prompt_string = *prompt_string_pointer;
5275 }
5276
5277 static void
5278 print_prompt ()
5279 {
5280   fprintf (stderr, "%s", current_decoded_prompt);
5281   fflush (stderr);
5282 }
5283
5284 /* Return a string which will be printed as a prompt.  The string
5285    may contain special characters which are decoded as follows:
5286
5287         \a      bell (ascii 07)
5288         \d      the date in Day Mon Date format
5289         \e      escape (ascii 033)
5290         \h      the hostname up to the first `.'
5291         \H      the hostname
5292         \j      the number of active jobs
5293         \l      the basename of the shell's tty device name
5294         \n      CRLF
5295         \r      CR
5296         \s      the name of the shell
5297         \t      the time in 24-hour hh:mm:ss format
5298         \T      the time in 12-hour hh:mm:ss format
5299         \@      the time in 12-hour hh:mm am/pm format
5300         \A      the time in 24-hour hh:mm format
5301         \D{fmt} the result of passing FMT to strftime(3)
5302         \u      your username
5303         \v      the version of bash (e.g., 2.00)
5304         \V      the release of bash, version + patchlevel (e.g., 2.00.0)
5305         \w      the current working directory
5306         \W      the last element of $PWD
5307         \!      the history number of this command
5308         \#      the command number of this command
5309         \$      a $ or a # if you are root
5310         \nnn    character code nnn in octal
5311         \\      a backslash
5312         \[      begin a sequence of non-printing chars
5313         \]      end a sequence of non-printing chars
5314 */
5315 #define PROMPT_GROWTH 48
5316 char *
5317 decode_prompt_string (string)
5318      char *string;
5319 {
5320   WORD_LIST *list;
5321   char *result, *t;
5322   struct dstack save_dstack;
5323   int last_exit_value;
5324 #if defined (PROMPT_STRING_DECODE)
5325   int result_size, result_index;
5326   int c, n, i;
5327   char *temp, octal_string[4];
5328   struct tm *tm;
5329   time_t the_time;
5330   char timebuf[128];
5331   char *timefmt;
5332
5333   result = (char *)xmalloc (result_size = PROMPT_GROWTH);
5334   result[result_index = 0] = 0;
5335   temp = (char *)NULL;
5336
5337   while (c = *string++)
5338     {
5339       if (posixly_correct && c == '!')
5340         {
5341           if (*string == '!')
5342             {
5343               temp = savestring ("!");
5344               goto add_string;
5345             }
5346           else
5347             {
5348 #if !defined (HISTORY)
5349                 temp = savestring ("1");
5350 #else /* HISTORY */
5351                 temp = itos (history_number ());
5352 #endif /* HISTORY */
5353                 string--;       /* add_string increments string again. */
5354                 goto add_string;
5355             }
5356         }
5357       if (c == '\\')
5358         {
5359           c = *string;
5360
5361           switch (c)
5362             {
5363             case '0':
5364             case '1':
5365             case '2':
5366             case '3':
5367             case '4':
5368             case '5':
5369             case '6':
5370             case '7':
5371               strncpy (octal_string, string, 3);
5372               octal_string[3] = '\0';
5373
5374               n = read_octal (octal_string);
5375               temp = (char *)xmalloc (3);
5376
5377               if (n == CTLESC || n == CTLNUL)
5378                 {
5379                   temp[0] = CTLESC;
5380                   temp[1] = n;
5381                   temp[2] = '\0';
5382                 }
5383               else if (n == -1)
5384                 {
5385                   temp[0] = '\\';
5386                   temp[1] = '\0';
5387                 }
5388               else
5389                 {
5390                   temp[0] = n;
5391                   temp[1] = '\0';
5392                 }
5393
5394               for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
5395                 string++;
5396
5397               c = 0;            /* tested at add_string: */
5398               goto add_string;
5399
5400             case 'd':
5401             case 't':
5402             case 'T':
5403             case '@':
5404             case 'A':
5405               /* Make the current time/date into a string. */
5406               (void) time (&the_time);
5407               tm = localtime (&the_time);
5408
5409               if (c == 'd')
5410                 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
5411               else if (c == 't')
5412                 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
5413               else if (c == 'T')
5414                 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
5415               else if (c == '@')
5416                 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
5417               else if (c == 'A')
5418                 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
5419
5420               if (n == 0)
5421                 timebuf[0] = '\0';
5422               else
5423                 timebuf[sizeof(timebuf) - 1] = '\0';
5424
5425               temp = savestring (timebuf);
5426               goto add_string;
5427
5428             case 'D':           /* strftime format */
5429               if (string[1] != '{')             /* } */
5430                 goto not_escape;
5431
5432               (void) time (&the_time);
5433               tm = localtime (&the_time);
5434               string += 2;                      /* skip { */
5435               timefmt = xmalloc (strlen (string) + 3);
5436               for (t = timefmt; *string && *string != '}'; )
5437                 *t++ = *string++;
5438               *t = '\0';
5439               c = *string;      /* tested at add_string */
5440               if (timefmt[0] == '\0')
5441                 {
5442                   timefmt[0] = '%';
5443                   timefmt[1] = 'X';     /* locale-specific current time */
5444                   timefmt[2] = '\0';
5445                 }
5446               n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
5447               free (timefmt);
5448
5449               if (n == 0)
5450                 timebuf[0] = '\0';
5451               else
5452                 timebuf[sizeof(timebuf) - 1] = '\0';
5453
5454               if (promptvars || posixly_correct)
5455                 /* Make sure that expand_prompt_string is called with a
5456                    second argument of Q_DOUBLE_QUOTES if we use this
5457                    function here. */
5458                 temp = sh_backslash_quote_for_double_quotes (timebuf);
5459               else
5460                 temp = savestring (timebuf);
5461               goto add_string;
5462
5463             case 'n':
5464               temp = (char *)xmalloc (3);
5465               temp[0] = no_line_editing ? '\n' : '\r';
5466               temp[1] = no_line_editing ? '\0' : '\n';
5467               temp[2] = '\0';
5468               goto add_string;
5469
5470             case 's':
5471               temp = base_pathname (shell_name);
5472               temp = savestring (temp);
5473               goto add_string;
5474
5475             case 'v':
5476             case 'V':
5477               temp = (char *)xmalloc (16);
5478               if (c == 'v')
5479                 strcpy (temp, dist_version);
5480               else
5481                 sprintf (temp, "%s.%d", dist_version, patch_level);
5482               goto add_string;
5483
5484             case 'w':
5485             case 'W':
5486               {
5487                 /* Use the value of PWD because it is much more efficient. */
5488                 char t_string[PATH_MAX];
5489                 int tlen;
5490
5491                 temp = get_string_value ("PWD");
5492
5493                 if (temp == 0)
5494                   {
5495                     if (getcwd (t_string, sizeof(t_string)) == 0)
5496                       {
5497                         t_string[0] = '.';
5498                         tlen = 1;
5499                       }
5500                     else
5501                       tlen = strlen (t_string);
5502                   }
5503                 else
5504                   {
5505                     tlen = sizeof (t_string) - 1;
5506                     strncpy (t_string, temp, tlen);
5507                   }
5508                 t_string[tlen] = '\0';
5509
5510 #define ROOT_PATH(x)    ((x)[0] == '/' && (x)[1] == 0)
5511 #define DOUBLE_SLASH_ROOT(x)    ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
5512                 /* Abbreviate \W as ~ if $PWD == $HOME */
5513                 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
5514                   {
5515                     if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
5516                       {
5517                         t = strrchr (t_string, '/');
5518                         if (t)
5519                           strcpy (t_string, t + 1);
5520                       }
5521                   }
5522 #undef ROOT_PATH
5523 #undef DOUBLE_SLASH_ROOT
5524                 else
5525                   /* polite_directory_format is guaranteed to return a string
5526                      no longer than PATH_MAX - 1 characters. */
5527                   strcpy (t_string, polite_directory_format (t_string));
5528
5529                 /* If we're going to be expanding the prompt string later,
5530                    quote the directory name. */
5531                 if (promptvars || posixly_correct)
5532                   /* Make sure that expand_prompt_string is called with a
5533                      second argument of Q_DOUBLE_QUOTES if we use this
5534                      function here. */
5535                   temp = sh_backslash_quote_for_double_quotes (t_string);
5536                 else
5537                   temp = savestring (t_string);
5538
5539                 goto add_string;
5540               }
5541
5542             case 'u':
5543               if (current_user.user_name == 0)
5544                 get_current_user_info ();
5545               temp = savestring (current_user.user_name);
5546               goto add_string;
5547
5548             case 'h':
5549             case 'H':
5550               temp = savestring (current_host_name);
5551               if (c == 'h' && (t = (char *)strchr (temp, '.')))
5552                 *t = '\0';
5553               goto add_string;
5554
5555             case '#':
5556               temp = itos (current_command_number);
5557               goto add_string;
5558
5559             case '!':
5560 #if !defined (HISTORY)
5561               temp = savestring ("1");
5562 #else /* HISTORY */
5563               temp = itos (history_number ());
5564 #endif /* HISTORY */
5565               goto add_string;
5566
5567             case '$':
5568               t = temp = (char *)xmalloc (3);
5569               if ((promptvars || posixly_correct) && (current_user.euid != 0))
5570                 *t++ = '\\';
5571               *t++ = current_user.euid == 0 ? '#' : '$';
5572               *t = '\0';
5573               goto add_string;
5574
5575             case 'j':
5576               temp = itos (count_all_jobs ());
5577               goto add_string;
5578
5579             case 'l':
5580 #if defined (HAVE_TTYNAME)
5581               temp = (char *)ttyname (fileno (stdin));
5582               t = temp ? base_pathname (temp) : "tty";
5583               temp = savestring (t);
5584 #else
5585               temp = savestring ("tty");
5586 #endif /* !HAVE_TTYNAME */
5587               goto add_string;
5588
5589 #if defined (READLINE)
5590             case '[':
5591             case ']':
5592               if (no_line_editing)
5593                 {
5594                   string++;
5595                   break;
5596                 }
5597               temp = (char *)xmalloc (3);
5598               n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
5599               i = 0;
5600               if (n == CTLESC || n == CTLNUL)
5601                 temp[i++] = CTLESC;
5602               temp[i++] = n;
5603               temp[i] = '\0';
5604               goto add_string;
5605 #endif /* READLINE */
5606
5607             case '\\':
5608             case 'a':
5609             case 'e':
5610             case 'r':
5611               temp = (char *)xmalloc (2);
5612               if (c == 'a')
5613                 temp[0] = '\07';
5614               else if (c == 'e')
5615                 temp[0] = '\033';
5616               else if (c == 'r')
5617                 temp[0] = '\r';
5618               else                      /* (c == '\\') */
5619                 temp[0] = c;
5620               temp[1] = '\0';
5621               goto add_string;
5622
5623             default:
5624 not_escape:
5625               temp = (char *)xmalloc (3);
5626               temp[0] = '\\';
5627               temp[1] = c;
5628               temp[2] = '\0';
5629
5630             add_string:
5631               if (c)
5632                 string++;
5633               result =
5634                 sub_append_string (temp, result, &result_index, &result_size);
5635               temp = (char *)NULL; /* Freed in sub_append_string (). */
5636               result[result_index] = '\0';
5637               break;
5638             }
5639         }
5640       else
5641         {
5642           RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
5643           result[result_index++] = c;
5644           result[result_index] = '\0';
5645         }
5646     }
5647 #else /* !PROMPT_STRING_DECODE */
5648   result = savestring (string);
5649 #endif /* !PROMPT_STRING_DECODE */
5650
5651   /* Save the delimiter stack and point `dstack' to temp space so any
5652      command substitutions in the prompt string won't result in screwing
5653      up the parser's quoting state. */
5654   save_dstack = dstack;
5655   dstack = temp_dstack;
5656   dstack.delimiter_depth = 0;
5657
5658   /* Perform variable and parameter expansion and command substitution on
5659      the prompt string. */
5660   if (promptvars || posixly_correct)
5661     {
5662       last_exit_value = last_command_exit_value;
5663       list = expand_prompt_string (result, Q_DOUBLE_QUOTES);
5664       free (result);
5665       result = string_list (list);
5666       dispose_words (list);
5667       last_command_exit_value = last_exit_value;
5668     }
5669   else
5670     {
5671       t = dequote_string (result);
5672       free (result);
5673       result = t;
5674     }
5675
5676   dstack = save_dstack;
5677
5678   return (result);
5679 }
5680
5681 /************************************************
5682  *                                              *
5683  *              ERROR HANDLING                  *
5684  *                                              *
5685  ************************************************/
5686
5687 /* Report a syntax error, and restart the parser.  Call here for fatal
5688    errors. */
5689 int
5690 yyerror (msg)
5691      const char *msg;
5692 {
5693   report_syntax_error ((char *)NULL);
5694   reset_parser ();
5695   return (0);
5696 }
5697
5698 static char *
5699 error_token_from_token (tok)
5700      int tok;
5701 {
5702   char *t;
5703
5704   if (t = find_token_in_alist (tok, word_token_alist, 0))
5705     return t;
5706
5707   if (t = find_token_in_alist (tok, other_token_alist, 0))
5708     return t;
5709
5710   t = (char *)NULL;
5711   /* This stuff is dicy and needs closer inspection */
5712   switch (current_token)
5713     {
5714     case WORD:
5715     case ASSIGNMENT_WORD:
5716       if (yylval.word)
5717         t = savestring (yylval.word->word);
5718       break;
5719     case NUMBER:
5720       t = itos (yylval.number);
5721       break;
5722     case ARITH_CMD:
5723       if (yylval.word_list)
5724         t = string_list (yylval.word_list);
5725       break;
5726     case ARITH_FOR_EXPRS:
5727       if (yylval.word_list)
5728         t = string_list_internal (yylval.word_list, " ; ");
5729       break;
5730     case COND_CMD:
5731       t = (char *)NULL;         /* punt */
5732       break;
5733     }
5734
5735   return t;
5736 }
5737
5738 static char *
5739 error_token_from_text ()
5740 {
5741   char *msg, *t;
5742   int token_end, i;
5743
5744   t = shell_input_line;
5745   i = shell_input_line_index;
5746   token_end = 0;
5747   msg = (char *)NULL;
5748
5749   if (i && t[i] == '\0')
5750     i--;
5751
5752   while (i && (whitespace (t[i]) || t[i] == '\n'))
5753     i--;
5754
5755   if (i)
5756     token_end = i + 1;
5757
5758   while (i && (member (t[i], " \n\t;|&") == 0))
5759     i--;
5760
5761   while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
5762     i++;
5763
5764   /* Return our idea of the offending token. */
5765   if (token_end || (i == 0 && token_end == 0))
5766     {
5767       if (token_end)
5768         msg = substring (t, i, token_end);
5769       else      /* one-character token */
5770         {
5771           msg = (char *)xmalloc (2);
5772           msg[0] = t[i];
5773           msg[1] = '\0';
5774         }
5775     }
5776
5777   return (msg);
5778 }
5779
5780 static void
5781 print_offending_line ()
5782 {
5783   char *msg;
5784   int token_end;
5785
5786   msg = savestring (shell_input_line);
5787   token_end = strlen (msg);
5788   while (token_end && msg[token_end - 1] == '\n')
5789     msg[--token_end] = '\0';
5790
5791   parser_error (line_number, "`%s'", msg);
5792   free (msg);
5793 }
5794
5795 /* Report a syntax error with line numbers, etc.
5796    Call here for recoverable errors.  If you have a message to print,
5797    then place it in MESSAGE, otherwise pass NULL and this will figure
5798    out an appropriate message for you. */
5799 static void
5800 report_syntax_error (message)
5801      char *message;
5802 {
5803   char *msg;
5804
5805   if (message)
5806     {
5807       parser_error (line_number, "%s", message);
5808       if (interactive && EOF_Reached)
5809         EOF_Reached = 0;
5810       last_command_exit_value = EX_USAGE;
5811       return;
5812     }
5813
5814   /* If the line of input we're reading is not null, try to find the
5815      objectionable token.  First, try to figure out what token the
5816      parser's complaining about by looking at current_token. */
5817   if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
5818     {
5819       parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
5820       free (msg);
5821
5822       if (interactive == 0)
5823         print_offending_line ();
5824
5825       last_command_exit_value = EX_USAGE;
5826       return;
5827     }
5828
5829   /* If looking at the current token doesn't prove fruitful, try to find the
5830      offending token by analyzing the text of the input line near the current
5831      input line index and report what we find. */
5832   if (shell_input_line && *shell_input_line)
5833     {
5834       msg = error_token_from_text ();
5835       if (msg)
5836         {
5837           parser_error (line_number, _("syntax error near `%s'"), msg);
5838           free (msg);
5839         }
5840
5841       /* If not interactive, print the line containing the error. */
5842       if (interactive == 0)
5843         print_offending_line ();
5844     }
5845   else
5846     {
5847       msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
5848       parser_error (line_number, "%s", msg);
5849       /* When the shell is interactive, this file uses EOF_Reached
5850          only for error reporting.  Other mechanisms are used to
5851          decide whether or not to exit. */
5852       if (interactive && EOF_Reached)
5853         EOF_Reached = 0;
5854     }
5855
5856   last_command_exit_value = EX_USAGE;
5857 }
5858
5859 /* ??? Needed function. ??? We have to be able to discard the constructs
5860    created during parsing.  In the case of error, we want to return
5861    allocated objects to the memory pool.  In the case of no error, we want
5862    to throw away the information about where the allocated objects live.
5863    (dispose_command () will actually free the command.) */
5864 static void
5865 discard_parser_constructs (error_p)
5866      int error_p;
5867 {
5868 }
5869
5870 /************************************************
5871  *                                              *
5872  *              EOF HANDLING                    *
5873  *                                              *
5874  ************************************************/
5875
5876 /* Do that silly `type "bye" to exit' stuff.  You know, "ignoreeof". */
5877
5878 /* A flag denoting whether or not ignoreeof is set. */
5879 int ignoreeof = 0;
5880
5881 /* The number of times that we have encountered an EOF character without
5882    another character intervening.  When this gets above the limit, the
5883    shell terminates. */
5884 int eof_encountered = 0;
5885
5886 /* The limit for eof_encountered. */
5887 int eof_encountered_limit = 10;
5888
5889 /* If we have EOF as the only input unit, this user wants to leave
5890    the shell.  If the shell is not interactive, then just leave.
5891    Otherwise, if ignoreeof is set, and we haven't done this the
5892    required number of times in a row, print a message. */
5893 static void
5894 handle_eof_input_unit ()
5895 {
5896   if (interactive)
5897     {
5898       /* shell.c may use this to decide whether or not to write out the
5899          history, among other things.  We use it only for error reporting
5900          in this file. */
5901       if (EOF_Reached)
5902         EOF_Reached = 0;
5903
5904       /* If the user wants to "ignore" eof, then let her do so, kind of. */
5905       if (ignoreeof)
5906         {
5907           if (eof_encountered < eof_encountered_limit)
5908             {
5909               fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
5910                        login_shell ? "logout" : "exit");
5911               eof_encountered++;
5912               /* Reset the parsing state. */
5913               last_read_token = current_token = '\n';
5914               /* Reset the prompt string to be $PS1. */
5915               prompt_string_pointer = (char **)NULL;
5916               prompt_again ();
5917               return;
5918             }
5919         }
5920
5921       /* In this case EOF should exit the shell.  Do it now. */
5922       reset_parser ();
5923       exit_builtin ((WORD_LIST *)NULL);
5924     }
5925   else
5926     {
5927       /* We don't write history files, etc., for non-interactive shells. */
5928       EOF_Reached = 1;
5929     }
5930 }
5931
5932 /************************************************
5933  *                                              *
5934  *      STRING PARSING FUNCTIONS                *
5935  *                                              *
5936  ************************************************/
5937
5938 /* It's very important that these two functions treat the characters
5939    between ( and ) identically. */
5940
5941 static WORD_LIST parse_string_error;
5942
5943 /* Take a string and run it through the shell parser, returning the
5944    resultant word list.  Used by compound array assignment. */
5945 WORD_LIST *
5946 parse_string_to_word_list (s, flags, whom)
5947      char *s;
5948      int flags;
5949      const char *whom;
5950 {
5951   WORD_LIST *wl;
5952   int tok, orig_current_token, orig_line_number, orig_input_terminator;
5953   int orig_line_count;
5954   int old_echo_input, old_expand_aliases;
5955 #if defined (HISTORY)
5956   int old_remember_on_history, old_history_expansion_inhibited;
5957 #endif
5958
5959 #if defined (HISTORY)
5960   old_remember_on_history = remember_on_history;
5961 #  if defined (BANG_HISTORY)
5962   old_history_expansion_inhibited = history_expansion_inhibited;
5963 #  endif
5964   bash_history_disable ();
5965 #endif
5966
5967   orig_line_number = line_number;
5968   orig_line_count = current_command_line_count;
5969   orig_input_terminator = shell_input_line_terminator;
5970   old_echo_input = echo_input_at_read;
5971   old_expand_aliases = expand_aliases;
5972
5973   push_stream (1);
5974   last_read_token = WORD;               /* WORD to allow reserved words here */
5975   current_command_line_count = 0;
5976   echo_input_at_read = expand_aliases = 0;
5977
5978   with_input_from_string (s, whom);
5979   wl = (WORD_LIST *)NULL;
5980
5981   if (flags & 1)
5982     parser_state |= PST_COMPASSIGN;
5983
5984   while ((tok = read_token (READ)) != yacc_EOF)
5985     {
5986       if (tok == '\n' && *bash_input.location.string == '\0')
5987         break;
5988       if (tok == '\n')          /* Allow newlines in compound assignments */
5989         continue;
5990       if (tok != WORD && tok != ASSIGNMENT_WORD)
5991         {
5992           line_number = orig_line_number + line_number - 1;
5993           orig_current_token = current_token;
5994           current_token = tok;
5995           yyerror (NULL);       /* does the right thing */
5996           current_token = orig_current_token;
5997           if (wl)
5998             dispose_words (wl);
5999           wl = &parse_string_error;
6000           break;
6001         }
6002       wl = make_word_list (yylval.word, wl);
6003     }
6004
6005   last_read_token = '\n';
6006   pop_stream ();
6007
6008 #if defined (HISTORY)
6009   remember_on_history = old_remember_on_history;
6010 #  if defined (BANG_HISTORY)
6011   history_expansion_inhibited = old_history_expansion_inhibited;
6012 #  endif /* BANG_HISTORY */
6013 #endif /* HISTORY */
6014
6015   echo_input_at_read = old_echo_input;
6016   expand_aliases = old_expand_aliases;
6017
6018   current_command_line_count = orig_line_count;
6019   shell_input_line_terminator = orig_input_terminator;
6020
6021   if (flags & 1)
6022     parser_state &= ~PST_COMPASSIGN;
6023
6024   if (wl == &parse_string_error)
6025     {
6026       last_command_exit_value = EXECUTION_FAILURE;
6027       if (interactive_shell == 0 && posixly_correct)
6028         jump_to_top_level (FORCE_EOF);
6029       else
6030         jump_to_top_level (DISCARD);
6031     }
6032
6033   return (REVERSE_LIST (wl, WORD_LIST *));
6034 }
6035
6036 static char *
6037 parse_compound_assignment (retlenp)
6038      int *retlenp;
6039 {
6040   WORD_LIST *wl, *rl;
6041   int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
6042   char *saved_token, *ret;
6043
6044   saved_token = token;
6045   orig_token_size = token_buffer_size;
6046   orig_line_number = line_number;
6047   orig_last_token = last_read_token;
6048
6049   last_read_token = WORD;       /* WORD to allow reserved words here */
6050
6051   token = (char *)NULL;
6052   token_buffer_size = 0;
6053
6054   assignok = parser_state&PST_ASSIGNOK;         /* XXX */
6055
6056   wl = (WORD_LIST *)NULL;       /* ( */
6057   parser_state |= PST_COMPASSIGN;
6058
6059   while ((tok = read_token (READ)) != ')')
6060     {
6061       if (tok == '\n')                  /* Allow newlines in compound assignments */
6062         {
6063           if (SHOULD_PROMPT ())
6064             prompt_again ();
6065           continue;
6066         }
6067       if (tok != WORD && tok != ASSIGNMENT_WORD)
6068         {
6069           current_token = tok;  /* for error reporting */
6070           if (tok == yacc_EOF)  /* ( */
6071             parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
6072           else
6073             yyerror(NULL);      /* does the right thing */
6074           if (wl)
6075             dispose_words (wl);
6076           wl = &parse_string_error;
6077           break;
6078         }
6079       wl = make_word_list (yylval.word, wl);
6080     }
6081
6082   FREE (token);
6083   token = saved_token;
6084   token_buffer_size = orig_token_size;
6085
6086   parser_state &= ~PST_COMPASSIGN;
6087
6088   if (wl == &parse_string_error)
6089     {
6090       last_command_exit_value = EXECUTION_FAILURE;
6091       last_read_token = '\n';   /* XXX */
6092       if (interactive_shell == 0 && posixly_correct)
6093         jump_to_top_level (FORCE_EOF);
6094       else
6095         jump_to_top_level (DISCARD);
6096     }
6097
6098   last_read_token = orig_last_token;            /* XXX - was WORD? */
6099
6100   if (wl)
6101     {
6102       rl = REVERSE_LIST (wl, WORD_LIST *);
6103       ret = string_list (rl);
6104       dispose_words (rl);
6105     }
6106   else
6107     ret = (char *)NULL;
6108
6109   if (retlenp)
6110     *retlenp = (ret && *ret) ? strlen (ret) : 0;
6111
6112   if (assignok)
6113     parser_state |= PST_ASSIGNOK;
6114
6115   return ret;
6116 }
6117
6118 /************************************************
6119  *                                              *
6120  *   SAVING AND RESTORING PARTIAL PARSE STATE   *
6121  *                                              *
6122  ************************************************/
6123
6124 sh_parser_state_t *
6125 save_parser_state (ps)
6126      sh_parser_state_t *ps;
6127 {
6128 #if defined (ARRAY_VARS)
6129   SHELL_VAR *v;
6130 #endif
6131
6132   if (ps == 0)
6133     ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
6134   if (ps == 0)
6135     return ((sh_parser_state_t *)NULL);
6136
6137   ps->parser_state = parser_state;
6138   ps->token_state = save_token_state ();
6139
6140   ps->input_line_terminator = shell_input_line_terminator;
6141   ps->eof_encountered = eof_encountered;
6142
6143   ps->current_command_line_count = current_command_line_count;
6144
6145 #if defined (HISTORY)
6146   ps->remember_on_history = remember_on_history;
6147 #  if defined (BANG_HISTORY)
6148   ps->history_expansion_inhibited = history_expansion_inhibited;
6149 #  endif
6150 #endif
6151
6152   ps->last_command_exit_value = last_command_exit_value;
6153 #if defined (ARRAY_VARS)
6154   v = find_variable ("PIPESTATUS");
6155   if (v && array_p (v) && array_cell (v))
6156     ps->pipestatus = array_copy (array_cell (v));
6157   else
6158     ps->pipestatus = (ARRAY *)NULL;
6159 #endif
6160
6161   ps->last_shell_builtin = last_shell_builtin;
6162   ps->this_shell_builtin = this_shell_builtin;
6163
6164   ps->expand_aliases = expand_aliases;
6165   ps->echo_input_at_read = echo_input_at_read;
6166
6167   return (ps);
6168 }
6169
6170 void
6171 restore_parser_state (ps)
6172      sh_parser_state_t *ps;
6173 {
6174 #if defined (ARRAY_VARS)
6175   SHELL_VAR *v;
6176 #endif
6177
6178   if (ps == 0)
6179     return;
6180
6181   parser_state = ps->parser_state;
6182   if (ps->token_state)
6183     {
6184       restore_token_state (ps->token_state);
6185       free (ps->token_state);
6186     }
6187
6188   shell_input_line_terminator = ps->input_line_terminator;
6189   eof_encountered = ps->eof_encountered;
6190
6191   current_command_line_count = ps->current_command_line_count;
6192
6193 #if defined (HISTORY)
6194   remember_on_history = ps->remember_on_history;
6195 #  if defined (BANG_HISTORY)
6196   history_expansion_inhibited = ps->history_expansion_inhibited;
6197 #  endif
6198 #endif
6199
6200   last_command_exit_value = ps->last_command_exit_value;
6201 #if defined (ARRAY_VARS)
6202   v = find_variable ("PIPESTATUS");
6203   if (v && array_p (v) && array_cell (v))
6204     {
6205       array_dispose (array_cell (v));
6206       var_setarray (v, ps->pipestatus);
6207     }
6208 #endif
6209
6210   last_shell_builtin = ps->last_shell_builtin;
6211   this_shell_builtin = ps->this_shell_builtin;
6212
6213   expand_aliases = ps->expand_aliases;
6214   echo_input_at_read = ps->echo_input_at_read;
6215 }
6216
6217 /************************************************
6218  *                                              *
6219  *      MULTIBYTE CHARACTER HANDLING            *
6220  *                                              *
6221  ************************************************/
6222
6223 #if defined (HANDLE_MULTIBYTE)
6224 static void
6225 set_line_mbstate ()
6226 {
6227   int i, previ, len, c;
6228   mbstate_t mbs, prevs;
6229   size_t mbclen;
6230
6231   if (shell_input_line == NULL)
6232     return;
6233   len = strlen (shell_input_line);      /* XXX - shell_input_line_len ? */
6234   FREE (shell_input_line_property);
6235   shell_input_line_property = (char *)xmalloc (len + 1);
6236
6237   memset (&prevs, '\0', sizeof (mbstate_t));
6238   for (i = previ = 0; i < len; i++)
6239     {
6240       mbs = prevs;
6241
6242       c = shell_input_line[i];
6243       if (c == EOF)
6244         {
6245           int j;
6246           for (j = i; j < len; j++)
6247             shell_input_line_property[j] = 1;
6248           break;
6249         }
6250
6251       mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
6252       if (mbclen == 1 || mbclen == (size_t)-1)
6253         {
6254           mbclen = 1;
6255           previ = i + 1;
6256         }
6257       else if (mbclen == (size_t)-2)
6258         mbclen = 0;
6259       else if (mbclen > 1)
6260         {
6261           mbclen = 0;
6262           previ = i + 1;
6263           prevs = mbs;
6264         }
6265       else
6266         {
6267           /* XXX - what to do if mbrlen returns 0? (null wide character) */
6268           int j;
6269           for (j = i; j < len; j++)
6270             shell_input_line_property[j] = 1;
6271           break;
6272         }
6273
6274       shell_input_line_property[i] = mbclen;
6275     }
6276 }
6277 #endif /* HANDLE_MULTIBYTE */