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