1 /* parse.y - Yacc grammar for bash. */
3 /* Copyright (C) 1989-2010 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
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.
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.
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/>.
24 #include "bashtypes.h"
29 #if defined (HAVE_UNISTD_H)
33 #if defined (HAVE_LOCALE_H)
38 #include "chartypes.h"
45 #define NEED_STRFTIME_DECL /* used in externs.h */
51 #include "mailcheck.h"
54 #include "builtins/common.h"
55 #include "builtins/builtext.h"
59 #if defined (READLINE)
60 # include "bashline.h"
61 # include <readline/readline.h>
65 # include "bashhist.h"
66 # include <readline/history.h>
69 #if defined (JOB_CONTROL)
71 #endif /* JOB_CONTROL */
76 typedef void *alias_t;
79 #if defined (PROMPT_STRING_DECODE)
81 # include <sys/param.h>
84 # if defined (TM_IN_SYS_TIME)
85 # include <sys/types.h>
86 # include <sys/time.h>
87 # endif /* TM_IN_SYS_TIME */
89 #endif /* PROMPT_STRING_DECODE */
91 #define RE_READ_TOKEN -99
92 #define NO_EXPANSION -100
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] \
105 # define MBTEST(x) ((x) && last_shell_getc_is_singlebyte)
107 # define last_shell_getc_is_singlebyte 1
108 # define MBTEST(x) ((x))
111 #if defined (EXTENDED_GLOB)
112 extern int extended_glob;
115 extern int eof_encountered;
116 extern int no_line_editing, running_under_emacs;
117 extern int current_command_number;
118 extern int sourcelevel, parse_and_execute_level;
119 extern int posixly_correct;
120 extern int last_command_exit_value;
121 extern pid_t last_command_subst_pid;
122 extern char *shell_name, *current_host_name;
123 extern char *dist_version;
124 extern int patch_level;
125 extern int dump_translatable_strings, dump_po_strings;
126 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
127 #if defined (BUFFERED_INPUT)
128 extern int bash_input_fd_changed;
132 /* **************************************************************** */
134 /* "Forward" declarations */
136 /* **************************************************************** */
139 static void debug_parser __P((int));
142 static int yy_getc __P((void));
143 static int yy_ungetc __P((int));
145 #if defined (READLINE)
146 static int yy_readline_get __P((void));
147 static int yy_readline_unget __P((int));
150 static int yy_string_get __P((void));
151 static int yy_string_unget __P((int));
152 static void rewind_input_string __P((void));
153 static int yy_stream_get __P((void));
154 static int yy_stream_unget __P((int));
156 static int shell_getc __P((int));
157 static void shell_ungetc __P((int));
158 static void discard_until __P((int));
160 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
161 static void push_string __P((char *, int, alias_t *));
162 static void pop_string __P((void));
163 static void free_string_list __P((void));
166 static char *read_a_line __P((int));
168 static int reserved_word_acceptable __P((int));
169 static int yylex __P((void));
170 static int alias_expand_token __P((char *));
171 static int time_command_acceptable __P((void));
172 static int special_case_tokens __P((char *));
173 static int read_token __P((int));
174 static char *parse_matched_pair __P((int, int, int, int *, int));
175 static char *parse_comsub __P((int, int, int, int *, int));
176 #if defined (ARRAY_VARS)
177 static char *parse_compound_assignment __P((int *));
179 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
180 static int parse_dparen __P((int));
181 static int parse_arith_cmd __P((char **, int));
183 #if defined (COND_COMMAND)
184 static void cond_error __P((void));
185 static COND_COM *cond_expr __P((void));
186 static COND_COM *cond_or __P((void));
187 static COND_COM *cond_and __P((void));
188 static COND_COM *cond_term __P((void));
189 static int cond_skip_newlines __P((void));
190 static COMMAND *parse_cond_command __P((void));
192 #if defined (ARRAY_VARS)
193 static int token_is_assignment __P((char *, int));
194 static int token_is_ident __P((char *, int));
196 static int read_token_word __P((int));
197 static void discard_parser_constructs __P((int));
199 static char *error_token_from_token __P((int));
200 static char *error_token_from_text __P((void));
201 static void print_offending_line __P((void));
202 static void report_syntax_error __P((char *));
204 static void handle_eof_input_unit __P((void));
205 static void prompt_again __P((void));
207 static void reset_readline_prompt __P((void));
209 static void print_prompt __P((void));
211 #if defined (HANDLE_MULTIBYTE)
212 static void set_line_mbstate __P((void));
213 static char *shell_input_line_property = NULL;
215 # define set_line_mbstate()
218 extern int yyerror __P((const char *));
224 /* Default prompt strings */
225 char *primary_prompt = PPROMPT;
226 char *secondary_prompt = SPROMPT;
228 /* PROMPT_STRING_POINTER points to one of these, never to an actual string. */
229 char *ps1_prompt, *ps2_prompt;
231 /* Handle on the current prompt string. Indirectly points through
232 ps1_ or ps2_prompt. */
233 char **prompt_string_pointer = (char **)NULL;
234 char *current_prompt_string;
236 /* Non-zero means we expand aliases in commands. */
237 int expand_aliases = 0;
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. */
245 /* If non-zero, $'...' and $"..." are expanded when they appear within
246 a ${...} expansion, even when the expansion appears within double
248 int extended_quote = 1;
250 /* The number of lines read from input while creating the current command. */
251 int current_command_line_count;
253 /* The token that currently denotes the end of parse. */
256 /* The token currently being read. */
259 /* The current parser state. */
262 /* Variables to manage the task of reading here documents, because we need to
263 defer the reading until after a complete command has been collected. */
264 static REDIRECT *redir_stack[10];
267 /* Where shell input comes from. History expansion is performed on each
268 line when the shell is interactive. */
269 static char *shell_input_line = (char *)NULL;
270 static int shell_input_line_index;
271 static int shell_input_line_size; /* Amount allocated for shell_input_line. */
272 static int shell_input_line_len; /* strlen (shell_input_line) */
274 /* Either zero or EOF. */
275 static int shell_input_line_terminator;
277 /* The line number in a script on which a function definition starts. */
278 static int function_dstart;
280 /* The line number in a script on which a function body starts. */
281 static int function_bstart;
283 /* The line number in a script at which an arithmetic for command starts. */
284 static int arith_for_lineno;
286 /* The decoded prompt string. Used if READLINE is not defined or if
287 editing is turned off. Analogous to current_readline_prompt. */
288 static char *current_decoded_prompt;
290 /* The last read token, or NULL. read_token () uses this for context
292 static int last_read_token;
294 /* The token read prior to last_read_token. */
295 static int token_before_that;
297 /* The token read prior to token_before_that. */
298 static int two_tokens_ago;
300 static int global_extglob;
302 /* The line number in a script where the word in a `case WORD', `select WORD'
303 or `for WORD' begins. This is a nested command maximum, since the array
304 index is decremented after a case, select, or for command is parsed. */
305 #define MAX_CASE_NEST 128
306 static int word_lineno[MAX_CASE_NEST];
307 static int word_top = -1;
309 /* If non-zero, it is the token that we want read_token to return
310 regardless of what text is (or isn't) present to be read. This
311 is reset by read_token. If token_to_read == WORD or
312 ASSIGNMENT_WORD, yylval.word should be set to word_desc_to_read. */
313 static int token_to_read;
314 static WORD_DESC *word_desc_to_read;
316 static REDIRECTEE source;
317 static REDIRECTEE redir;
321 WORD_DESC *word; /* the word that we read. */
322 int number; /* the number that we read. */
323 WORD_LIST *word_list;
327 PATTERN_LIST *pattern;
330 /* Reserved words. Members of the first group are only recognized
331 in the case that they are preceded by a list_terminator. Members
332 of the second group are for [[...]] commands. Members of the
333 third group are recognized only under special circumstances. */
334 %token IF THEN ELSE ELIF FI CASE ESAC FOR SELECT WHILE UNTIL DO DONE FUNCTION COPROC
335 %token COND_START COND_END COND_ERROR
336 %token IN BANG TIME TIMEOPT
338 /* More general tokens. yylex () knows how to make these. */
339 %token <word> WORD ASSIGNMENT_WORD REDIR_WORD
340 %token <number> NUMBER
341 %token <word_list> ARITH_CMD ARITH_FOR_EXPRS
342 %token <command> COND_CMD
343 %token AND_AND OR_OR GREATER_GREATER LESS_LESS LESS_AND LESS_LESS_LESS
344 %token GREATER_AND SEMI_SEMI SEMI_AND SEMI_SEMI_AND
345 %token LESS_LESS_MINUS AND_GREATER AND_GREATER_GREATER LESS_GREATER
346 %token GREATER_BAR BAR_AND
348 /* The types that the various syntactical units return. */
350 %type <command> inputunit command pipeline pipeline_command
351 %type <command> list list0 list1 compound_list simple_list simple_list1
352 %type <command> simple_command shell_command
353 %type <command> for_command select_command case_command group_command
354 %type <command> arith_command
355 %type <command> cond_command
356 %type <command> arith_for_command
357 %type <command> coproc
358 %type <command> function_def function_body if_command elif_clause subshell
359 %type <redirect> redirection redirection_list
360 %type <element> simple_command_element
361 %type <word_list> word_list pattern
362 %type <pattern> pattern_list case_clause_sequence case_clause
363 %type <number> timespec
364 %type <number> list_terminator
368 %left '&' ';' '\n' yacc_EOF
373 inputunit: simple_list simple_list_terminator
375 /* Case of regular command. Discard the error
376 safety net,and return the command just parsed. */
379 /* discard_parser_constructs (0); */
380 if (parser_state & PST_CMDSUBST)
381 parser_state |= PST_EOFTOKEN;
386 /* Case of regular command, but not a very
387 interesting one. Return a NULL command. */
388 global_command = (COMMAND *)NULL;
389 if (parser_state & PST_CMDSUBST)
390 parser_state |= PST_EOFTOKEN;
395 /* Error during parsing. Return NULL command. */
396 global_command = (COMMAND *)NULL;
398 /* discard_parser_constructs (1); */
399 if (interactive && parse_and_execute_level == 0)
410 /* Case of EOF seen by itself. Do ignoreeof or
412 global_command = (COMMAND *)NULL;
413 handle_eof_input_unit ();
419 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
421 { $$ = make_word_list ($2, $1); }
424 redirection: '>' WORD
428 $$ = make_redirection (source, r_output_direction, redir, 0);
434 $$ = make_redirection (source, r_input_direction, redir, 0);
440 $$ = make_redirection (source, r_output_direction, redir, 0);
446 $$ = make_redirection (source, r_input_direction, redir, 0);
448 | REDIR_WORD '>' WORD
450 source.filename = $1;
452 $$ = make_redirection (source, r_output_direction, redir, REDIR_VARASSIGN);
454 | REDIR_WORD '<' WORD
456 source.filename = $1;
458 $$ = make_redirection (source, r_input_direction, redir, REDIR_VARASSIGN);
460 | GREATER_GREATER WORD
464 $$ = make_redirection (source, r_appending_to, redir, 0);
466 | NUMBER GREATER_GREATER WORD
470 $$ = make_redirection (source, r_appending_to, redir, 0);
472 | REDIR_WORD GREATER_GREATER WORD
474 source.filename = $1;
476 $$ = make_redirection (source, r_appending_to, redir, REDIR_VARASSIGN);
482 $$ = make_redirection (source, r_output_force, redir, 0);
484 | NUMBER GREATER_BAR WORD
488 $$ = make_redirection (source, r_output_force, redir, 0);
490 | REDIR_WORD GREATER_BAR WORD
492 source.filename = $1;
494 $$ = make_redirection (source, r_output_force, redir, REDIR_VARASSIGN);
500 $$ = make_redirection (source, r_input_output, redir, 0);
502 | NUMBER LESS_GREATER WORD
506 $$ = make_redirection (source, r_input_output, redir, 0);
508 | REDIR_WORD LESS_GREATER WORD
510 source.filename = $1;
512 $$ = make_redirection (source, r_input_output, redir, REDIR_VARASSIGN);
518 $$ = make_redirection (source, r_reading_until, redir, 0);
519 redir_stack[need_here_doc++] = $$;
521 | NUMBER LESS_LESS WORD
525 $$ = make_redirection (source, r_reading_until, redir, 0);
526 redir_stack[need_here_doc++] = $$;
528 | REDIR_WORD LESS_LESS WORD
530 source.filename = $1;
532 $$ = make_redirection (source, r_reading_until, redir, REDIR_VARASSIGN);
533 redir_stack[need_here_doc++] = $$;
535 | LESS_LESS_MINUS WORD
539 $$ = make_redirection (source, r_deblank_reading_until, redir, 0);
540 redir_stack[need_here_doc++] = $$;
542 | NUMBER LESS_LESS_MINUS WORD
546 $$ = make_redirection (source, r_deblank_reading_until, redir, 0);
547 redir_stack[need_here_doc++] = $$;
549 | REDIR_WORD LESS_LESS_MINUS WORD
551 source.filename = $1;
553 $$ = make_redirection (source, r_deblank_reading_until, redir, REDIR_VARASSIGN);
554 redir_stack[need_here_doc++] = $$;
556 | LESS_LESS_LESS WORD
560 $$ = make_redirection (source, r_reading_string, redir, 0);
562 | NUMBER LESS_LESS_LESS WORD
566 $$ = make_redirection (source, r_reading_string, redir, 0);
568 | REDIR_WORD LESS_LESS_LESS WORD
570 source.filename = $1;
572 $$ = make_redirection (source, r_reading_string, redir, REDIR_VARASSIGN);
578 $$ = make_redirection (source, r_duplicating_input, redir, 0);
580 | NUMBER LESS_AND NUMBER
584 $$ = make_redirection (source, r_duplicating_input, redir, 0);
586 | REDIR_WORD LESS_AND NUMBER
588 source.filename = $1;
590 $$ = make_redirection (source, r_duplicating_input, redir, REDIR_VARASSIGN);
596 $$ = make_redirection (source, r_duplicating_output, redir, 0);
598 | NUMBER GREATER_AND NUMBER
602 $$ = make_redirection (source, r_duplicating_output, redir, 0);
604 | REDIR_WORD GREATER_AND NUMBER
606 source.filename = $1;
608 $$ = make_redirection (source, r_duplicating_output, redir, REDIR_VARASSIGN);
614 $$ = make_redirection (source, r_duplicating_input_word, redir, 0);
616 | NUMBER LESS_AND WORD
620 $$ = make_redirection (source, r_duplicating_input_word, redir, 0);
622 | REDIR_WORD LESS_AND WORD
624 source.filename = $1;
626 $$ = make_redirection (source, r_duplicating_input_word, redir, REDIR_VARASSIGN);
632 $$ = make_redirection (source, r_duplicating_output_word, redir, 0);
634 | NUMBER GREATER_AND WORD
638 $$ = make_redirection (source, r_duplicating_output_word, redir, 0);
640 | REDIR_WORD GREATER_AND WORD
642 source.filename = $1;
644 $$ = make_redirection (source, r_duplicating_output_word, redir, REDIR_VARASSIGN);
650 $$ = make_redirection (source, r_close_this, redir, 0);
652 | NUMBER GREATER_AND '-'
656 $$ = make_redirection (source, r_close_this, redir, 0);
658 | REDIR_WORD GREATER_AND '-'
660 source.filename = $1;
662 $$ = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
668 $$ = make_redirection (source, r_close_this, redir, 0);
670 | NUMBER LESS_AND '-'
674 $$ = make_redirection (source, r_close_this, redir, 0);
676 | REDIR_WORD LESS_AND '-'
678 source.filename = $1;
680 $$ = make_redirection (source, r_close_this, redir, REDIR_VARASSIGN);
686 $$ = make_redirection (source, r_err_and_out, redir, 0);
688 | AND_GREATER_GREATER WORD
692 $$ = make_redirection (source, r_append_err_and_out, redir, 0);
696 simple_command_element: WORD
697 { $$.word = $1; $$.redirect = 0; }
699 { $$.word = $1; $$.redirect = 0; }
701 { $$.redirect = $1; $$.word = 0; }
704 redirection_list: redirection
708 | redirection_list redirection
710 register REDIRECT *t;
712 for (t = $1; t->next; t = t->next)
719 simple_command: simple_command_element
720 { $$ = make_simple_command ($1, (COMMAND *)NULL); }
721 | simple_command simple_command_element
722 { $$ = make_simple_command ($2, $1); }
725 command: simple_command
726 { $$ = clean_simple_command ($1); }
729 | shell_command redirection_list
736 register REDIRECT *t;
737 for (t = tc->redirects; t->next; t = t->next)
751 shell_command: for_command
755 | WHILE compound_list DO compound_list DONE
756 { $$ = make_while_command ($2, $4); }
757 | UNTIL compound_list DO compound_list DONE
758 { $$ = make_until_command ($2, $4); }
775 for_command: FOR WORD newline_list DO compound_list DONE
777 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
778 if (word_top > 0) word_top--;
780 | FOR WORD newline_list '{' compound_list '}'
782 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
783 if (word_top > 0) word_top--;
785 | FOR WORD ';' newline_list DO compound_list DONE
787 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
788 if (word_top > 0) word_top--;
790 | FOR WORD ';' newline_list '{' compound_list '}'
792 $$ = make_for_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
793 if (word_top > 0) word_top--;
795 | FOR WORD newline_list IN word_list list_terminator newline_list DO compound_list DONE
797 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
798 if (word_top > 0) word_top--;
800 | FOR WORD newline_list IN word_list list_terminator newline_list '{' compound_list '}'
802 $$ = make_for_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
803 if (word_top > 0) word_top--;
805 | FOR WORD newline_list IN list_terminator newline_list DO compound_list DONE
807 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
808 if (word_top > 0) word_top--;
810 | FOR WORD newline_list IN list_terminator newline_list '{' compound_list '}'
812 $$ = make_for_command ($2, (WORD_LIST *)NULL, $8, word_lineno[word_top]);
813 if (word_top > 0) word_top--;
817 arith_for_command: FOR ARITH_FOR_EXPRS list_terminator newline_list DO compound_list DONE
819 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
820 if (word_top > 0) word_top--;
822 | FOR ARITH_FOR_EXPRS list_terminator newline_list '{' compound_list '}'
824 $$ = make_arith_for_command ($2, $6, arith_for_lineno);
825 if (word_top > 0) word_top--;
827 | FOR ARITH_FOR_EXPRS DO compound_list DONE
829 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
830 if (word_top > 0) word_top--;
832 | FOR ARITH_FOR_EXPRS '{' compound_list '}'
834 $$ = make_arith_for_command ($2, $4, arith_for_lineno);
835 if (word_top > 0) word_top--;
839 select_command: SELECT WORD newline_list DO list DONE
841 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
842 if (word_top > 0) word_top--;
844 | SELECT WORD newline_list '{' list '}'
846 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $5, word_lineno[word_top]);
847 if (word_top > 0) word_top--;
849 | SELECT WORD ';' newline_list DO list DONE
851 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
852 if (word_top > 0) word_top--;
854 | SELECT WORD ';' newline_list '{' list '}'
856 $$ = make_select_command ($2, add_string_to_list ("\"$@\"", (WORD_LIST *)NULL), $6, word_lineno[word_top]);
857 if (word_top > 0) word_top--;
859 | SELECT WORD newline_list IN word_list list_terminator newline_list DO list DONE
861 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
862 if (word_top > 0) word_top--;
864 | SELECT WORD newline_list IN word_list list_terminator newline_list '{' list '}'
866 $$ = make_select_command ($2, REVERSE_LIST ($5, WORD_LIST *), $9, word_lineno[word_top]);
867 if (word_top > 0) word_top--;
871 case_command: CASE WORD newline_list IN newline_list ESAC
873 $$ = make_case_command ($2, (PATTERN_LIST *)NULL, word_lineno[word_top]);
874 if (word_top > 0) word_top--;
876 | CASE WORD newline_list IN case_clause_sequence newline_list ESAC
878 $$ = make_case_command ($2, $5, word_lineno[word_top]);
879 if (word_top > 0) word_top--;
881 | CASE WORD newline_list IN case_clause ESAC
883 $$ = make_case_command ($2, $5, word_lineno[word_top]);
884 if (word_top > 0) word_top--;
888 function_def: WORD '(' ')' newline_list function_body
889 { $$ = make_function_def ($1, $5, function_dstart, function_bstart); }
891 | FUNCTION WORD '(' ')' newline_list function_body
892 { $$ = make_function_def ($2, $6, function_dstart, function_bstart); }
894 | FUNCTION WORD newline_list function_body
895 { $$ = make_function_def ($2, $4, function_dstart, function_bstart); }
898 function_body: shell_command
900 | shell_command redirection_list
905 /* According to Posix.2 3.9.5, redirections
906 specified after the body of a function should
907 be attached to the function and performed when
908 the function is executed, not as part of the
909 function definition command. */
910 /* XXX - I don't think it matters, but we might
911 want to change this in the future to avoid
912 problems differentiating between a function
913 definition with a redirection and a function
914 definition containing a single command with a
915 redirection. The two are semantically equivalent,
916 though -- the only difference is in how the
917 command printing code displays the redirections. */
920 register REDIRECT *t;
921 for (t = tc->redirects; t->next; t = t->next)
931 subshell: '(' compound_list ')'
933 $$ = make_subshell_command ($2);
934 $$->flags |= CMD_WANT_SUBSHELL;
938 coproc: COPROC shell_command
940 $$ = make_coproc_command ("COPROC", $2);
941 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
943 | COPROC shell_command redirection_list
950 register REDIRECT *t;
951 for (t = tc->redirects; t->next; t = t->next)
957 $$ = make_coproc_command ("COPROC", $2);
958 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
960 | COPROC WORD shell_command
962 $$ = make_coproc_command ($2->word, $3);
963 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
965 | COPROC WORD shell_command redirection_list
972 register REDIRECT *t;
973 for (t = tc->redirects; t->next; t = t->next)
979 $$ = make_coproc_command ($2->word, $3);
980 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
982 | COPROC simple_command
984 $$ = make_coproc_command ("COPROC", clean_simple_command ($2));
985 $$->flags |= CMD_WANT_SUBSHELL|CMD_COPROC_SUBSHELL;
989 if_command: IF compound_list THEN compound_list FI
990 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
991 | IF compound_list THEN compound_list ELSE compound_list FI
992 { $$ = make_if_command ($2, $4, $6); }
993 | IF compound_list THEN compound_list elif_clause FI
994 { $$ = make_if_command ($2, $4, $5); }
998 group_command: '{' compound_list '}'
999 { $$ = make_group_command ($2); }
1002 arith_command: ARITH_CMD
1003 { $$ = make_arith_command ($1); }
1006 cond_command: COND_START COND_CMD COND_END
1010 elif_clause: ELIF compound_list THEN compound_list
1011 { $$ = make_if_command ($2, $4, (COMMAND *)NULL); }
1012 | ELIF compound_list THEN compound_list ELSE compound_list
1013 { $$ = make_if_command ($2, $4, $6); }
1014 | ELIF compound_list THEN compound_list elif_clause
1015 { $$ = make_if_command ($2, $4, $5); }
1018 case_clause: pattern_list
1019 | case_clause_sequence pattern_list
1020 { $2->next = $1; $$ = $2; }
1023 pattern_list: newline_list pattern ')' compound_list
1024 { $$ = make_pattern_list ($2, $4); }
1025 | newline_list pattern ')' newline_list
1026 { $$ = make_pattern_list ($2, (COMMAND *)NULL); }
1027 | newline_list '(' pattern ')' compound_list
1028 { $$ = make_pattern_list ($3, $5); }
1029 | newline_list '(' pattern ')' newline_list
1030 { $$ = make_pattern_list ($3, (COMMAND *)NULL); }
1033 case_clause_sequence: pattern_list SEMI_SEMI
1035 | case_clause_sequence pattern_list SEMI_SEMI
1036 { $2->next = $1; $$ = $2; }
1037 | pattern_list SEMI_AND
1038 { $1->flags |= CASEPAT_FALLTHROUGH; $$ = $1; }
1039 | case_clause_sequence pattern_list SEMI_AND
1040 { $2->flags |= CASEPAT_FALLTHROUGH; $2->next = $1; $$ = $2; }
1041 | pattern_list SEMI_SEMI_AND
1042 { $1->flags |= CASEPAT_TESTNEXT; $$ = $1; }
1043 | case_clause_sequence pattern_list SEMI_SEMI_AND
1044 { $2->flags |= CASEPAT_TESTNEXT; $2->next = $1; $$ = $2; }
1048 { $$ = make_word_list ($1, (WORD_LIST *)NULL); }
1050 { $$ = make_word_list ($3, $1); }
1053 /* A list allows leading or trailing newlines and
1054 newlines as operators (equivalent to semicolons).
1055 It must end with a newline or semicolon.
1056 Lists are used within commands such as if, for, while. */
1058 list: newline_list list0
1062 gather_here_documents ();
1067 | newline_list list1
1073 list0: list1 '\n' newline_list
1074 | list1 '&' newline_list
1076 if ($1->type == cm_connection)
1077 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1079 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1081 | list1 ';' newline_list
1085 list1: list1 AND_AND newline_list list1
1086 { $$ = command_connect ($1, $4, AND_AND); }
1087 | list1 OR_OR newline_list list1
1088 { $$ = command_connect ($1, $4, OR_OR); }
1089 | list1 '&' newline_list list1
1091 if ($1->type == cm_connection)
1092 $$ = connect_async_list ($1, $4, '&');
1094 $$ = command_connect ($1, $4, '&');
1096 | list1 ';' newline_list list1
1097 { $$ = command_connect ($1, $4, ';'); }
1098 | list1 '\n' newline_list list1
1099 { $$ = command_connect ($1, $4, ';'); }
1104 simple_list_terminator: '\n'
1108 list_terminator:'\n'
1120 /* A simple_list is a list that contains no significant newlines
1121 and no leading or trailing newlines. Newlines are allowed
1122 only following operators, where they are not significant.
1124 This is what an inputunit consists of. */
1126 simple_list: simple_list1
1130 gather_here_documents ();
1131 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1133 global_command = $1;
1134 eof_encountered = 0;
1135 rewind_input_string ();
1141 if ($1->type == cm_connection)
1142 $$ = connect_async_list ($1, (COMMAND *)NULL, '&');
1144 $$ = command_connect ($1, (COMMAND *)NULL, '&');
1146 gather_here_documents ();
1147 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1149 global_command = $1;
1150 eof_encountered = 0;
1151 rewind_input_string ();
1159 gather_here_documents ();
1160 if ((parser_state & PST_CMDSUBST) && current_token == shell_eof_token)
1162 global_command = $1;
1163 eof_encountered = 0;
1164 rewind_input_string ();
1170 simple_list1: simple_list1 AND_AND newline_list simple_list1
1171 { $$ = command_connect ($1, $4, AND_AND); }
1172 | simple_list1 OR_OR newline_list simple_list1
1173 { $$ = command_connect ($1, $4, OR_OR); }
1174 | simple_list1 '&' simple_list1
1176 if ($1->type == cm_connection)
1177 $$ = connect_async_list ($1, $3, '&');
1179 $$ = command_connect ($1, $3, '&');
1181 | simple_list1 ';' simple_list1
1182 { $$ = command_connect ($1, $3, ';'); }
1188 pipeline_command: pipeline
1193 $2->flags |= CMD_INVERT_RETURN;
1202 | timespec BANG pipeline
1205 $3->flags |= $1|CMD_INVERT_RETURN;
1208 | BANG timespec pipeline
1211 $3->flags |= $2|CMD_INVERT_RETURN;
1214 | timespec list_terminator
1218 /* Boy, this is unclean. `time' by itself can
1219 time a null command. We cheat and push a
1220 newline back if the list_terminator was a newline
1221 to avoid the double-newline problem (one to
1222 terminate this, one to terminate the command) */
1225 $$ = make_simple_command (x, (COMMAND *)NULL);
1227 /* XXX - let's cheat and push a newline back */
1229 token_to_read = '\n';
1234 pipeline: pipeline '|' newline_list pipeline
1235 { $$ = command_connect ($1, $4, '|'); }
1236 | pipeline BAR_AND newline_list pipeline
1238 /* Make cmd1 |& cmd2 equivalent to cmd1 2>&1 | cmd2 */
1243 tc = $1->type == cm_simple ? (COMMAND *)$1->value.Simple : $1;
1246 r = make_redirection (sd, r_duplicating_output, rd, 0);
1249 register REDIRECT *t;
1250 for (t = tc->redirects; t->next; t = t->next)
1257 $$ = command_connect ($1, $4, '|');
1264 { $$ = CMD_TIME_PIPELINE; }
1266 { $$ = CMD_TIME_PIPELINE|CMD_TIME_POSIX; }
1270 /* Initial size to allocate for tokens, and the
1271 amount to grow them by. */
1272 #define TOKEN_DEFAULT_INITIAL_SIZE 496
1273 #define TOKEN_DEFAULT_GROW_SIZE 512
1275 /* Should we call prompt_again? */
1276 #define SHOULD_PROMPT() \
1277 (interactive && (bash_input.type == st_stdin || bash_input.type == st_stream))
1280 # define expanding_alias() (pushed_string_list && pushed_string_list->expander)
1282 # define expanding_alias() 0
1285 /* Global var is non-zero when end of file has been reached. */
1286 int EOF_Reached = 0;
1299 /* yy_getc () returns the next available character from input or EOF.
1300 yy_ungetc (c) makes `c' the next character to read.
1301 init_yy_io (get, unget, type, location) makes the function GET the
1302 installed function for getting the next character, makes UNGET the
1303 installed function for un-getting a character, sets the type of stream
1304 (either string or file) from TYPE, and makes LOCATION point to where
1305 the input is coming from. */
1307 /* Unconditionally returns end-of-file. */
1314 /* Variable containing the current get and unget functions.
1315 See ./input.h for a clearer description. */
1316 BASH_INPUT bash_input;
1318 /* Set all of the fields in BASH_INPUT to NULL. Free bash_input.name if it
1319 is non-null, avoiding a memory leak. */
1321 initialize_bash_input ()
1323 bash_input.type = st_none;
1324 FREE (bash_input.name);
1325 bash_input.name = (char *)NULL;
1326 bash_input.location.file = (FILE *)NULL;
1327 bash_input.location.string = (char *)NULL;
1328 bash_input.getter = (sh_cget_func_t *)NULL;
1329 bash_input.ungetter = (sh_cunget_func_t *)NULL;
1332 /* Set the contents of the current bash input stream from
1333 GET, UNGET, TYPE, NAME, and LOCATION. */
1335 init_yy_io (get, unget, type, name, location)
1336 sh_cget_func_t *get;
1337 sh_cunget_func_t *unget;
1338 enum stream_type type;
1340 INPUT_STREAM location;
1342 bash_input.type = type;
1343 FREE (bash_input.name);
1344 bash_input.name = name ? savestring (name) : (char *)NULL;
1348 memcpy((char *)&bash_input.location.string, (char *)&location.string, sizeof(location));
1350 bash_input.location = location;
1352 bash_input.getter = get;
1353 bash_input.ungetter = unget;
1359 return (bash_input.name ? bash_input.name : "stdin");
1362 /* Call this to get the next character of input. */
1366 return (*(bash_input.getter)) ();
1369 /* Call this to unget C. That is, to make C the next character
1375 return (*(bash_input.ungetter)) (c);
1378 #if defined (BUFFERED_INPUT)
1379 #ifdef INCLUDE_UNUSED
1381 input_file_descriptor ()
1383 switch (bash_input.type)
1386 return (fileno (bash_input.location.file));
1388 return (bash_input.location.buffered_fd);
1391 return (fileno (stdin));
1395 #endif /* BUFFERED_INPUT */
1397 /* **************************************************************** */
1399 /* Let input be read from readline (). */
1401 /* **************************************************************** */
1403 #if defined (READLINE)
1404 char *current_readline_prompt = (char *)NULL;
1405 char *current_readline_line = (char *)NULL;
1406 int current_readline_line_index = 0;
1411 SigHandler *old_sigint;
1415 if (!current_readline_line)
1417 if (!bash_readline_initialized)
1418 initialize_readline ();
1420 #if defined (JOB_CONTROL)
1422 give_terminal_to (shell_pgrp, 0);
1423 #endif /* JOB_CONTROL */
1425 old_sigint = (SigHandler *)NULL;
1426 if (signal_is_ignored (SIGINT) == 0)
1428 old_sigint = (SigHandler *)set_signal_handler (SIGINT, sigint_sighandler);
1429 interrupt_immediately++;
1431 terminate_immediately = 1;
1433 current_readline_line = readline (current_readline_prompt ?
1434 current_readline_prompt : "");
1436 terminate_immediately = 0;
1437 if (signal_is_ignored (SIGINT) == 0 && old_sigint)
1439 interrupt_immediately--;
1440 set_signal_handler (SIGINT, old_sigint);
1444 /* Reset the prompt to the decoded value of prompt_string_pointer. */
1445 reset_readline_prompt ();
1448 if (current_readline_line == 0)
1451 current_readline_line_index = 0;
1452 line_len = strlen (current_readline_line);
1454 current_readline_line = (char *)xrealloc (current_readline_line, 2 + line_len);
1455 current_readline_line[line_len++] = '\n';
1456 current_readline_line[line_len] = '\0';
1459 if (current_readline_line[current_readline_line_index] == 0)
1461 free (current_readline_line);
1462 current_readline_line = (char *)NULL;
1463 return (yy_readline_get ());
1467 c = current_readline_line[current_readline_line_index++];
1473 yy_readline_unget (c)
1476 if (current_readline_line_index && current_readline_line)
1477 current_readline_line[--current_readline_line_index] = c;
1482 with_input_from_stdin ()
1484 INPUT_STREAM location;
1486 if (bash_input.type != st_stdin && stream_on_stack (st_stdin) == 0)
1488 location.string = current_readline_line;
1489 init_yy_io (yy_readline_get, yy_readline_unget,
1490 st_stdin, "readline stdin", location);
1494 #else /* !READLINE */
1497 with_input_from_stdin ()
1499 with_input_from_stream (stdin, "stdin");
1501 #endif /* !READLINE */
1503 /* **************************************************************** */
1505 /* Let input come from STRING. STRING is zero terminated. */
1507 /* **************************************************************** */
1512 register char *string;
1513 register unsigned char c;
1515 string = bash_input.location.string;
1517 /* If the string doesn't exist, or is empty, EOF found. */
1518 if (string && *string)
1521 bash_input.location.string = string;
1532 *(--bash_input.location.string) = c;
1537 with_input_from_string (string, name)
1541 INPUT_STREAM location;
1543 location.string = string;
1544 init_yy_io (yy_string_get, yy_string_unget, st_string, name, location);
1547 /* Count the number of characters we've consumed from bash_input.location.string
1548 and read into shell_input_line, but have not returned from shell_getc.
1549 That is the true input location. Rewind bash_input.location.string by
1550 that number of characters, so it points to the last character actually
1551 consumed by the parser. */
1553 rewind_input_string ()
1557 /* number of unconsumed characters in the input -- XXX need to take newlines
1558 into account, e.g., $(...\n) */
1559 xchars = shell_input_line_len - shell_input_line_index;
1560 if (bash_input.location.string[-1] == '\n')
1563 /* XXX - how to reflect bash_input.location.string back to string passed to
1564 parse_and_execute or xparse_dolparen? xparse_dolparen needs to know how
1565 far into the string we parsed. parse_and_execute knows where bash_input.
1566 location.string is, and how far from orig_string that is -- that's the
1567 number of characters the command consumed. */
1569 /* bash_input.location.string - xchars should be where we parsed to */
1570 /* need to do more validation on xchars value for sanity -- test cases. */
1571 bash_input.location.string -= xchars;
1574 /* **************************************************************** */
1576 /* Let input come from STREAM. */
1578 /* **************************************************************** */
1580 /* These two functions used to test the value of the HAVE_RESTARTABLE_SYSCALLS
1581 define, and just use getc/ungetc if it was defined, but since bash
1582 installs its signal handlers without the SA_RESTART flag, some signals
1583 (like SIGCHLD, SIGWINCH, etc.) received during a read(2) will not cause
1584 the read to be restarted. We need to restart it ourselves. */
1592 if (bash_input.location.file)
1596 interrupt_immediately++;
1597 terminate_immediately++;
1599 result = getc_with_restart (bash_input.location.file);
1602 interrupt_immediately--;
1603 terminate_immediately--;
1613 return (ungetc_with_restart (c, bash_input.location.file));
1617 with_input_from_stream (stream, name)
1621 INPUT_STREAM location;
1623 location.file = stream;
1624 init_yy_io (yy_stream_get, yy_stream_unget, st_stream, name, location);
1627 typedef struct stream_saver {
1628 struct stream_saver *next;
1629 BASH_INPUT bash_input;
1631 #if defined (BUFFERED_INPUT)
1632 BUFFERED_STREAM *bstream;
1633 #endif /* BUFFERED_INPUT */
1636 /* The globally known line number. */
1637 int line_number = 0;
1639 #if defined (COND_COMMAND)
1640 static int cond_lineno;
1641 static int cond_token;
1644 STREAM_SAVER *stream_list = (STREAM_SAVER *)NULL;
1647 push_stream (reset_lineno)
1650 STREAM_SAVER *saver = (STREAM_SAVER *)xmalloc (sizeof (STREAM_SAVER));
1652 xbcopy ((char *)&bash_input, (char *)&(saver->bash_input), sizeof (BASH_INPUT));
1654 #if defined (BUFFERED_INPUT)
1655 saver->bstream = (BUFFERED_STREAM *)NULL;
1656 /* If we have a buffered stream, clear out buffers[fd]. */
1657 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1658 saver->bstream = set_buffered_stream (bash_input.location.buffered_fd,
1659 (BUFFERED_STREAM *)NULL);
1660 #endif /* BUFFERED_INPUT */
1662 saver->line = line_number;
1663 bash_input.name = (char *)NULL;
1664 saver->next = stream_list;
1665 stream_list = saver;
1678 STREAM_SAVER *saver = stream_list;
1681 stream_list = stream_list->next;
1683 init_yy_io (saver->bash_input.getter,
1684 saver->bash_input.ungetter,
1685 saver->bash_input.type,
1686 saver->bash_input.name,
1687 saver->bash_input.location);
1689 #if defined (BUFFERED_INPUT)
1690 /* If we have a buffered stream, restore buffers[fd]. */
1691 /* If the input file descriptor was changed while this was on the
1692 save stack, update the buffered fd to the new file descriptor and
1693 re-establish the buffer <-> bash_input fd correspondence. */
1694 if (bash_input.type == st_bstream && bash_input.location.buffered_fd >= 0)
1696 if (bash_input_fd_changed)
1698 bash_input_fd_changed = 0;
1699 if (default_buffered_input >= 0)
1701 bash_input.location.buffered_fd = default_buffered_input;
1702 saver->bstream->b_fd = default_buffered_input;
1703 SET_CLOSE_ON_EXEC (default_buffered_input);
1706 /* XXX could free buffered stream returned as result here. */
1707 set_buffered_stream (bash_input.location.buffered_fd, saver->bstream);
1709 #endif /* BUFFERED_INPUT */
1711 line_number = saver->line;
1713 FREE (saver->bash_input.name);
1718 /* Return 1 if a stream of type TYPE is saved on the stack. */
1720 stream_on_stack (type)
1721 enum stream_type type;
1723 register STREAM_SAVER *s;
1725 for (s = stream_list; s; s = s->next)
1726 if (s->bash_input.type == type)
1731 /* Save the current token state and return it in a malloced array. */
1737 ret = (int *)xmalloc (4 * sizeof (int));
1738 ret[0] = last_read_token;
1739 ret[1] = token_before_that;
1740 ret[2] = two_tokens_ago;
1741 ret[3] = current_token;
1746 restore_token_state (ts)
1751 last_read_token = ts[0];
1752 token_before_that = ts[1];
1753 two_tokens_ago = ts[2];
1754 current_token = ts[3];
1758 * This is used to inhibit alias expansion and reserved word recognition
1759 * inside case statement pattern lists. A `case statement pattern list' is:
1761 * everything between the `in' in a `case word in' and the next ')'
1763 * everything between a `;;' and the next `)' or `esac'
1766 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1768 #define END_OF_ALIAS 0
1771 * Pseudo-global variables used in implementing token-wise alias expansion.
1775 * Pushing and popping strings. This works together with shell_getc to
1776 * implement alias expansion on a per-token basis.
1779 typedef struct string_saver {
1780 struct string_saver *next;
1781 int expand_alias; /* Value to set expand_alias to when string is popped. */
1784 alias_t *expander; /* alias that caused this line to be pushed. */
1786 int saved_line_size, saved_line_index, saved_line_terminator;
1789 STRING_SAVER *pushed_string_list = (STRING_SAVER *)NULL;
1792 * Push the current shell_input_line onto a stack of such lines and make S
1793 * the current input. Used when expanding aliases. EXPAND is used to set
1794 * the value of expand_next_token when the string is popped, so that the
1795 * word after the alias in the original line is handled correctly when the
1796 * alias expands to multiple words. TOKEN is the token that was expanded
1797 * into S; it is saved and used to prevent infinite recursive expansion.
1800 push_string (s, expand, ap)
1805 STRING_SAVER *temp = (STRING_SAVER *)xmalloc (sizeof (STRING_SAVER));
1807 temp->expand_alias = expand;
1808 temp->saved_line = shell_input_line;
1809 temp->saved_line_size = shell_input_line_size;
1810 temp->saved_line_index = shell_input_line_index;
1811 temp->saved_line_terminator = shell_input_line_terminator;
1813 temp->expander = ap;
1815 temp->next = pushed_string_list;
1816 pushed_string_list = temp;
1820 ap->flags |= AL_BEINGEXPANDED;
1823 shell_input_line = s;
1824 shell_input_line_size = strlen (s);
1825 shell_input_line_index = 0;
1826 shell_input_line_terminator = '\0';
1828 parser_state &= ~PST_ALEXPNEXT; /* XXX */
1831 set_line_mbstate ();
1835 * Make the top of the pushed_string stack be the current shell input.
1836 * Only called when there is something on the stack. Called from shell_getc
1837 * when it thinks it has consumed the string generated by an alias expansion
1838 * and needs to return to the original input line.
1845 FREE (shell_input_line);
1846 shell_input_line = pushed_string_list->saved_line;
1847 shell_input_line_index = pushed_string_list->saved_line_index;
1848 shell_input_line_size = pushed_string_list->saved_line_size;
1849 shell_input_line_terminator = pushed_string_list->saved_line_terminator;
1851 if (pushed_string_list->expand_alias)
1852 parser_state |= PST_ALEXPNEXT;
1854 parser_state &= ~PST_ALEXPNEXT;
1856 t = pushed_string_list;
1857 pushed_string_list = pushed_string_list->next;
1861 t->expander->flags &= ~AL_BEINGEXPANDED;
1866 set_line_mbstate ();
1872 register STRING_SAVER *t, *t1;
1874 for (t = pushed_string_list; t; )
1877 FREE (t->saved_line);
1880 t->expander->flags &= ~AL_BEINGEXPANDED;
1885 pushed_string_list = (STRING_SAVER *)NULL;
1888 #endif /* ALIAS || DPAREN_ARITHMETIC */
1891 free_pushed_string_input ()
1893 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
1894 free_string_list ();
1898 /* Return a line of text, taken from wherever yylex () reads input.
1899 If there is no more input, then we return NULL. If REMOVE_QUOTED_NEWLINE
1900 is non-zero, we remove unquoted \<newline> pairs. This is used by
1901 read_secondary_line to read here documents. */
1903 read_a_line (remove_quoted_newline)
1904 int remove_quoted_newline;
1906 static char *line_buffer = (char *)NULL;
1907 static int buffer_size = 0;
1908 int indx, c, peekc, pass_next;
1910 #if defined (READLINE)
1911 if (no_line_editing && SHOULD_PROMPT ())
1913 if (SHOULD_PROMPT ())
1917 pass_next = indx = 0;
1920 /* Allow immediate exit if interrupted during input. */
1925 /* Ignore null bytes in input. */
1929 internal_warning ("read_a_line: ignored null byte in input");
1934 /* If there is no more input, then we return NULL. */
1937 if (interactive && bash_input.type == st_stream)
1940 return ((char *)NULL);
1944 /* `+2' in case the final character in the buffer is a newline. */
1945 RESIZE_MALLOCED_BUFFER (line_buffer, indx, 2, buffer_size, 128);
1947 /* IF REMOVE_QUOTED_NEWLINES is non-zero, we are reading a
1948 here document with an unquoted delimiter. In this case,
1949 the line will be expanded as if it were in double quotes.
1950 We allow a backslash to escape the next character, but we
1951 need to treat the backslash specially only if a backslash
1952 quoting a backslash-newline pair appears in the line. */
1955 line_buffer[indx++] = c;
1958 else if (c == '\\' && remove_quoted_newline)
1965 continue; /* Make the unquoted \<newline> pair disappear. */
1971 line_buffer[indx++] = c; /* Preserve the backslash. */
1975 line_buffer[indx++] = c;
1979 line_buffer[indx] = '\0';
1980 return (line_buffer);
1985 /* Return a line as in read_a_line (), but insure that the prompt is
1986 the secondary prompt. This is used to read the lines of a here
1987 document. REMOVE_QUOTED_NEWLINE is non-zero if we should remove
1988 newlines quoted with backslashes while reading the line. It is
1989 non-zero unless the delimiter of the here document was quoted. */
1991 read_secondary_line (remove_quoted_newline)
1992 int remove_quoted_newline;
1997 prompt_string_pointer = &ps2_prompt;
1998 if (SHOULD_PROMPT())
2000 ret = read_a_line (remove_quoted_newline);
2001 #if defined (HISTORY)
2002 if (ret && remember_on_history && (parser_state & PST_HEREDOC))
2004 /* To make adding the the here-document body right, we need to rely
2005 on history_delimiting_chars() returning \n for the first line of
2006 the here-document body and the null string for the second and
2007 subsequent lines, so we avoid double newlines.
2008 current_command_line_count == 2 for the first line of the body. */
2010 current_command_line_count++;
2011 maybe_add_history (ret);
2013 #endif /* HISTORY */
2017 /* **************************************************************** */
2021 /* **************************************************************** */
2023 /* Reserved words. These are only recognized as the first word of a
2025 STRING_INT_ALIST word_token_alist[] = {
2034 #if defined (SELECT_COMMAND)
2035 { "select", SELECT },
2042 { "function", FUNCTION },
2043 #if defined (COMMAND_TIMING)
2049 #if defined (COND_COMMAND)
2050 { "[[", COND_START },
2053 #if defined (COPROCESS_SUPPORT)
2054 { "coproc", COPROC },
2059 /* other tokens that can be returned by read_token() */
2060 STRING_INT_ALIST other_token_alist[] = {
2061 /* Multiple-character tokens with special values */
2065 { ">>", GREATER_GREATER },
2066 { "<<", LESS_LESS },
2068 { ">&", GREATER_AND },
2069 { ";;", SEMI_SEMI },
2071 { ";;&", SEMI_SEMI_AND },
2072 { "<<-", LESS_LESS_MINUS },
2073 { "<<<", LESS_LESS_LESS },
2074 { "&>", AND_GREATER },
2075 { "&>>", AND_GREATER_GREATER },
2076 { "<>", LESS_GREATER },
2077 { ">|", GREATER_BAR },
2079 { "EOF", yacc_EOF },
2080 /* Tokens whose value is the character itself */
2091 { "newline", '\n' },
2095 /* others not listed here:
2096 WORD look at yylval.word
2097 ASSIGNMENT_WORD look at yylval.word
2098 NUMBER look at yylval.number
2099 ARITH_CMD look at yylval.word_list
2100 ARITH_FOR_EXPRS look at yylval.word_list
2101 COND_CMD look at yylval.command
2104 /* These are used by read_token_word, but appear up here so that shell_getc
2105 can use them to decide when to add otherwise blank lines to the history. */
2107 /* The primary delimiter stack. */
2108 struct dstack dstack = { (char *)NULL, 0, 0 };
2110 /* A temporary delimiter stack to be used when decoding prompt strings.
2111 This is needed because command substitutions in prompt strings (e.g., PS2)
2112 can screw up the parser's quoting state. */
2113 static struct dstack temp_dstack = { (char *)NULL, 0, 0 };
2115 /* Macro for accessing the top delimiter on the stack. Returns the
2116 delimiter or zero if none. */
2117 #define current_delimiter(ds) \
2118 (ds.delimiter_depth ? ds.delimiters[ds.delimiter_depth - 1] : 0)
2120 #define push_delimiter(ds, character) \
2123 if (ds.delimiter_depth + 2 > ds.delimiter_space) \
2124 ds.delimiters = (char *)xrealloc \
2125 (ds.delimiters, (ds.delimiter_space += 10) * sizeof (char)); \
2126 ds.delimiters[ds.delimiter_depth] = character; \
2127 ds.delimiter_depth++; \
2131 #define pop_delimiter(ds) ds.delimiter_depth--
2133 /* Return the next shell input character. This always reads characters
2134 from shell_input_line; when that line is exhausted, it is time to
2135 read the next line. This is called by read_token when the shell is
2136 processing normal command input. */
2138 /* This implements one-character lookahead/lookbehind across physical input
2139 lines, to avoid something being lost because it's pushed back with
2140 shell_ungetc when we're at the start of a line. */
2141 static int eol_ungetc_lookahead = 0;
2144 shell_getc (remove_quoted_newline)
2145 int remove_quoted_newline;
2153 if (sigwinch_received)
2155 sigwinch_received = 0;
2156 get_new_window_size (0, (int *)0, (int *)0);
2159 if (eol_ungetc_lookahead)
2161 c = eol_ungetc_lookahead;
2162 eol_ungetc_lookahead = 0;
2166 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2167 /* If shell_input_line[shell_input_line_index] == 0, but there is
2168 something on the pushed list of strings, then we don't want to go
2169 off and get another line. We let the code down below handle it. */
2171 if (!shell_input_line || ((!shell_input_line[shell_input_line_index]) &&
2172 (pushed_string_list == (STRING_SAVER *)NULL)))
2173 #else /* !ALIAS && !DPAREN_ARITHMETIC */
2174 if (!shell_input_line || !shell_input_line[shell_input_line_index])
2175 #endif /* !ALIAS && !DPAREN_ARITHMETIC */
2181 /* Allow immediate exit if interrupted during input. */
2185 shell_input_line_terminator = 0;
2187 /* If the shell is interatctive, but not currently printing a prompt
2188 (interactive_shell && interactive == 0), we don't want to print
2189 notifies or cleanup the jobs -- we want to defer it until we do
2190 print the next prompt. */
2191 if (interactive_shell == 0 || SHOULD_PROMPT())
2193 #if defined (JOB_CONTROL)
2194 /* This can cause a problem when reading a command as the result
2195 of a trap, when the trap is called from flush_child. This call
2196 had better not cause jobs to disappear from the job table in
2197 that case, or we will have big trouble. */
2198 notify_and_cleanup ();
2199 #else /* !JOB_CONTROL */
2200 cleanup_dead_jobs ();
2201 #endif /* !JOB_CONTROL */
2204 #if defined (READLINE)
2205 if (no_line_editing && SHOULD_PROMPT())
2207 if (SHOULD_PROMPT())
2211 if (bash_input.type == st_stream)
2218 /* Allow immediate exit if interrupted during input. */
2224 internal_warning ("shell_getc: ignored null byte in input");
2229 RESIZE_MALLOCED_BUFFER (shell_input_line, i, 2, shell_input_line_size, 256);
2233 if (bash_input.type == st_stream)
2237 shell_input_line_terminator = EOF;
2239 shell_input_line[i] = '\0';
2243 shell_input_line[i++] = c;
2247 shell_input_line[--i] = '\0';
2248 current_command_line_count++;
2253 shell_input_line_index = 0;
2254 shell_input_line_len = i; /* == strlen (shell_input_line) */
2256 set_line_mbstate ();
2258 #if defined (HISTORY)
2259 if (remember_on_history && shell_input_line && shell_input_line[0])
2262 # if defined (BANG_HISTORY)
2265 /* If the current delimiter is a single quote, we should not be
2266 performing history expansion, even if we're on a different
2267 line from the original single quote. */
2268 old_hist = history_expansion_inhibited;
2269 if (current_delimiter (dstack) == '\'')
2270 history_expansion_inhibited = 1;
2272 expansions = pre_process_line (shell_input_line, 1, 1);
2273 # if defined (BANG_HISTORY)
2274 history_expansion_inhibited = old_hist;
2276 if (expansions != shell_input_line)
2278 free (shell_input_line);
2279 shell_input_line = expansions;
2280 shell_input_line_len = shell_input_line ?
2281 strlen (shell_input_line) : 0;
2282 if (shell_input_line_len == 0)
2283 current_command_line_count--;
2285 /* We have to force the xrealloc below because we don't know
2286 the true allocated size of shell_input_line anymore. */
2287 shell_input_line_size = shell_input_line_len;
2289 set_line_mbstate ();
2292 /* Try to do something intelligent with blank lines encountered while
2293 entering multi-line commands. XXX - this is grotesque */
2294 else if (remember_on_history && shell_input_line &&
2295 shell_input_line[0] == '\0' &&
2296 current_command_line_count > 1)
2298 if (current_delimiter (dstack))
2299 /* We know shell_input_line[0] == 0 and we're reading some sort of
2300 quoted string. This means we've got a line consisting of only
2301 a newline in a quoted string. We want to make sure this line
2302 gets added to the history. */
2303 maybe_add_history (shell_input_line);
2307 hdcs = history_delimiting_chars ();
2308 if (hdcs && hdcs[0] == ';')
2309 maybe_add_history (shell_input_line);
2313 #endif /* HISTORY */
2315 if (shell_input_line)
2317 /* Lines that signify the end of the shell's input should not be
2319 if (echo_input_at_read && (shell_input_line[0] ||
2320 shell_input_line_terminator != EOF))
2321 fprintf (stderr, "%s\n", shell_input_line);
2325 shell_input_line_size = 0;
2326 prompt_string_pointer = ¤t_prompt_string;
2327 if (SHOULD_PROMPT ())
2332 /* Add the newline to the end of this string, iff the string does
2333 not already end in an EOF character. */
2334 if (shell_input_line_terminator != EOF)
2336 if (shell_input_line_len + 3 > shell_input_line_size)
2337 shell_input_line = (char *)xrealloc (shell_input_line,
2338 1 + (shell_input_line_size += 2));
2340 shell_input_line[shell_input_line_len] = '\n';
2341 shell_input_line[shell_input_line_len + 1] = '\0';
2343 set_line_mbstate ();
2348 uc = shell_input_line[shell_input_line_index];
2351 shell_input_line_index++;
2353 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2354 /* If UC is NULL, we have reached the end of the current input string. If
2355 pushed_string_list is non-empty, it's time to pop to the previous string
2356 because we have fully consumed the result of the last alias expansion.
2357 Do it transparently; just return the next character of the string popped
2360 if (uc == 0 && (pushed_string_list != (STRING_SAVER *)NULL))
2363 uc = shell_input_line[shell_input_line_index];
2365 shell_input_line_index++;
2367 #endif /* ALIAS || DPAREN_ARITHMETIC */
2369 if MBTEST(uc == '\\' && remove_quoted_newline && shell_input_line[shell_input_line_index] == '\n')
2371 if (SHOULD_PROMPT ())
2374 /* What do we do here if we're expanding an alias whose definition
2375 includes an escaped newline? If that's the last character in the
2376 alias expansion, we just pop the pushed string list (recall that
2377 we inhibit the appending of a space in mk_alexpansion() if newline
2378 is the last character). If it's not the last character, we need
2379 to consume the quoted newline and move to the next character in
2381 if (expanding_alias () && shell_input_line[shell_input_line_index+1] == '\0')
2386 else if (expanding_alias () && shell_input_line[shell_input_line_index+1] != '\0')
2388 shell_input_line_index++; /* skip newline */
2389 goto next_alias_char; /* and get next character */
2395 if (uc == 0 && shell_input_line_terminator == EOF)
2396 return ((shell_input_line_index != 0) ? '\n' : EOF);
2401 /* Put C back into the input for the shell. This might need changes for
2402 HANDLE_MULTIBYTE around EOLs. Since we (currently) never push back a
2403 character different than we read, shell_input_line_property doesn't need
2404 to change when manipulating shell_input_line. The define for
2405 last_shell_getc_is_singlebyte should take care of it, though. */
2410 if (shell_input_line && shell_input_line_index)
2411 shell_input_line[--shell_input_line_index] = c;
2413 eol_ungetc_lookahead = c;
2416 #ifdef INCLUDE_UNUSED
2417 /* Back the input pointer up by one, effectively `ungetting' a character. */
2421 if (shell_input_line && shell_input_line_index)
2422 shell_input_line_index--;
2426 /* Discard input until CHARACTER is seen, then push that character back
2427 onto the input stream. */
2429 discard_until (character)
2434 while ((c = shell_getc (0)) != EOF && c != character)
2442 execute_variable_command (command, vname)
2443 char *command, *vname;
2446 sh_parser_state_t ps;
2448 save_parser_state (&ps);
2449 last_lastarg = get_string_value ("_");
2451 last_lastarg = savestring (last_lastarg);
2453 parse_and_execute (savestring (command), vname, SEVAL_NONINT|SEVAL_NOHIST);
2455 restore_parser_state (&ps);
2456 bind_variable ("_", last_lastarg, 0);
2457 FREE (last_lastarg);
2459 if (token_to_read == '\n') /* reset_parser was called */
2463 /* Place to remember the token. We try to keep the buffer
2464 at a reasonable size, but it can grow. */
2465 static char *token = (char *)NULL;
2467 /* Current size of the token buffer. */
2468 static int token_buffer_size;
2470 /* Command to read_token () explaining what we want it to do. */
2473 #define prompt_is_ps1 \
2474 (!prompt_string_pointer || prompt_string_pointer == &ps1_prompt)
2476 /* Function for yyparse to call. yylex keeps track of
2477 the last two tokens read, and calls read_token. */
2481 if (interactive && (current_token == 0 || current_token == '\n'))
2483 /* Before we print a prompt, we might have to check mailboxes.
2484 We do this only if it is time to do so. Notice that only here
2485 is the mail alarm reset; nothing takes place in check_mail ()
2486 except the checking of mail. Please don't change this. */
2487 if (prompt_is_ps1 && time_to_check_mail ())
2490 reset_mail_timer ();
2493 /* Avoid printing a prompt if we're not going to read anything, e.g.
2494 after resetting the parser with read_token (RESET). */
2495 if (token_to_read == 0 && SHOULD_PROMPT ())
2499 two_tokens_ago = token_before_that;
2500 token_before_that = last_read_token;
2501 last_read_token = current_token;
2502 current_token = read_token (READ);
2504 if ((parser_state & PST_EOFTOKEN) && current_token == shell_eof_token)
2506 current_token = yacc_EOF;
2507 if (bash_input.type == st_string)
2508 rewind_input_string ();
2510 parser_state &= ~PST_EOFTOKEN;
2512 return (current_token);
2515 /* When non-zero, we have read the required tokens
2516 which allow ESAC to be the next one read. */
2517 static int esacs_needed_count;
2520 gather_here_documents ()
2525 while (need_here_doc)
2527 parser_state |= PST_HEREDOC;
2528 make_here_document (redir_stack[r++], line_number);
2529 parser_state &= ~PST_HEREDOC;
2534 /* When non-zero, an open-brace used to create a group is awaiting a close
2536 static int open_brace_count;
2538 #define command_token_position(token) \
2539 (((token) == ASSIGNMENT_WORD) || (parser_state&PST_REDIRLIST) || \
2540 ((token) != SEMI_SEMI && (token) != SEMI_AND && (token) != SEMI_SEMI_AND && reserved_word_acceptable(token)))
2542 #define assignment_acceptable(token) \
2543 (command_token_position(token) && ((parser_state & PST_CASEPAT) == 0))
2545 /* Check to see if TOKEN is a reserved word and return the token
2547 #define CHECK_FOR_RESERVED_WORD(tok) \
2549 if (!dollar_present && !quoted && \
2550 reserved_word_acceptable (last_read_token)) \
2553 for (i = 0; word_token_alist[i].word != (char *)NULL; i++) \
2554 if (STREQ (tok, word_token_alist[i].word)) \
2556 if ((parser_state & PST_CASEPAT) && (word_token_alist[i].token != ESAC)) \
2558 if (word_token_alist[i].token == TIME && time_command_acceptable () == 0) \
2560 if (word_token_alist[i].token == ESAC) \
2561 parser_state &= ~(PST_CASEPAT|PST_CASESTMT); \
2562 else if (word_token_alist[i].token == CASE) \
2563 parser_state |= PST_CASESTMT; \
2564 else if (word_token_alist[i].token == COND_END) \
2565 parser_state &= ~(PST_CONDCMD|PST_CONDEXPR); \
2566 else if (word_token_alist[i].token == COND_START) \
2567 parser_state |= PST_CONDCMD; \
2568 else if (word_token_alist[i].token == '{') \
2569 open_brace_count++; \
2570 else if (word_token_alist[i].token == '}' && open_brace_count) \
2571 open_brace_count--; \
2572 return (word_token_alist[i].token); \
2579 /* OK, we have a token. Let's try to alias expand it, if (and only if)
2582 It is eligible for expansion if EXPAND_ALIASES is set, and
2583 the token is unquoted and the last token read was a command
2584 separator (or expand_next_token is set), and we are currently
2585 processing an alias (pushed_string_list is non-empty) and this
2586 token is not the same as the current or any previously
2589 Special cases that disqualify:
2590 In a pattern list in a case statement (parser_state & PST_CASEPAT). */
2600 r = xmalloc (l + 2);
2602 /* If the last character in the alias is a newline, don't add a trailing
2603 space to the expansion. Works with shell_getc above. */
2604 if (r[l - 1] != ' ' && r[l - 1] != '\n')
2611 alias_expand_token (tokstr)
2617 if (((parser_state & PST_ALEXPNEXT) || command_token_position (last_read_token)) &&
2618 (parser_state & PST_CASEPAT) == 0)
2620 ap = find_alias (tokstr);
2622 /* Currently expanding this token. */
2623 if (ap && (ap->flags & AL_BEINGEXPANDED))
2624 return (NO_EXPANSION);
2626 /* mk_alexpansion puts an extra space on the end of the alias expansion,
2627 so the lookahead by the parser works right. If this gets changed,
2628 make sure the code in shell_getc that deals with reaching the end of
2629 an expanded alias is changed with it. */
2630 expanded = ap ? mk_alexpansion (ap->value) : (char *)NULL;
2634 push_string (expanded, ap->flags & AL_EXPANDNEXT, ap);
2635 return (RE_READ_TOKEN);
2638 /* This is an eligible token that does not have an expansion. */
2639 return (NO_EXPANSION);
2641 return (NO_EXPANSION);
2646 time_command_acceptable ()
2648 #if defined (COMMAND_TIMING)
2649 switch (last_read_token)
2668 #endif /* COMMAND_TIMING */
2671 /* Handle special cases of token recognition:
2672 IN is recognized if the last token was WORD and the token
2673 before that was FOR or CASE or SELECT.
2675 DO is recognized if the last token was WORD and the token
2676 before that was FOR or SELECT.
2678 ESAC is recognized if the last token caused `esacs_needed_count'
2681 `{' is recognized if the last token as WORD and the token
2682 before that was FUNCTION, or if we just parsed an arithmetic
2685 `}' is recognized if there is an unclosed `{' present.
2687 `-p' is returned as TIMEOPT if the last read token was TIME.
2689 ']]' is returned as COND_END if the parser is currently parsing
2690 a conditional expression ((parser_state & PST_CONDEXPR) != 0)
2692 `time' is returned as TIME if and only if it is immediately
2693 preceded by one of `;', `\n', `||', `&&', or `&'.
2697 special_case_tokens (tokstr)
2700 if ((last_read_token == WORD) &&
2701 #if defined (SELECT_COMMAND)
2702 ((token_before_that == FOR) || (token_before_that == CASE) || (token_before_that == SELECT)) &&
2704 ((token_before_that == FOR) || (token_before_that == CASE)) &&
2706 (tokstr[0] == 'i' && tokstr[1] == 'n' && tokstr[2] == 0))
2708 if (token_before_that == CASE)
2710 parser_state |= PST_CASEPAT;
2711 esacs_needed_count++;
2716 if (last_read_token == WORD &&
2717 #if defined (SELECT_COMMAND)
2718 (token_before_that == FOR || token_before_that == SELECT) &&
2720 (token_before_that == FOR) &&
2722 (tokstr[0] == 'd' && tokstr[1] == 'o' && tokstr[2] == '\0'))
2725 /* Ditto for ESAC in the CASE case.
2726 Specifically, this handles "case word in esac", which is a legal
2727 construct, certainly because someone will pass an empty arg to the
2728 case construct, and we don't want it to barf. Of course, we should
2729 insist that the case construct has at least one pattern in it, but
2730 the designers disagree. */
2731 if (esacs_needed_count)
2733 esacs_needed_count--;
2734 if (STREQ (tokstr, "esac"))
2736 parser_state &= ~PST_CASEPAT;
2741 /* The start of a shell function definition. */
2742 if (parser_state & PST_ALLOWOPNBRC)
2744 parser_state &= ~PST_ALLOWOPNBRC;
2745 if (tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2748 function_bstart = line_number;
2749 return ('{'); /* } */
2753 /* We allow a `do' after a for ((...)) without an intervening
2755 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == 'd' && tokstr[1] == 'o' && !tokstr[2])
2757 if (last_read_token == ARITH_FOR_EXPRS && tokstr[0] == '{' && tokstr[1] == '\0') /* } */
2760 return ('{'); /* } */
2763 if (open_brace_count && reserved_word_acceptable (last_read_token) && tokstr[0] == '}' && !tokstr[1])
2765 open_brace_count--; /* { */
2769 #if defined (COMMAND_TIMING)
2770 /* Handle -p after `time'. */
2771 if (last_read_token == TIME && tokstr[0] == '-' && tokstr[1] == 'p' && !tokstr[2])
2776 #if defined (COMMAND_TIMING)
2777 if (STREQ (token, "time") && ((parser_state & PST_CASEPAT) == 0) && time_command_acceptable ())
2779 #endif /* COMMAND_TIMING */
2782 #if defined (COND_COMMAND) /* [[ */
2783 if ((parser_state & PST_CONDEXPR) && tokstr[0] == ']' && tokstr[1] == ']' && tokstr[2] == '\0')
2790 /* Called from shell.c when Control-C is typed at top level. Or
2791 by the error rule at top level. */
2795 dstack.delimiter_depth = 0; /* No delimiters found so far. */
2796 open_brace_count = 0;
2798 #if defined (EXTENDED_GLOB)
2799 /* Reset to global value of extended glob */
2800 if (parser_state & PST_EXTPAT)
2801 extended_glob = global_extglob;
2806 #if defined (ALIAS) || defined (DPAREN_ARITHMETIC)
2807 if (pushed_string_list)
2808 free_string_list ();
2809 #endif /* ALIAS || DPAREN_ARITHMETIC */
2811 if (shell_input_line)
2813 free (shell_input_line);
2814 shell_input_line = (char *)NULL;
2815 shell_input_line_size = shell_input_line_index = 0;
2818 FREE (word_desc_to_read);
2819 word_desc_to_read = (WORD_DESC *)NULL;
2821 current_token = '\n'; /* XXX */
2822 last_read_token = '\n';
2823 token_to_read = '\n';
2826 /* Read the next token. Command can be READ (normal operation) or
2827 RESET (to normalize state). */
2829 read_token (command)
2832 int character; /* Current character. */
2833 int peek_char; /* Temporary look-ahead character. */
2834 int result; /* The thing to return. */
2836 if (command == RESET)
2844 result = token_to_read;
2845 if (token_to_read == WORD || token_to_read == ASSIGNMENT_WORD)
2847 yylval.word = word_desc_to_read;
2848 word_desc_to_read = (WORD_DESC *)NULL;
2854 #if defined (COND_COMMAND)
2855 if ((parser_state & (PST_CONDCMD|PST_CONDEXPR)) == PST_CONDCMD)
2857 cond_lineno = line_number;
2858 parser_state |= PST_CONDEXPR;
2859 yylval.command = parse_cond_command ();
2860 if (cond_token != COND_END)
2865 token_to_read = COND_END;
2866 parser_state &= ~(PST_CONDEXPR|PST_CONDCMD);
2872 /* This is a place to jump back to once we have successfully expanded a
2873 token with an alias and pushed the string with push_string () */
2877 /* Read a single word from input. Start by skipping blanks. */
2878 while ((character = shell_getc (1)) != EOF && shellblank (character))
2881 if (character == EOF)
2887 if MBTEST(character == '#' && (!interactive || interactive_comments))
2889 /* A comment. Discard until EOL or EOF, and then return a newline. */
2890 discard_until ('\n');
2892 character = '\n'; /* this will take the next if statement and return. */
2895 if (character == '\n')
2897 /* If we're about to return an unquoted newline, we can go and collect
2898 the text of any pending here document. */
2900 gather_here_documents ();
2903 parser_state &= ~PST_ALEXPNEXT;
2906 parser_state &= ~PST_ASSIGNOK;
2911 if (parser_state & PST_REGEXP)
2914 /* Shell meta-characters. */
2915 if MBTEST(shellmeta (character) && ((parser_state & PST_DBLPAREN) == 0))
2918 /* Turn off alias tokenization iff this character sequence would
2919 not leave us ready to read a command. */
2920 if (character == '<' || character == '>')
2921 parser_state &= ~PST_ALEXPNEXT;
2924 parser_state &= ~PST_ASSIGNOK;
2926 peek_char = shell_getc (1);
2927 if (character == peek_char)
2932 /* If '<' then we could be at "<<" or at "<<-". We have to
2933 look ahead one more character. */
2934 peek_char = shell_getc (1);
2935 if MBTEST(peek_char == '-')
2936 return (LESS_LESS_MINUS);
2937 else if MBTEST(peek_char == '<')
2938 return (LESS_LESS_LESS);
2941 shell_ungetc (peek_char);
2946 return (GREATER_GREATER);
2949 parser_state |= PST_CASEPAT;
2951 parser_state &= ~PST_ALEXPNEXT;
2954 peek_char = shell_getc (1);
2955 if MBTEST(peek_char == '&')
2956 return (SEMI_SEMI_AND);
2959 shell_ungetc (peek_char);
2969 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
2971 result = parse_dparen (character);
2979 else if MBTEST(character == '<' && peek_char == '&')
2981 else if MBTEST(character == '>' && peek_char == '&')
2982 return (GREATER_AND);
2983 else if MBTEST(character == '<' && peek_char == '>')
2984 return (LESS_GREATER);
2985 else if MBTEST(character == '>' && peek_char == '|')
2986 return (GREATER_BAR);
2987 else if MBTEST(character == '&' && peek_char == '>')
2989 peek_char = shell_getc (1);
2990 if MBTEST(peek_char == '>')
2991 return (AND_GREATER_GREATER);
2994 shell_ungetc (peek_char);
2995 return (AND_GREATER);
2998 else if MBTEST(character == '|' && peek_char == '&')
3000 else if MBTEST(character == ';' && peek_char == '&')
3002 parser_state |= PST_CASEPAT;
3004 parser_state &= ~PST_ALEXPNEXT;
3009 shell_ungetc (peek_char);
3011 /* If we look like we are reading the start of a function
3012 definition, then let the reader know about it so that
3013 we will do the right thing with `{'. */
3014 if MBTEST(character == ')' && last_read_token == '(' && token_before_that == WORD)
3016 parser_state |= PST_ALLOWOPNBRC;
3018 parser_state &= ~PST_ALEXPNEXT;
3020 function_dstart = line_number;
3023 /* case pattern lists may be preceded by an optional left paren. If
3024 we're not trying to parse a case pattern list, the left paren
3025 indicates a subshell. */
3026 if MBTEST(character == '(' && (parser_state & PST_CASEPAT) == 0) /* ) */
3027 parser_state |= PST_SUBSHELL;
3029 else if MBTEST((parser_state & PST_CASEPAT) && character == ')')
3030 parser_state &= ~PST_CASEPAT;
3032 else if MBTEST((parser_state & PST_SUBSHELL) && character == ')')
3033 parser_state &= ~PST_SUBSHELL;
3035 #if defined (PROCESS_SUBSTITUTION)
3036 /* Check for the constructs which introduce process substitution.
3037 Shells running in `posix mode' don't do process substitution. */
3038 if MBTEST(posixly_correct || ((character != '>' && character != '<') || peek_char != '(')) /*)*/
3039 #endif /* PROCESS_SUBSTITUTION */
3043 /* Hack <&- (close stdin) case. Also <&N- (dup and close). */
3044 if MBTEST(character == '-' && (last_read_token == LESS_AND || last_read_token == GREATER_AND))
3048 /* Okay, if we got this far, we have to read a word. Read one,
3049 and then check it against the known ones. */
3050 result = read_token_word (character);
3052 if (result == RE_READ_TOKEN)
3059 * Match a $(...) or other grouping construct. This has to handle embedded
3060 * quoted strings ('', ``, "") and nested constructs. It also must handle
3061 * reprompting the user, if necessary, after reading a newline, and returning
3062 * correct error values if it reads EOF.
3064 #define P_FIRSTCLOSE 0x01
3065 #define P_ALLOWESC 0x02
3066 #define P_DQUOTE 0x04
3067 #define P_COMMAND 0x08 /* parsing a command, so look for comments */
3068 #define P_BACKQUOTE 0x10 /* parsing a backquoted command substitution */
3069 #define P_ARRAYSUB 0x20 /* parsing a [...] array subscript for assignment */
3071 /* Lexical state while parsing a grouping construct or $(...). */
3072 #define LEX_WASDOL 0x001
3073 #define LEX_CKCOMMENT 0x002
3074 #define LEX_INCOMMENT 0x004
3075 #define LEX_PASSNEXT 0x008
3076 #define LEX_RESWDOK 0x010
3077 #define LEX_CKCASE 0x020
3078 #define LEX_INCASE 0x040
3079 #define LEX_INHEREDOC 0x080
3080 #define LEX_HEREDELIM 0x100 /* reading here-doc delimiter */
3081 #define LEX_STRIPDOC 0x200 /* <<- strip tabs from here doc delim */
3082 #define LEX_INWORD 0x400
3084 #define COMSUB_META(ch) ((ch) == ';' || (ch) == '&' || (ch) == '|')
3086 #define CHECK_NESTRET_ERROR() \
3088 if (nestret == &matched_pair_error) \
3091 return &matched_pair_error; \
3095 #define APPEND_NESTRET() \
3099 RESIZE_MALLOCED_BUFFER (ret, retind, nestlen, retsize, 64); \
3100 strcpy (ret + retind, nestret); \
3101 retind += nestlen; \
3105 static char matched_pair_error;
3108 parse_matched_pair (qc, open, close, lenp, flags)
3109 int qc; /* `"' if this construct is within double quotes */
3113 int count, ch, tflags;
3114 int nestlen, ttranslen, start_lineno;
3115 char *ret, *nestret, *ttrans;
3116 int retind, retsize, rflags;
3118 /*itrace("parse_matched_pair[%d]: open = %c close = %c flags = %d", line_number, open, close, flags);*/
3122 if ((flags & P_COMMAND) && qc != '`' && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3123 tflags |= LEX_CKCOMMENT;
3125 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3126 rflags = (qc == '"') ? P_DQUOTE : (flags & P_DQUOTE);
3128 ret = (char *)xmalloc (retsize = 64);
3131 start_lineno = line_number;
3134 ch = shell_getc (qc != '\'' && (tflags & LEX_PASSNEXT) == 0);
3139 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3140 EOF_Reached = 1; /* XXX */
3141 return (&matched_pair_error);
3144 /* Possible reprompting. */
3145 if (ch == '\n' && SHOULD_PROMPT ())
3148 /* Don't bother counting parens or doing anything else if in a comment
3149 or part of a case statement */
3150 if (tflags & LEX_INCOMMENT)
3152 /* Add this character. */
3153 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3157 tflags &= ~LEX_INCOMMENT;
3162 /* Not exactly right yet, should handle shell metacharacters, too. If
3163 any changes are made to this test, make analogous changes to subst.c:
3164 extract_delimited_string(). */
3165 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (retind == 0 || ret[retind-1] == '\n' || shellblank (ret[retind - 1])))
3166 tflags |= LEX_INCOMMENT;
3168 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3170 tflags &= ~LEX_PASSNEXT;
3171 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3174 retind--; /* swallow previously-added backslash */
3178 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3179 if MBTEST(ch == CTLESC || ch == CTLNUL)
3180 ret[retind++] = CTLESC;
3184 /* If we're reparsing the input (e.g., from parse_string_to_word_list),
3185 we've already prepended CTLESC to single-quoted results of $'...'.
3186 We may want to do this for other CTLESC-quoted characters in
3188 else if MBTEST((parser_state & PST_REPARSE) && open == '\'' && (ch == CTLESC || ch == CTLNUL))
3190 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3194 else if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3196 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3197 ret[retind++] = CTLESC;
3201 else if MBTEST(ch == close) /* ending delimiter */
3203 /* handle nested ${...} specially. */
3204 else if MBTEST(open != close && (tflags & LEX_WASDOL) && open == '{' && ch == open) /* } */
3206 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && ch == open) /* nested begin */
3209 /* Add this character. */
3210 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3213 /* If we just read the ending character, don't bother continuing. */
3217 if (open == '\'') /* '' inside grouping construct */
3219 if MBTEST((flags & P_ALLOWESC) && ch == '\\')
3220 tflags |= LEX_PASSNEXT;
3224 if MBTEST(ch == '\\') /* backslashes */
3225 tflags |= LEX_PASSNEXT;
3228 /* The big hammer. Single quotes aren't special in double quotes. The
3229 problem is that Posix says the single quotes are semi-special:
3230 within a double-quoted ${...} construct "an even number of
3231 unescaped double-quotes or single-quotes, if any, shall occur." */
3232 if MBTEST(open == '{' && (flags & P_DQUOTE) && ch == '\'') /* } */
3236 /* Could also check open == '`' if we want to parse grouping constructs
3237 inside old-style command substitution. */
3238 if (open != close) /* a grouping construct */
3240 if MBTEST(shellquote (ch))
3242 /* '', ``, or "" inside $(...) or other grouping construct. */
3243 push_delimiter (dstack, ch);
3244 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3245 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3247 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3248 pop_delimiter (dstack);
3249 CHECK_NESTRET_ERROR ();
3251 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3253 /* Translate $'...' here. */
3254 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3257 if ((rflags & P_DQUOTE) == 0)
3259 nestret = sh_single_quote (ttrans);
3261 nestlen = strlen (nestret);
3266 nestlen = ttranslen;
3268 retind -= 2; /* back up before the $' */
3270 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3272 /* Locale expand $"..." here. */
3273 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3276 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3278 nestlen = ttranslen + 2;
3279 retind -= 2; /* back up before the $" */
3285 else if ((flags & P_ARRAYSUB) && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3286 goto parse_dollar_word;
3288 /* Parse an old-style command substitution within double quotes as a
3290 /* XXX - sh and ksh93 don't do this - XXX */
3291 else if MBTEST(open == '"' && ch == '`')
3293 nestret = parse_matched_pair (0, '`', '`', &nestlen, rflags);
3295 CHECK_NESTRET_ERROR ();
3300 else if MBTEST(open != '`' && (tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3301 /* check for $(), $[], or ${} inside quoted string. */
3304 if (open == ch) /* undo previous increment */
3306 if (ch == '(') /* ) */
3307 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3308 else if (ch == '{') /* } */
3309 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
3310 else if (ch == '[') /* ] */
3311 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3313 CHECK_NESTRET_ERROR ();
3318 if MBTEST(ch == '$')
3319 tflags |= LEX_WASDOL;
3321 tflags &= ~LEX_WASDOL;
3327 /*itrace("parse_matched_pair[%d]: returning %s", line_number, ret);*/
3331 /* Parse a $(...) command substitution. This is messier than I'd like, and
3332 reproduces a lot more of the token-reading code than I'd like. */
3334 parse_comsub (qc, open, close, lenp, flags)
3335 int qc; /* `"' if this construct is within double quotes */
3339 int count, ch, peekc, tflags, lex_rwlen, lex_wlen, lex_firstind;
3340 int nestlen, ttranslen, start_lineno;
3341 char *ret, *nestret, *ttrans, *heredelim;
3342 int retind, retsize, rflags, hdlen;
3344 #if 0 /* XXX - bash-4.2 -- jwm@horde.net */
3345 /* Assume $(( introduces arithmetic command and parse accordingly. */
3346 peekc = shell_getc (0);
3347 shell_ungetc (peekc);
3349 return (parse_matched_pair (qc, open, close, lenp, 0));
3352 /*itrace("parse_comsub: qc = `%c' open = %c close = %c", qc, open, close);*/
3354 tflags = LEX_RESWDOK;
3356 if ((flags & P_COMMAND) && qc != '\'' && qc != '"' && (flags & P_DQUOTE) == 0)
3357 tflags |= LEX_CKCASE;
3358 if ((tflags & LEX_CKCASE) && (interactive == 0 || interactive_comments))
3359 tflags |= LEX_CKCOMMENT;
3361 /* RFLAGS is the set of flags we want to pass to recursive calls. */
3362 rflags = (flags & P_DQUOTE);
3364 ret = (char *)xmalloc (retsize = 64);
3367 start_lineno = line_number;
3368 lex_rwlen = lex_wlen = 0;
3376 ch = shell_getc (qc != '\'' && (tflags & LEX_PASSNEXT) == 0);
3383 parser_error (start_lineno, _("unexpected EOF while looking for matching `%c'"), close);
3384 EOF_Reached = 1; /* XXX */
3385 return (&matched_pair_error);
3388 /* If we hit the end of a line and are reading the contents of a here
3389 document, and it's not the same line that the document starts on,
3390 check for this line being the here doc delimiter. Otherwise, if
3391 we're in a here document, mark the next character as the beginning
3395 if ((tflags & LEX_HEREDELIM) && heredelim)
3397 tflags &= ~LEX_HEREDELIM;
3398 tflags |= LEX_INHEREDOC;
3399 lex_firstind = retind + 1;
3401 else if (tflags & LEX_INHEREDOC)
3404 tind = lex_firstind;
3405 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3407 if (STREQN (ret + tind, heredelim, hdlen))
3409 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3410 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3416 lex_firstind = retind + 1;
3420 /* Possible reprompting. */
3421 if (ch == '\n' && SHOULD_PROMPT ())
3424 /* XXX -- possibly allow here doc to be delimited by ending right
3426 if ((tflags & LEX_INHEREDOC) && ch == close && count == 1)
3429 /*itrace("parse_comsub: in here doc, ch == close, retind - firstind = %d hdlen = %d retind = %d", retind-lex_firstind, hdlen, retind);*/
3430 tind = lex_firstind;
3431 while ((tflags & LEX_STRIPDOC) && ret[tind] == '\t')
3433 if (retind-tind == hdlen && STREQN (ret + tind, heredelim, hdlen))
3435 tflags &= ~(LEX_STRIPDOC|LEX_INHEREDOC);
3436 /*itrace("parse_comsub:%d: found here doc end `%s'", line_number, ret + tind);*/
3443 /* Don't bother counting parens or doing anything else if in a comment */
3444 if (tflags & (LEX_INCOMMENT|LEX_INHEREDOC))
3446 /* Add this character. */
3447 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3450 if ((tflags & LEX_INCOMMENT) && ch == '\n')
3452 /*itrace("parse_comsub:%d: lex_incomment -> 0 ch = `%c'", line_number, ch);*/
3453 tflags &= ~LEX_INCOMMENT;
3459 if (tflags & LEX_PASSNEXT) /* last char was backslash */
3461 /*itrace("parse_comsub:%d: lex_passnext -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3462 tflags &= ~LEX_PASSNEXT;
3463 if (qc != '\'' && ch == '\n') /* double-quoted \<newline> disappears. */
3466 retind--; /* swallow previously-added backslash */
3470 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3471 if MBTEST(ch == CTLESC || ch == CTLNUL)
3472 ret[retind++] = CTLESC;
3477 /* If this is a shell break character, we are not in a word. If not,
3478 we either start or continue a word. */
3479 if MBTEST(shellbreak (ch))
3481 tflags &= ~LEX_INWORD;
3482 /*itrace("parse_comsub:%d: lex_inword -> 0 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3486 if (tflags & LEX_INWORD)
3489 /*itrace("parse_comsub:%d: lex_inword == 1 ch = `%c' lex_wlen = %d (%d)", line_number, ch, lex_wlen, __LINE__);*/
3493 /*itrace("parse_comsub:%d: lex_inword -> 1 ch = `%c' (%d)", line_number, ch, __LINE__);*/
3494 tflags |= LEX_INWORD;
3499 /* Skip whitespace */
3500 if MBTEST(shellblank (ch) && lex_rwlen == 0)
3502 /* Add this character. */
3503 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3508 /* Either we are looking for the start of the here-doc delimiter
3509 (lex_firstind == -1) or we are reading one (lex_firstind >= 0).
3510 If this character is a shell break character and we are reading
3511 the delimiter, save it and note that we are now reading a here
3512 document. If we've found the start of the delimiter, note it by
3513 setting lex_firstind. Backslashes can quote shell metacharacters
3514 in here-doc delimiters. */
3515 if (tflags & LEX_HEREDELIM)
3517 if (lex_firstind == -1 && shellbreak (ch) == 0)
3518 lex_firstind = retind;
3520 else if (heredelim && (tflags & LEX_PASSNEXT) == 0 && ch == '\n')
3522 tflags |= LEX_INHEREDOC;
3523 tflags &= ~LEX_HEREDELIM;
3524 lex_firstind = retind + 1;
3527 else if (lex_firstind >= 0 && (tflags & LEX_PASSNEXT) == 0 && shellbreak (ch))
3531 nestret = substring (ret, lex_firstind, retind);
3532 heredelim = string_quote_removal (nestret, 0);
3534 hdlen = STRLEN(heredelim);
3535 /*itrace("parse_comsub:%d: found here doc delimiter `%s' (%d)", line_number, heredelim, hdlen);*/
3539 tflags |= LEX_INHEREDOC;
3540 tflags &= ~LEX_HEREDELIM;
3541 lex_firstind = retind + 1;
3548 /* Meta-characters that can introduce a reserved word. Not perfect yet. */
3549 if MBTEST((tflags & LEX_RESWDOK) == 0 && (tflags & LEX_CKCASE) && (tflags & LEX_INCOMMENT) == 0 && (shellmeta(ch) || ch == '\n'))
3551 /* Add this character. */
3552 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3554 peekc = shell_getc (1);
3555 if (ch == peekc && (ch == '&' || ch == '|' || ch == ';')) /* two-character tokens */
3557 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3558 ret[retind++] = peekc;
3559 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3560 tflags |= LEX_RESWDOK;
3564 else if (ch == '\n' || COMSUB_META(ch))
3566 shell_ungetc (peekc);
3567 /*itrace("parse_comsub:%d: set lex_reswordok = 1, ch = `%c'", line_number, ch);*/
3568 tflags |= LEX_RESWDOK;
3576 /* `unget' the character we just added and fall through */
3578 shell_ungetc (peekc);
3582 /* If we can read a reserved word, try to read one. */
3583 if (tflags & LEX_RESWDOK)
3585 if MBTEST(islower (ch))
3587 /* Add this character. */
3588 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3593 else if MBTEST(lex_rwlen == 4 && shellbreak (ch))
3595 if (STREQN (ret + retind - 4, "case", 4))
3597 tflags |= LEX_INCASE;
3598 /*itrace("parse_comsub:%d: found `case', lex_incase -> 1 lex_reswdok -> 0", line_number);*/
3600 else if (STREQN (ret + retind - 4, "esac", 4))
3602 tflags &= ~LEX_INCASE;
3603 /*itrace("parse_comsub:%d: found `esac', lex_incase -> 0 lex_reswdok -> 0", line_number);*/
3605 tflags &= ~LEX_RESWDOK;
3607 else if MBTEST((tflags & LEX_CKCOMMENT) && ch == '#' && (lex_rwlen == 0 || ((tflags & LEX_INWORD) && lex_wlen == 0)))
3608 ; /* don't modify LEX_RESWDOK if we're starting a comment */
3609 else if MBTEST((tflags & LEX_INCASE) && ch != '\n')
3610 /* If we can read a reserved word and we're in case, we're at the
3611 point where we can read a new pattern list or an esac. We
3612 handle the esac case above. If we read a newline, we want to
3613 leave LEX_RESWDOK alone. If we read anything else, we want to
3614 turn off LEX_RESWDOK, since we're going to read a pattern list. */
3616 tflags &= ~LEX_RESWDOK;
3617 /*itrace("parse_comsub:%d: lex_incase == 1 found `%c', lex_reswordok -> 0", line_number, ch);*/
3619 else if MBTEST(shellbreak (ch) == 0)
3621 tflags &= ~LEX_RESWDOK;
3622 /*itrace("parse_comsub:%d: found `%c', lex_reswordok -> 0", line_number, ch);*/
3626 /* Might be the start of a here-doc delimiter */
3627 if MBTEST((tflags & LEX_INCOMMENT) == 0 && (tflags & LEX_CKCASE) && ch == '<')
3629 /* Add this character. */
3630 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3632 peekc = shell_getc (1);
3637 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3638 ret[retind++] = peekc;
3639 peekc = shell_getc (1);
3644 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3645 ret[retind++] = peekc;
3646 tflags |= LEX_STRIPDOC;
3649 shell_ungetc (peekc);
3652 tflags |= LEX_HEREDELIM;
3658 ch = peekc; /* fall through and continue XXX */
3660 else if MBTEST((tflags & LEX_CKCOMMENT) && (tflags & LEX_INCOMMENT) == 0 && ch == '#' && (((tflags & LEX_RESWDOK) && lex_rwlen == 0) || ((tflags & LEX_INWORD) && lex_wlen == 0)))
3662 /*itrace("parse_comsub:%d: lex_incomment -> 1 (%d)", line_number, __LINE__);*/
3663 tflags |= LEX_INCOMMENT;
3666 if MBTEST(ch == CTLESC || ch == CTLNUL) /* special shell escapes */
3668 RESIZE_MALLOCED_BUFFER (ret, retind, 2, retsize, 64);
3669 ret[retind++] = CTLESC;
3674 else if MBTEST((tflags & LEX_INCASE) && ch == close && close == ')')
3675 tflags &= ~LEX_INCASE; /* XXX */
3677 else if MBTEST(ch == close && (tflags & LEX_INCASE) == 0) /* ending delimiter */
3680 /*itrace("parse_comsub:%d: found close: count = %d", line_number, count);*/
3682 else if MBTEST(((flags & P_FIRSTCLOSE) == 0) && (tflags & LEX_INCASE) == 0 && ch == open) /* nested begin */
3685 /*itrace("parse_comsub:%d: found open: count = %d", line_number, count);*/
3688 /* Add this character. */
3689 RESIZE_MALLOCED_BUFFER (ret, retind, 1, retsize, 64);
3692 /* If we just read the ending character, don't bother continuing. */
3696 if MBTEST(ch == '\\') /* backslashes */
3697 tflags |= LEX_PASSNEXT;
3699 if MBTEST(shellquote (ch))
3701 /* '', ``, or "" inside $(...). */
3702 push_delimiter (dstack, ch);
3703 if MBTEST((tflags & LEX_WASDOL) && ch == '\'') /* $'...' inside group */
3704 nestret = parse_matched_pair (ch, ch, ch, &nestlen, P_ALLOWESC|rflags);
3706 nestret = parse_matched_pair (ch, ch, ch, &nestlen, rflags);
3707 pop_delimiter (dstack);
3708 CHECK_NESTRET_ERROR ();
3710 if MBTEST((tflags & LEX_WASDOL) && ch == '\'' && (extended_quote || (rflags & P_DQUOTE) == 0))
3712 /* Translate $'...' here. */
3713 ttrans = ansiexpand (nestret, 0, nestlen - 1, &ttranslen);
3716 if ((rflags & P_DQUOTE) == 0)
3718 nestret = sh_single_quote (ttrans);
3720 nestlen = strlen (nestret);
3725 nestlen = ttranslen;
3727 retind -= 2; /* back up before the $' */
3729 else if MBTEST((tflags & LEX_WASDOL) && ch == '"' && (extended_quote || (rflags & P_DQUOTE) == 0))
3731 /* Locale expand $"..." here. */
3732 ttrans = localeexpand (nestret, 0, nestlen - 1, start_lineno, &ttranslen);
3735 nestret = sh_mkdoublequoted (ttrans, ttranslen, 0);
3737 nestlen = ttranslen + 2;
3738 retind -= 2; /* back up before the $" */
3744 else if MBTEST((tflags & LEX_WASDOL) && (ch == '(' || ch == '{' || ch == '[')) /* ) } ] */
3745 /* check for $(), $[], or ${} inside command substitution. */
3747 if ((tflags & LEX_INCASE) == 0 && open == ch) /* undo previous increment */
3749 if (ch == '(') /* ) */
3750 nestret = parse_comsub (0, '(', ')', &nestlen, (rflags|P_COMMAND) & ~P_DQUOTE);
3751 else if (ch == '{') /* } */
3752 nestret = parse_matched_pair (0, '{', '}', &nestlen, P_FIRSTCLOSE|rflags);
3753 else if (ch == '[') /* ] */
3754 nestret = parse_matched_pair (0, '[', ']', &nestlen, rflags);
3756 CHECK_NESTRET_ERROR ();
3761 if MBTEST(ch == '$')
3762 tflags |= LEX_WASDOL;
3764 tflags &= ~LEX_WASDOL;
3771 /*itrace("parse_comsub:%d: returning `%s'", line_number, ret);*/
3775 /* XXX - this needs to handle functionality like subst.c:no_longjmp_on_fatal_error;
3776 maybe extract_command_subst should handle it. */
3778 xparse_dolparen (base, string, indp, flags)
3784 sh_parser_state_t ps;
3785 int orig_ind, nc, sflags;
3786 char *ret, *s, *ep, *ostring;
3792 sflags = SEVAL_NONINT|SEVAL_NOHIST|SEVAL_NOFREE;
3793 if (flags & SX_NOLONGJMP)
3794 sflags |= SEVAL_NOLONGJMP;
3795 save_parser_state (&ps);
3798 parser_state |= PST_CMDSUBST|PST_EOFTOKEN; /* allow instant ')' */ /*(*/
3799 shell_eof_token = ')';
3800 parse_string (string, "command substitution", sflags, &ep);
3802 restore_parser_state (&ps);
3807 /* Need to find how many characters parse_and_execute consumed, update
3808 *indp, if flags != 0, copy the portion of the string parsed into RET
3809 and return it. If flags & 1 (EX_NOALLOC) we can return NULL. */
3816 itrace("xparse_dolparen:%d: ep[-1] != RPAREN (%d), ep = `%s'", line_number, ep[-1], ep);
3818 while (ep > ostring && ep[-1] == '\n') ep--;
3822 *indp = ep - base - 1;
3826 if (base[*indp] != ')')
3827 itrace("xparse_dolparen:%d: base[%d] != RPAREN (%d), base = `%s'", line_number, *indp, base[*indp], base);
3830 if (flags & SX_NOALLOC)
3831 return (char *)NULL;
3839 ret = substring (ostring, 0, nc - 1);
3844 #if defined (DPAREN_ARITHMETIC) || defined (ARITH_FOR_COMMAND)
3845 /* Parse a double-paren construct. It can be either an arithmetic
3846 command, an arithmetic `for' command, or a nested subshell. Returns
3847 the parsed token, -1 on error, or -2 if we didn't do anything and
3848 should just go on. */
3857 #if defined (ARITH_FOR_COMMAND)
3858 if (last_read_token == FOR)
3860 arith_for_lineno = line_number;
3861 cmdtyp = parse_arith_cmd (&wval, 0);
3864 wd = alloc_word_desc ();
3866 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3867 return (ARITH_FOR_EXPRS);
3870 return -1; /* ERROR */
3874 #if defined (DPAREN_ARITHMETIC)
3875 if (reserved_word_acceptable (last_read_token))
3877 sline = line_number;
3879 cmdtyp = parse_arith_cmd (&wval, 0);
3880 if (cmdtyp == 1) /* arithmetic command */
3882 wd = alloc_word_desc ();
3884 wd->flags = W_QUOTED|W_NOSPLIT|W_NOGLOB|W_DQUOTE;
3885 yylval.word_list = make_word_list (wd, (WORD_LIST *)NULL);
3888 else if (cmdtyp == 0) /* nested subshell */
3890 push_string (wval, 0, (alias_t *)NULL);
3891 if ((parser_state & PST_CASEPAT) == 0)
3892 parser_state |= PST_SUBSHELL;
3900 return -2; /* XXX */
3903 /* We've seen a `(('. Look for the matching `))'. If we get it, return 1.
3904 If not, assume it's a nested subshell for backwards compatibility and
3905 return 0. In any case, put the characters we've consumed into a locally-
3906 allocated buffer and make *ep point to that buffer. Return -1 on an
3907 error, for example EOF. */
3909 parse_arith_cmd (ep, adddq)
3913 int exp_lineno, rval, c;
3914 char *ttok, *tokstr;
3917 exp_lineno = line_number;
3918 ttok = parse_matched_pair (0, '(', ')', &ttoklen, 0);
3920 if (ttok == &matched_pair_error)
3922 /* Check that the next character is the closing right paren. If
3923 not, this is a syntax error. ( */
3928 tokstr = (char *)xmalloc (ttoklen + 4);
3930 /* if ADDDQ != 0 then (( ... )) -> "..." */
3931 if (rval == 1 && adddq) /* arith cmd, add double quotes */
3934 strncpy (tokstr + 1, ttok, ttoklen - 1);
3935 tokstr[ttoklen] = '"';
3936 tokstr[ttoklen+1] = '\0';
3938 else if (rval == 1) /* arith cmd, don't add double quotes */
3940 strncpy (tokstr, ttok, ttoklen - 1);
3941 tokstr[ttoklen-1] = '\0';
3943 else /* nested subshell */
3946 strncpy (tokstr + 1, ttok, ttoklen - 1);
3947 tokstr[ttoklen] = ')';
3948 tokstr[ttoklen+1] = c;
3949 tokstr[ttoklen+2] = '\0';
3956 #endif /* DPAREN_ARITHMETIC || ARITH_FOR_COMMAND */
3958 #if defined (COND_COMMAND)
3964 if (EOF_Reached && cond_token != COND_ERROR) /* [[ */
3965 parser_error (cond_lineno, _("unexpected EOF while looking for `]]'"));
3966 else if (cond_token != COND_ERROR)
3968 if (etext = error_token_from_token (cond_token))
3970 parser_error (cond_lineno, _("syntax error in conditional expression: unexpected token `%s'"), etext);
3974 parser_error (cond_lineno, _("syntax error in conditional expression"));
3981 return (cond_or ());
3990 if (cond_token == OR_OR)
3993 l = make_cond_node (COND_OR, (WORD_DESC *)NULL, l, r);
4004 if (cond_token == AND_AND)
4007 l = make_cond_node (COND_AND, (WORD_DESC *)NULL, l, r);
4013 cond_skip_newlines ()
4015 while ((cond_token = read_token (READ)) == '\n')
4017 if (SHOULD_PROMPT ())
4020 return (cond_token);
4023 #define COND_RETURN_ERROR() \
4024 do { cond_token = COND_ERROR; return ((COND_COM *)NULL); } while (0)
4030 COND_COM *term, *tleft, *tright;
4034 /* Read a token. It can be a left paren, a `!', a unary operator, or a
4035 word that should be the first argument of a binary operator. Start by
4036 skipping newlines, since this is a compound command. */
4037 tok = cond_skip_newlines ();
4038 lineno = line_number;
4039 if (tok == COND_END)
4041 COND_RETURN_ERROR ();
4043 else if (tok == '(')
4045 term = cond_expr ();
4046 if (cond_token != ')')
4049 dispose_cond_node (term); /* ( */
4050 if (etext = error_token_from_token (cond_token))
4052 parser_error (lineno, _("unexpected token `%s', expected `)'"), etext);
4056 parser_error (lineno, _("expected `)'"));
4057 COND_RETURN_ERROR ();
4059 term = make_cond_node (COND_EXPR, (WORD_DESC *)NULL, term, (COND_COM *)NULL);
4060 (void)cond_skip_newlines ();
4062 else if (tok == BANG || (tok == WORD && (yylval.word->word[0] == '!' && yylval.word->word[1] == '\0')))
4065 dispose_word (yylval.word); /* not needed */
4066 term = cond_term ();
4068 term->flags |= CMD_INVERT_RETURN;
4070 else if (tok == WORD && yylval.word->word[0] == '-' && yylval.word->word[2] == 0 && test_unop (yylval.word->word))
4073 tok = read_token (READ);
4076 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4077 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4082 if (etext = error_token_from_token (tok))
4084 parser_error (line_number, _("unexpected argument `%s' to conditional unary operator"), etext);
4088 parser_error (line_number, _("unexpected argument to conditional unary operator"));
4089 COND_RETURN_ERROR ();
4092 (void)cond_skip_newlines ();
4094 else if (tok == WORD) /* left argument to binary operator */
4097 tleft = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4100 tok = read_token (READ);
4101 if (tok == WORD && test_binop (yylval.word->word))
4104 if (op->word[0] == '=' && (op->word[1] == '\0' || (op->word[1] == '=' && op->word[2] == '\0')))
4105 parser_state |= PST_EXTPAT;
4106 else if (op->word[0] == '!' && op->word[1] == '=' && op->word[2] == '\0')
4107 parser_state |= PST_EXTPAT;
4109 #if defined (COND_REGEXP)
4110 else if (tok == WORD && STREQ (yylval.word->word, "=~"))
4113 parser_state |= PST_REGEXP;
4116 else if (tok == '<' || tok == '>')
4117 op = make_word_from_token (tok); /* ( */
4118 /* There should be a check before blindly accepting the `)' that we have
4119 seen the opening `('. */
4120 else if (tok == COND_END || tok == AND_AND || tok == OR_OR || tok == ')')
4122 /* Special case. [[ x ]] is equivalent to [[ -n x ]], just like
4123 the test command. Similarly for [[ x && expr ]] or
4124 [[ x || expr ]] or [[ (x) ]]. */
4125 op = make_word ("-n");
4126 term = make_cond_node (COND_UNARY, op, tleft, (COND_COM *)NULL);
4132 if (etext = error_token_from_token (tok))
4134 parser_error (line_number, _("unexpected token `%s', conditional binary operator expected"), etext);
4138 parser_error (line_number, _("conditional binary operator expected"));
4139 dispose_cond_node (tleft);
4140 COND_RETURN_ERROR ();
4144 if (parser_state & PST_EXTPAT)
4146 tok = read_token (READ);
4147 if (parser_state & PST_EXTPAT)
4148 extended_glob = global_extglob;
4149 parser_state &= ~(PST_REGEXP|PST_EXTPAT);
4153 tright = make_cond_node (COND_TERM, yylval.word, (COND_COM *)NULL, (COND_COM *)NULL);
4154 term = make_cond_node (COND_BINARY, op, tleft, tright);
4158 if (etext = error_token_from_token (tok))
4160 parser_error (line_number, _("unexpected argument `%s' to conditional binary operator"), etext);
4164 parser_error (line_number, _("unexpected argument to conditional binary operator"));
4165 dispose_cond_node (tleft);
4167 COND_RETURN_ERROR ();
4170 (void)cond_skip_newlines ();
4175 parser_error (line_number, _("unexpected token `%c' in conditional command"), tok);
4176 else if (etext = error_token_from_token (tok))
4178 parser_error (line_number, _("unexpected token `%s' in conditional command"), etext);
4182 parser_error (line_number, _("unexpected token %d in conditional command"), tok);
4183 COND_RETURN_ERROR ();
4188 /* This is kind of bogus -- we slip a mini recursive-descent parser in
4189 here to handle the conditional statement syntax. */
4191 parse_cond_command ()
4195 global_extglob = extended_glob;
4196 cexp = cond_expr ();
4197 return (make_cond_command (cexp));
4201 #if defined (ARRAY_VARS)
4202 /* When this is called, it's guaranteed that we don't care about anything
4203 in t beyond i. We do save and restore the chars, though. */
4205 token_is_assignment (t, i)
4209 unsigned char c, c1;
4212 c = t[i]; c1 = t[i+1];
4213 t[i] = '='; t[i+1] = '\0';
4214 r = assignment (t, (parser_state & PST_COMPASSIGN) != 0);
4215 t[i] = c; t[i+1] = c1;
4219 /* XXX - possible changes here for `+=' */
4221 token_is_ident (t, i)
4230 r = legal_identifier (t);
4237 read_token_word (character)
4240 /* The value for YYLVAL when a WORD is read. */
4241 WORD_DESC *the_word;
4243 /* Index into the token that we are building. */
4246 /* ALL_DIGITS becomes zero when we see a non-digit. */
4247 int all_digit_token;
4249 /* DOLLAR_PRESENT becomes non-zero if we see a `$'. */
4252 /* COMPOUND_ASSIGNMENT becomes non-zero if we are parsing a compound
4254 int compound_assignment;
4256 /* QUOTED becomes non-zero if we see one of ("), ('), (`), or (\). */
4259 /* Non-zero means to ignore the value of the next character, and just
4260 to add it no matter what. */
4261 int pass_next_character;
4263 /* The current delimiting character. */
4265 int result, peek_char;
4266 char *ttok, *ttrans;
4267 int ttoklen, ttranslen;
4270 if (token_buffer_size < TOKEN_DEFAULT_INITIAL_SIZE)
4271 token = (char *)xrealloc (token, token_buffer_size = TOKEN_DEFAULT_INITIAL_SIZE);
4274 all_digit_token = DIGIT (character);
4275 dollar_present = quoted = pass_next_character = compound_assignment = 0;
4279 if (character == EOF)
4282 if (pass_next_character)
4284 pass_next_character = 0;
4285 goto got_escaped_character;
4288 cd = current_delimiter (dstack);
4290 /* Handle backslashes. Quote lots of things when not inside of
4291 double-quotes, quote some things inside of double-quotes. */
4292 if MBTEST(character == '\\')
4294 peek_char = shell_getc (0);
4296 /* Backslash-newline is ignored in all cases except
4297 when quoted with single quotes. */
4298 if (peek_char == '\n')
4301 goto next_character;
4305 shell_ungetc (peek_char);
4307 /* If the next character is to be quoted, note it now. */
4308 if (cd == 0 || cd == '`' ||
4309 (cd == '"' && peek_char >= 0 && (sh_syntaxtab[peek_char] & CBSDQUOTE)))
4310 pass_next_character++;
4317 /* Parse a matched pair of quote characters. */
4318 if MBTEST(shellquote (character))
4320 push_delimiter (dstack, character);
4321 ttok = parse_matched_pair (character, character, character, &ttoklen, (character == '`') ? P_COMMAND : 0);
4322 pop_delimiter (dstack);
4323 if (ttok == &matched_pair_error)
4324 return -1; /* Bail immediately. */
4325 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4326 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4327 token[token_index++] = character;
4328 strcpy (token + token_index, ttok);
4329 token_index += ttoklen;
4330 all_digit_token = 0;
4332 dollar_present |= (character == '"' && strchr (ttok, '$') != 0);
4334 goto next_character;
4338 /* When parsing a regexp as a single word inside a conditional command,
4339 we need to special-case characters special to both the shell and
4340 regular expressions. Right now, that is only '(' and '|'. */ /*)*/
4341 if MBTEST((parser_state & PST_REGEXP) && (character == '(' || character == '|')) /*)*/
4343 if (character == '|')
4346 push_delimiter (dstack, character);
4347 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4348 pop_delimiter (dstack);
4349 if (ttok == &matched_pair_error)
4350 return -1; /* Bail immediately. */
4351 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4352 token_buffer_size, TOKEN_DEFAULT_GROW_SIZE);
4353 token[token_index++] = character;
4354 strcpy (token + token_index, ttok);
4355 token_index += ttoklen;
4357 dollar_present = all_digit_token = 0;
4358 goto next_character;
4360 #endif /* COND_REGEXP */
4362 #ifdef EXTENDED_GLOB
4363 /* Parse a ksh-style extended pattern matching specification. */
4364 if MBTEST(extended_glob && PATTERN_CHAR (character))
4366 peek_char = shell_getc (1);
4367 if MBTEST(peek_char == '(') /* ) */
4369 push_delimiter (dstack, peek_char);
4370 ttok = parse_matched_pair (cd, '(', ')', &ttoklen, 0);
4371 pop_delimiter (dstack);
4372 if (ttok == &matched_pair_error)
4373 return -1; /* Bail immediately. */
4374 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4376 TOKEN_DEFAULT_GROW_SIZE);
4377 token[token_index++] = character;
4378 token[token_index++] = peek_char;
4379 strcpy (token + token_index, ttok);
4380 token_index += ttoklen;
4382 dollar_present = all_digit_token = 0;
4383 goto next_character;
4386 shell_ungetc (peek_char);
4388 #endif /* EXTENDED_GLOB */
4390 /* If the delimiter character is not single quote, parse some of
4391 the shell expansions that must be read as a single word. */
4392 if (shellexp (character))
4394 peek_char = shell_getc (1);
4395 /* $(...), <(...), >(...), $((...)), ${...}, and $[...] constructs */
4396 if MBTEST(peek_char == '(' || \
4397 ((peek_char == '{' || peek_char == '[') && character == '$')) /* ) ] } */
4399 if (peek_char == '{') /* } */
4400 ttok = parse_matched_pair (cd, '{', '}', &ttoklen, P_FIRSTCLOSE);
4401 else if (peek_char == '(') /* ) */
4403 /* XXX - push and pop the `(' as a delimiter for use by
4404 the command-oriented-history code. This way newlines
4405 appearing in the $(...) string get added to the
4406 history literally rather than causing a possibly-
4407 incorrect `;' to be added. ) */
4408 push_delimiter (dstack, peek_char);
4409 ttok = parse_comsub (cd, '(', ')', &ttoklen, P_COMMAND);
4410 pop_delimiter (dstack);
4413 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, 0);
4414 if (ttok == &matched_pair_error)
4415 return -1; /* Bail immediately. */
4416 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4418 TOKEN_DEFAULT_GROW_SIZE);
4419 token[token_index++] = character;
4420 token[token_index++] = peek_char;
4421 strcpy (token + token_index, ttok);
4422 token_index += ttoklen;
4425 all_digit_token = 0;
4426 goto next_character;
4428 /* This handles $'...' and $"..." new-style quoted strings. */
4429 else if MBTEST(character == '$' && (peek_char == '\'' || peek_char == '"'))
4433 first_line = line_number;
4434 push_delimiter (dstack, peek_char);
4435 ttok = parse_matched_pair (peek_char, peek_char, peek_char,
4437 (peek_char == '\'') ? P_ALLOWESC : 0);
4438 pop_delimiter (dstack);
4439 if (ttok == &matched_pair_error)
4441 if (peek_char == '\'')
4443 ttrans = ansiexpand (ttok, 0, ttoklen - 1, &ttranslen);
4446 /* Insert the single quotes and correctly quote any
4447 embedded single quotes (allowed because P_ALLOWESC was
4448 passed to parse_matched_pair). */
4449 ttok = sh_single_quote (ttrans);
4451 ttranslen = strlen (ttok);
4456 /* Try to locale-expand the converted string. */
4457 ttrans = localeexpand (ttok, 0, ttoklen - 1, first_line, &ttranslen);
4460 /* Add the double quotes back */
4461 ttok = sh_mkdoublequoted (ttrans, ttranslen, 0);
4467 RESIZE_MALLOCED_BUFFER (token, token_index, ttranslen + 2,
4469 TOKEN_DEFAULT_GROW_SIZE);
4470 strcpy (token + token_index, ttrans);
4471 token_index += ttranslen;
4474 all_digit_token = 0;
4475 goto next_character;
4477 /* This could eventually be extended to recognize all of the
4478 shell's single-character parameter expansions, and set flags.*/
4479 else if MBTEST(character == '$' && peek_char == '$')
4481 ttok = (char *)xmalloc (3);
4482 ttok[0] = ttok[1] = '$';
4484 RESIZE_MALLOCED_BUFFER (token, token_index, 3,
4486 TOKEN_DEFAULT_GROW_SIZE);
4487 strcpy (token + token_index, ttok);
4490 all_digit_token = 0;
4492 goto next_character;
4495 shell_ungetc (peek_char);
4498 #if defined (ARRAY_VARS)
4499 /* Identify possible array subscript assignment; match [...]. If
4500 parser_state&PST_COMPASSIGN, we need to parse [sub]=words treating
4501 `sub' as if it were enclosed in double quotes. */
4502 else if MBTEST(character == '[' && /* ] */
4503 ((token_index > 0 && assignment_acceptable (last_read_token) && token_is_ident (token, token_index)) ||
4504 (token_index == 0 && (parser_state&PST_COMPASSIGN))))
4506 ttok = parse_matched_pair (cd, '[', ']', &ttoklen, P_ARRAYSUB);
4507 if (ttok == &matched_pair_error)
4508 return -1; /* Bail immediately. */
4509 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 2,
4511 TOKEN_DEFAULT_GROW_SIZE);
4512 token[token_index++] = character;
4513 strcpy (token + token_index, ttok);
4514 token_index += ttoklen;
4516 all_digit_token = 0;
4517 goto next_character;
4519 /* Identify possible compound array variable assignment. */
4520 else if MBTEST(character == '=' && token_index > 0 && (assignment_acceptable (last_read_token) || (parser_state & PST_ASSIGNOK)) && token_is_assignment (token, token_index))
4522 peek_char = shell_getc (1);
4523 if MBTEST(peek_char == '(') /* ) */
4525 ttok = parse_compound_assignment (&ttoklen);
4527 RESIZE_MALLOCED_BUFFER (token, token_index, ttoklen + 4,
4529 TOKEN_DEFAULT_GROW_SIZE);
4531 token[token_index++] = '=';
4532 token[token_index++] = '(';
4535 strcpy (token + token_index, ttok);
4536 token_index += ttoklen;
4538 token[token_index++] = ')';
4540 all_digit_token = 0;
4541 compound_assignment = 1;
4543 goto next_character;
4545 goto got_token; /* ksh93 seems to do this */
4549 shell_ungetc (peek_char);
4553 /* When not parsing a multi-character word construct, shell meta-
4554 characters break words. */
4555 if MBTEST(shellbreak (character))
4557 shell_ungetc (character);
4563 if (character == CTLESC || character == CTLNUL)
4564 token[token_index++] = CTLESC;
4566 got_escaped_character:
4568 all_digit_token &= DIGIT (character);
4569 dollar_present |= character == '$';
4571 token[token_index++] = character;
4573 RESIZE_MALLOCED_BUFFER (token, token_index, 1, token_buffer_size,
4574 TOKEN_DEFAULT_GROW_SIZE);
4577 if (character == '\n' && SHOULD_PROMPT ())
4580 /* We want to remove quoted newlines (that is, a \<newline> pair)
4581 unless we are within single quotes or pass_next_character is
4582 set (the shell equivalent of literal-next). */
4583 cd = current_delimiter (dstack);
4584 character = shell_getc (cd != '\'' && pass_next_character == 0);
4585 } /* end for (;;) */
4589 token[token_index] = '\0';
4591 /* Check to see what thing we should return. If the last_read_token
4592 is a `<', or a `&', or the character which ended this token is
4593 a '>' or '<', then, and ONLY then, is this input token a NUMBER.
4594 Otherwise, it is just a word, and should be returned as such. */
4595 if MBTEST(all_digit_token && (character == '<' || character == '>' || \
4596 last_read_token == LESS_AND || \
4597 last_read_token == GREATER_AND))
4599 if (legal_number (token, &lvalue) && (int)lvalue == lvalue)
4600 yylval.number = lvalue;
4606 /* Check for special case tokens. */
4607 result = (last_shell_getc_is_singlebyte) ? special_case_tokens (token) : -1;
4612 /* Posix.2 does not allow reserved words to be aliased, so check for all
4613 of them, including special cases, before expanding the current token
4615 if MBTEST(posixly_correct)
4616 CHECK_FOR_RESERVED_WORD (token);
4618 /* Aliases are expanded iff EXPAND_ALIASES is non-zero, and quoting
4619 inhibits alias expansion. */
4620 if (expand_aliases && quoted == 0)
4622 result = alias_expand_token (token);
4623 if (result == RE_READ_TOKEN)
4624 return (RE_READ_TOKEN);
4625 else if (result == NO_EXPANSION)
4626 parser_state &= ~PST_ALEXPNEXT;
4629 /* If not in Posix.2 mode, check for reserved words after alias
4631 if MBTEST(posixly_correct == 0)
4633 CHECK_FOR_RESERVED_WORD (token);
4635 the_word = (WORD_DESC *)xmalloc (sizeof (WORD_DESC));
4636 the_word->word = (char *)xmalloc (1 + token_index);
4637 the_word->flags = 0;
4638 strcpy (the_word->word, token);
4640 the_word->flags |= W_HASDOLLAR;
4642 the_word->flags |= W_QUOTED; /*(*/
4643 if (compound_assignment && token[token_index-1] == ')')
4644 the_word->flags |= W_COMPASSIGN;
4645 /* A word is an assignment if it appears at the beginning of a
4646 simple command, or after another assignment word. This is
4647 context-dependent, so it cannot be handled in the grammar. */
4648 if (assignment (token, (parser_state & PST_COMPASSIGN) != 0))
4650 the_word->flags |= W_ASSIGNMENT;
4651 /* Don't perform word splitting on assignment statements. */
4652 if (assignment_acceptable (last_read_token) || (parser_state & PST_COMPASSIGN) != 0)
4653 the_word->flags |= W_NOSPLIT;
4656 if (command_token_position (last_read_token))
4659 b = builtin_address_internal (token, 0);
4660 if (b && (b->flags & ASSIGNMENT_BUILTIN))
4661 parser_state |= PST_ASSIGNOK;
4662 else if (STREQ (token, "eval") || STREQ (token, "let"))
4663 parser_state |= PST_ASSIGNOK;
4666 yylval.word = the_word;
4668 if (token[0] == '{' && token[token_index-1] == '}' &&
4669 (character == '<' || character == '>'))
4671 /* can use token; already copied to the_word */
4672 token[token_index-1] = '\0';
4673 if (legal_identifier (token+1))
4675 strcpy (the_word->word, token+1);
4676 /*itrace("read_token_word: returning REDIR_WORD for %s", the_word->word);*/
4677 return (REDIR_WORD);
4681 result = ((the_word->flags & (W_ASSIGNMENT|W_NOSPLIT)) == (W_ASSIGNMENT|W_NOSPLIT))
4682 ? ASSIGNMENT_WORD : WORD;
4684 switch (last_read_token)
4687 parser_state |= PST_ALLOWOPNBRC;
4688 function_dstart = line_number;
4693 if (word_top < MAX_CASE_NEST)
4695 word_lineno[word_top] = line_number;
4702 /* Return 1 if TOKSYM is a token that after being read would allow
4703 a reserved word to be seen, else 0. */
4705 reserved_word_acceptable (toksym)
4741 #if defined (COPROCESS_SUPPORT)
4742 if (last_read_token == WORD && token_before_that == COPROC)
4749 /* Return the index of TOKEN in the alist of reserved words, or -1 if
4750 TOKEN is not a shell reserved word. */
4752 find_reserved_word (tokstr)
4756 for (i = 0; word_token_alist[i].word; i++)
4757 if (STREQ (tokstr, word_token_alist[i].word))
4763 #if defined (READLINE)
4764 /* Called after each time readline is called. This insures that whatever
4765 the new prompt string is gets propagated to readline's local prompt
4768 reset_readline_prompt ()
4772 if (prompt_string_pointer)
4774 temp_prompt = (*prompt_string_pointer)
4775 ? decode_prompt_string (*prompt_string_pointer)
4778 if (temp_prompt == 0)
4780 temp_prompt = (char *)xmalloc (1);
4781 temp_prompt[0] = '\0';
4784 FREE (current_readline_prompt);
4785 current_readline_prompt = temp_prompt;
4788 #endif /* READLINE */
4791 #if defined (HISTORY)
4792 /* A list of tokens which can be followed by newlines, but not by
4793 semi-colons. When concatenating multiple lines of history, the
4794 newline separator for such tokens is replaced with a space. */
4795 static const int no_semi_successors[] = {
4796 '\n', '{', '(', ')', ';', '&', '|',
4797 CASE, DO, ELSE, IF, SEMI_SEMI, SEMI_AND, SEMI_SEMI_AND, THEN, UNTIL,
4798 WHILE, AND_AND, OR_OR, IN,
4802 /* If we are not within a delimited expression, try to be smart
4803 about which separators can be semi-colons and which must be
4804 newlines. Returns the string that should be added into the
4807 history_delimiting_chars ()
4811 if (dstack.delimiter_depth != 0)
4814 /* We look for current_command_line_count == 2 because we are looking to
4815 add the first line of the body of the here document (the second line
4817 if (parser_state & PST_HEREDOC)
4818 return (current_command_line_count == 2 ? "\n" : "");
4820 /* First, handle some special cases. */
4822 /* If we just read `()', assume it's a function definition, and don't
4823 add a semicolon. If the token before the `)' was not `(', and we're
4824 not in the midst of parsing a case statement, assume it's a
4825 parenthesized command and add the semicolon. */
4827 if (token_before_that == ')')
4829 if (two_tokens_ago == '(') /*)*/ /* function def */
4831 /* This does not work for subshells inside case statement
4832 command lists. It's a suboptimal solution. */
4833 else if (parser_state & PST_CASESTMT) /* case statement pattern */
4836 return "; "; /* (...) subshell */
4838 else if (token_before_that == WORD && two_tokens_ago == FUNCTION)
4839 return " "; /* function def using `function name' without `()' */
4841 else if (token_before_that == WORD && two_tokens_ago == FOR)
4843 /* Tricky. `for i\nin ...' should not have a semicolon, but
4844 `for i\ndo ...' should. We do what we can. */
4845 for (i = shell_input_line_index; whitespace (shell_input_line[i]); i++)
4847 if (shell_input_line[i] && shell_input_line[i] == 'i' && shell_input_line[i+1] == 'n')
4851 else if (two_tokens_ago == CASE && token_before_that == WORD && (parser_state & PST_CASESTMT))
4854 for (i = 0; no_semi_successors[i]; i++)
4856 if (token_before_that == no_semi_successors[i])
4862 #endif /* HISTORY */
4864 /* Issue a prompt, or prepare to issue a prompt when the next character
4871 if (interactive == 0 || expanding_alias ()) /* XXX */
4874 ps1_prompt = get_string_value ("PS1");
4875 ps2_prompt = get_string_value ("PS2");
4877 if (!prompt_string_pointer)
4878 prompt_string_pointer = &ps1_prompt;
4880 temp_prompt = *prompt_string_pointer
4881 ? decode_prompt_string (*prompt_string_pointer)
4884 if (temp_prompt == 0)
4886 temp_prompt = (char *)xmalloc (1);
4887 temp_prompt[0] = '\0';
4890 current_prompt_string = *prompt_string_pointer;
4891 prompt_string_pointer = &ps2_prompt;
4893 #if defined (READLINE)
4894 if (!no_line_editing)
4896 FREE (current_readline_prompt);
4897 current_readline_prompt = temp_prompt;
4900 #endif /* READLINE */
4902 FREE (current_decoded_prompt);
4903 current_decoded_prompt = temp_prompt;
4908 get_current_prompt_level ()
4910 return ((current_prompt_string && current_prompt_string == ps2_prompt) ? 2 : 1);
4914 set_current_prompt_level (x)
4917 prompt_string_pointer = (x == 2) ? &ps2_prompt : &ps1_prompt;
4918 current_prompt_string = *prompt_string_pointer;
4924 fprintf (stderr, "%s", current_decoded_prompt);
4928 /* Return a string which will be printed as a prompt. The string
4929 may contain special characters which are decoded as follows:
4932 \d the date in Day Mon Date format
4933 \e escape (ascii 033)
4934 \h the hostname up to the first `.'
4936 \j the number of active jobs
4937 \l the basename of the shell's tty device name
4940 \s the name of the shell
4941 \t the time in 24-hour hh:mm:ss format
4942 \T the time in 12-hour hh:mm:ss format
4943 \@ the time in 12-hour hh:mm am/pm format
4944 \A the time in 24-hour hh:mm format
4945 \D{fmt} the result of passing FMT to strftime(3)
4947 \v the version of bash (e.g., 2.00)
4948 \V the release of bash, version + patchlevel (e.g., 2.00.0)
4949 \w the current working directory
4950 \W the last element of $PWD
4951 \! the history number of this command
4952 \# the command number of this command
4953 \$ a $ or a # if you are root
4954 \nnn character code nnn in octal
4956 \[ begin a sequence of non-printing chars
4957 \] end a sequence of non-printing chars
4959 #define PROMPT_GROWTH 48
4961 decode_prompt_string (string)
4966 struct dstack save_dstack;
4967 int last_exit_value, last_comsub_pid;
4968 #if defined (PROMPT_STRING_DECODE)
4969 int result_size, result_index;
4971 char *temp, octal_string[4];
4977 result = (char *)xmalloc (result_size = PROMPT_GROWTH);
4978 result[result_index = 0] = 0;
4979 temp = (char *)NULL;
4981 while (c = *string++)
4983 if (posixly_correct && c == '!')
4987 temp = savestring ("!");
4992 #if !defined (HISTORY)
4993 temp = savestring ("1");
4995 temp = itos (history_number ());
4996 #endif /* HISTORY */
4997 string--; /* add_string increments string again. */
5015 strncpy (octal_string, string, 3);
5016 octal_string[3] = '\0';
5018 n = read_octal (octal_string);
5019 temp = (char *)xmalloc (3);
5021 if (n == CTLESC || n == CTLNUL)
5038 for (c = 0; n != -1 && c < 3 && ISOCTAL (*string); c++)
5041 c = 0; /* tested at add_string: */
5049 /* Make the current time/date into a string. */
5050 (void) time (&the_time);
5051 tm = localtime (&the_time);
5054 n = strftime (timebuf, sizeof (timebuf), "%a %b %d", tm);
5056 n = strftime (timebuf, sizeof (timebuf), "%H:%M:%S", tm);
5058 n = strftime (timebuf, sizeof (timebuf), "%I:%M:%S", tm);
5060 n = strftime (timebuf, sizeof (timebuf), "%I:%M %p", tm);
5062 n = strftime (timebuf, sizeof (timebuf), "%H:%M", tm);
5067 timebuf[sizeof(timebuf) - 1] = '\0';
5069 temp = savestring (timebuf);
5072 case 'D': /* strftime format */
5073 if (string[1] != '{') /* } */
5076 (void) time (&the_time);
5077 tm = localtime (&the_time);
5078 string += 2; /* skip { */
5079 timefmt = xmalloc (strlen (string) + 3);
5080 for (t = timefmt; *string && *string != '}'; )
5083 c = *string; /* tested at add_string */
5084 if (timefmt[0] == '\0')
5087 timefmt[1] = 'X'; /* locale-specific current time */
5090 n = strftime (timebuf, sizeof (timebuf), timefmt, tm);
5096 timebuf[sizeof(timebuf) - 1] = '\0';
5098 if (promptvars || posixly_correct)
5099 /* Make sure that expand_prompt_string is called with a
5100 second argument of Q_DOUBLE_QUOTES if we use this
5102 temp = sh_backslash_quote_for_double_quotes (timebuf);
5104 temp = savestring (timebuf);
5108 temp = (char *)xmalloc (3);
5109 temp[0] = no_line_editing ? '\n' : '\r';
5110 temp[1] = no_line_editing ? '\0' : '\n';
5115 temp = base_pathname (shell_name);
5116 temp = savestring (temp);
5121 temp = (char *)xmalloc (16);
5123 strcpy (temp, dist_version);
5125 sprintf (temp, "%s.%d", dist_version, patch_level);
5131 /* Use the value of PWD because it is much more efficient. */
5132 char t_string[PATH_MAX];
5135 temp = get_string_value ("PWD");
5139 if (getcwd (t_string, sizeof(t_string)) == 0)
5145 tlen = strlen (t_string);
5149 tlen = sizeof (t_string) - 1;
5150 strncpy (t_string, temp, tlen);
5152 t_string[tlen] = '\0';
5154 #if defined (MACOSX)
5155 /* Convert from "fs" format to "input" format */
5156 temp = fnx_fromfs (t_string, strlen (t_string));
5157 if (temp != t_string)
5158 strcpy (t_string, temp);
5161 #define ROOT_PATH(x) ((x)[0] == '/' && (x)[1] == 0)
5162 #define DOUBLE_SLASH_ROOT(x) ((x)[0] == '/' && (x)[1] == '/' && (x)[2] == 0)
5163 /* Abbreviate \W as ~ if $PWD == $HOME */
5164 if (c == 'W' && (((t = get_string_value ("HOME")) == 0) || STREQ (t, t_string) == 0))
5166 if (ROOT_PATH (t_string) == 0 && DOUBLE_SLASH_ROOT (t_string) == 0)
5168 t = strrchr (t_string, '/');
5170 strcpy (t_string, t + 1);
5174 #undef DOUBLE_SLASH_ROOT
5176 /* polite_directory_format is guaranteed to return a string
5177 no longer than PATH_MAX - 1 characters. */
5178 strcpy (t_string, polite_directory_format (t_string));
5180 temp = trim_pathname (t_string, PATH_MAX - 1);
5181 /* If we're going to be expanding the prompt string later,
5182 quote the directory name. */
5183 if (promptvars || posixly_correct)
5184 /* Make sure that expand_prompt_string is called with a
5185 second argument of Q_DOUBLE_QUOTES if we use this
5187 temp = sh_backslash_quote_for_double_quotes (t_string);
5189 temp = savestring (t_string);
5195 if (current_user.user_name == 0)
5196 get_current_user_info ();
5197 temp = savestring (current_user.user_name);
5202 temp = savestring (current_host_name);
5203 if (c == 'h' && (t = (char *)strchr (temp, '.')))
5208 temp = itos (current_command_number);
5212 #if !defined (HISTORY)
5213 temp = savestring ("1");
5215 temp = itos (history_number ());
5216 #endif /* HISTORY */
5220 t = temp = (char *)xmalloc (3);
5221 if ((promptvars || posixly_correct) && (current_user.euid != 0))
5223 *t++ = current_user.euid == 0 ? '#' : '$';
5228 temp = itos (count_all_jobs ());
5232 #if defined (HAVE_TTYNAME)
5233 temp = (char *)ttyname (fileno (stdin));
5234 t = temp ? base_pathname (temp) : "tty";
5235 temp = savestring (t);
5237 temp = savestring ("tty");
5238 #endif /* !HAVE_TTYNAME */
5241 #if defined (READLINE)
5244 if (no_line_editing)
5249 temp = (char *)xmalloc (3);
5250 n = (c == '[') ? RL_PROMPT_START_IGNORE : RL_PROMPT_END_IGNORE;
5252 if (n == CTLESC || n == CTLNUL)
5257 #endif /* READLINE */
5263 temp = (char *)xmalloc (2);
5270 else /* (c == '\\') */
5277 temp = (char *)xmalloc (3);
5286 sub_append_string (temp, result, &result_index, &result_size);
5287 temp = (char *)NULL; /* Freed in sub_append_string (). */
5288 result[result_index] = '\0';
5294 RESIZE_MALLOCED_BUFFER (result, result_index, 3, result_size, PROMPT_GROWTH);
5295 result[result_index++] = c;
5296 result[result_index] = '\0';
5299 #else /* !PROMPT_STRING_DECODE */
5300 result = savestring (string);
5301 #endif /* !PROMPT_STRING_DECODE */
5303 /* Save the delimiter stack and point `dstack' to temp space so any
5304 command substitutions in the prompt string won't result in screwing
5305 up the parser's quoting state. */
5306 save_dstack = dstack;
5307 dstack = temp_dstack;
5308 dstack.delimiter_depth = 0;
5310 /* Perform variable and parameter expansion and command substitution on
5311 the prompt string. */
5312 if (promptvars || posixly_correct)
5314 last_exit_value = last_command_exit_value;
5315 last_comsub_pid = last_command_subst_pid;
5316 list = expand_prompt_string (result, Q_DOUBLE_QUOTES, 0);
5318 result = string_list (list);
5319 dispose_words (list);
5320 last_command_exit_value = last_exit_value;
5321 last_command_subst_pid = last_comsub_pid;
5325 t = dequote_string (result);
5330 dstack = save_dstack;
5335 /************************************************
5339 ************************************************/
5341 /* Report a syntax error, and restart the parser. Call here for fatal
5347 report_syntax_error ((char *)NULL);
5353 error_token_from_token (tok)
5358 if (t = find_token_in_alist (tok, word_token_alist, 0))
5361 if (t = find_token_in_alist (tok, other_token_alist, 0))
5365 /* This stuff is dicy and needs closer inspection */
5366 switch (current_token)
5369 case ASSIGNMENT_WORD:
5371 t = savestring (yylval.word->word);
5374 t = itos (yylval.number);
5377 if (yylval.word_list)
5378 t = string_list (yylval.word_list);
5380 case ARITH_FOR_EXPRS:
5381 if (yylval.word_list)
5382 t = string_list_internal (yylval.word_list, " ; ");
5385 t = (char *)NULL; /* punt */
5393 error_token_from_text ()
5398 t = shell_input_line;
5399 i = shell_input_line_index;
5403 if (i && t[i] == '\0')
5406 while (i && (whitespace (t[i]) || t[i] == '\n'))
5412 while (i && (member (t[i], " \n\t;|&") == 0))
5415 while (i != token_end && (whitespace (t[i]) || t[i] == '\n'))
5418 /* Return our idea of the offending token. */
5419 if (token_end || (i == 0 && token_end == 0))
5422 msg = substring (t, i, token_end);
5423 else /* one-character token */
5425 msg = (char *)xmalloc (2);
5435 print_offending_line ()
5440 msg = savestring (shell_input_line);
5441 token_end = strlen (msg);
5442 while (token_end && msg[token_end - 1] == '\n')
5443 msg[--token_end] = '\0';
5445 parser_error (line_number, "`%s'", msg);
5449 /* Report a syntax error with line numbers, etc.
5450 Call here for recoverable errors. If you have a message to print,
5451 then place it in MESSAGE, otherwise pass NULL and this will figure
5452 out an appropriate message for you. */
5454 report_syntax_error (message)
5461 parser_error (line_number, "%s", message);
5462 if (interactive && EOF_Reached)
5464 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5468 /* If the line of input we're reading is not null, try to find the
5469 objectionable token. First, try to figure out what token the
5470 parser's complaining about by looking at current_token. */
5471 if (current_token != 0 && EOF_Reached == 0 && (msg = error_token_from_token (current_token)))
5473 parser_error (line_number, _("syntax error near unexpected token `%s'"), msg);
5476 if (interactive == 0)
5477 print_offending_line ();
5479 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5483 /* If looking at the current token doesn't prove fruitful, try to find the
5484 offending token by analyzing the text of the input line near the current
5485 input line index and report what we find. */
5486 if (shell_input_line && *shell_input_line)
5488 msg = error_token_from_text ();
5491 parser_error (line_number, _("syntax error near `%s'"), msg);
5495 /* If not interactive, print the line containing the error. */
5496 if (interactive == 0)
5497 print_offending_line ();
5501 msg = EOF_Reached ? _("syntax error: unexpected end of file") : _("syntax error");
5502 parser_error (line_number, "%s", msg);
5503 /* When the shell is interactive, this file uses EOF_Reached
5504 only for error reporting. Other mechanisms are used to
5505 decide whether or not to exit. */
5506 if (interactive && EOF_Reached)
5510 last_command_exit_value = parse_and_execute_level ? EX_BADSYNTAX : EX_BADUSAGE;
5513 /* ??? Needed function. ??? We have to be able to discard the constructs
5514 created during parsing. In the case of error, we want to return
5515 allocated objects to the memory pool. In the case of no error, we want
5516 to throw away the information about where the allocated objects live.
5517 (dispose_command () will actually free the command.) */
5519 discard_parser_constructs (error_p)
5524 /************************************************
5528 ************************************************/
5530 /* Do that silly `type "bye" to exit' stuff. You know, "ignoreeof". */
5532 /* A flag denoting whether or not ignoreeof is set. */
5535 /* The number of times that we have encountered an EOF character without
5536 another character intervening. When this gets above the limit, the
5537 shell terminates. */
5538 int eof_encountered = 0;
5540 /* The limit for eof_encountered. */
5541 int eof_encountered_limit = 10;
5543 /* If we have EOF as the only input unit, this user wants to leave
5544 the shell. If the shell is not interactive, then just leave.
5545 Otherwise, if ignoreeof is set, and we haven't done this the
5546 required number of times in a row, print a message. */
5548 handle_eof_input_unit ()
5552 /* shell.c may use this to decide whether or not to write out the
5553 history, among other things. We use it only for error reporting
5558 /* If the user wants to "ignore" eof, then let her do so, kind of. */
5561 if (eof_encountered < eof_encountered_limit)
5563 fprintf (stderr, _("Use \"%s\" to leave the shell.\n"),
5564 login_shell ? "logout" : "exit");
5566 /* Reset the parsing state. */
5567 last_read_token = current_token = '\n';
5568 /* Reset the prompt string to be $PS1. */
5569 prompt_string_pointer = (char **)NULL;
5575 /* In this case EOF should exit the shell. Do it now. */
5577 exit_builtin ((WORD_LIST *)NULL);
5581 /* We don't write history files, etc., for non-interactive shells. */
5586 /************************************************
5588 * STRING PARSING FUNCTIONS *
5590 ************************************************/
5592 /* It's very important that these two functions treat the characters
5593 between ( and ) identically. */
5595 static WORD_LIST parse_string_error;
5597 /* Take a string and run it through the shell parser, returning the
5598 resultant word list. Used by compound array assignment. */
5600 parse_string_to_word_list (s, flags, whom)
5606 int tok, orig_current_token, orig_line_number, orig_input_terminator;
5607 int orig_line_count;
5608 int old_echo_input, old_expand_aliases;
5609 #if defined (HISTORY)
5610 int old_remember_on_history, old_history_expansion_inhibited;
5613 #if defined (HISTORY)
5614 old_remember_on_history = remember_on_history;
5615 # if defined (BANG_HISTORY)
5616 old_history_expansion_inhibited = history_expansion_inhibited;
5618 bash_history_disable ();
5621 orig_line_number = line_number;
5622 orig_line_count = current_command_line_count;
5623 orig_input_terminator = shell_input_line_terminator;
5624 old_echo_input = echo_input_at_read;
5625 old_expand_aliases = expand_aliases;
5628 last_read_token = WORD; /* WORD to allow reserved words here */
5629 current_command_line_count = 0;
5630 echo_input_at_read = expand_aliases = 0;
5632 with_input_from_string (s, whom);
5633 wl = (WORD_LIST *)NULL;
5636 parser_state |= PST_COMPASSIGN|PST_REPARSE;
5638 while ((tok = read_token (READ)) != yacc_EOF)
5640 if (tok == '\n' && *bash_input.location.string == '\0')
5642 if (tok == '\n') /* Allow newlines in compound assignments */
5644 if (tok != WORD && tok != ASSIGNMENT_WORD)
5646 line_number = orig_line_number + line_number - 1;
5647 orig_current_token = current_token;
5648 current_token = tok;
5649 yyerror (NULL); /* does the right thing */
5650 current_token = orig_current_token;
5653 wl = &parse_string_error;
5656 wl = make_word_list (yylval.word, wl);
5659 last_read_token = '\n';
5662 #if defined (HISTORY)
5663 remember_on_history = old_remember_on_history;
5664 # if defined (BANG_HISTORY)
5665 history_expansion_inhibited = old_history_expansion_inhibited;
5666 # endif /* BANG_HISTORY */
5667 #endif /* HISTORY */
5669 echo_input_at_read = old_echo_input;
5670 expand_aliases = old_expand_aliases;
5672 current_command_line_count = orig_line_count;
5673 shell_input_line_terminator = orig_input_terminator;
5676 parser_state &= ~(PST_COMPASSIGN|PST_REPARSE);
5678 if (wl == &parse_string_error)
5680 last_command_exit_value = EXECUTION_FAILURE;
5681 if (interactive_shell == 0 && posixly_correct)
5682 jump_to_top_level (FORCE_EOF);
5684 jump_to_top_level (DISCARD);
5687 return (REVERSE_LIST (wl, WORD_LIST *));
5691 parse_compound_assignment (retlenp)
5695 int tok, orig_line_number, orig_token_size, orig_last_token, assignok;
5696 char *saved_token, *ret;
5698 saved_token = token;
5699 orig_token_size = token_buffer_size;
5700 orig_line_number = line_number;
5701 orig_last_token = last_read_token;
5703 last_read_token = WORD; /* WORD to allow reserved words here */
5705 token = (char *)NULL;
5706 token_buffer_size = 0;
5708 assignok = parser_state&PST_ASSIGNOK; /* XXX */
5710 wl = (WORD_LIST *)NULL; /* ( */
5711 parser_state |= PST_COMPASSIGN;
5713 while ((tok = read_token (READ)) != ')')
5715 if (tok == '\n') /* Allow newlines in compound assignments */
5717 if (SHOULD_PROMPT ())
5721 if (tok != WORD && tok != ASSIGNMENT_WORD)
5723 current_token = tok; /* for error reporting */
5724 if (tok == yacc_EOF) /* ( */
5725 parser_error (orig_line_number, _("unexpected EOF while looking for matching `)'"));
5727 yyerror(NULL); /* does the right thing */
5730 wl = &parse_string_error;
5733 wl = make_word_list (yylval.word, wl);
5737 token = saved_token;
5738 token_buffer_size = orig_token_size;
5740 parser_state &= ~PST_COMPASSIGN;
5742 if (wl == &parse_string_error)
5744 last_command_exit_value = EXECUTION_FAILURE;
5745 last_read_token = '\n'; /* XXX */
5746 if (interactive_shell == 0 && posixly_correct)
5747 jump_to_top_level (FORCE_EOF);
5749 jump_to_top_level (DISCARD);
5752 last_read_token = orig_last_token; /* XXX - was WORD? */
5756 rl = REVERSE_LIST (wl, WORD_LIST *);
5757 ret = string_list (rl);
5764 *retlenp = (ret && *ret) ? strlen (ret) : 0;
5767 parser_state |= PST_ASSIGNOK;
5772 /************************************************
5774 * SAVING AND RESTORING PARTIAL PARSE STATE *
5776 ************************************************/
5779 save_parser_state (ps)
5780 sh_parser_state_t *ps;
5782 #if defined (ARRAY_VARS)
5787 ps = (sh_parser_state_t *)xmalloc (sizeof (sh_parser_state_t));
5789 return ((sh_parser_state_t *)NULL);
5791 ps->parser_state = parser_state;
5792 ps->token_state = save_token_state ();
5794 ps->input_line_terminator = shell_input_line_terminator;
5795 ps->eof_encountered = eof_encountered;
5797 ps->current_command_line_count = current_command_line_count;
5799 #if defined (HISTORY)
5800 ps->remember_on_history = remember_on_history;
5801 # if defined (BANG_HISTORY)
5802 ps->history_expansion_inhibited = history_expansion_inhibited;
5806 ps->last_command_exit_value = last_command_exit_value;
5807 #if defined (ARRAY_VARS)
5808 v = find_variable ("PIPESTATUS");
5809 if (v && array_p (v) && array_cell (v))
5810 ps->pipestatus = array_copy (array_cell (v));
5812 ps->pipestatus = (ARRAY *)NULL;
5815 ps->last_shell_builtin = last_shell_builtin;
5816 ps->this_shell_builtin = this_shell_builtin;
5818 ps->expand_aliases = expand_aliases;
5819 ps->echo_input_at_read = echo_input_at_read;
5825 restore_parser_state (ps)
5826 sh_parser_state_t *ps;
5828 #if defined (ARRAY_VARS)
5835 parser_state = ps->parser_state;
5836 if (ps->token_state)
5838 restore_token_state (ps->token_state);
5839 free (ps->token_state);
5842 shell_input_line_terminator = ps->input_line_terminator;
5843 eof_encountered = ps->eof_encountered;
5845 current_command_line_count = ps->current_command_line_count;
5847 #if defined (HISTORY)
5848 remember_on_history = ps->remember_on_history;
5849 # if defined (BANG_HISTORY)
5850 history_expansion_inhibited = ps->history_expansion_inhibited;
5854 last_command_exit_value = ps->last_command_exit_value;
5855 #if defined (ARRAY_VARS)
5856 v = find_variable ("PIPESTATUS");
5857 if (v && array_p (v) && array_cell (v))
5859 array_dispose (array_cell (v));
5860 var_setarray (v, ps->pipestatus);
5864 last_shell_builtin = ps->last_shell_builtin;
5865 this_shell_builtin = ps->this_shell_builtin;
5867 expand_aliases = ps->expand_aliases;
5868 echo_input_at_read = ps->echo_input_at_read;
5871 /************************************************
5873 * MULTIBYTE CHARACTER HANDLING *
5875 ************************************************/
5877 #if defined (HANDLE_MULTIBYTE)
5881 int i, previ, len, c;
5882 mbstate_t mbs, prevs;
5885 if (shell_input_line == NULL)
5887 len = strlen (shell_input_line); /* XXX - shell_input_line_len ? */
5888 FREE (shell_input_line_property);
5889 shell_input_line_property = (char *)xmalloc (len + 1);
5891 memset (&prevs, '\0', sizeof (mbstate_t));
5892 for (i = previ = 0; i < len; i++)
5896 c = shell_input_line[i];
5900 for (j = i; j < len; j++)
5901 shell_input_line_property[j] = 1;
5905 mbclen = mbrlen (shell_input_line + previ, i - previ + 1, &mbs);
5906 if (mbclen == 1 || mbclen == (size_t)-1)
5911 else if (mbclen == (size_t)-2)
5913 else if (mbclen > 1)
5921 /* XXX - what to do if mbrlen returns 0? (null wide character) */
5923 for (j = i; j < len; j++)
5924 shell_input_line_property[j] = 1;
5928 shell_input_line_property[i] = mbclen;
5931 #endif /* HANDLE_MULTIBYTE */