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