y.tab.c

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