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