y.tab.c

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