y.tab.c

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