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